By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
425,647 Members | 1,178 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 425,647 IT Pros & Developers. It's quick & easy.

Order of uknown array subscript

P: n/a
Hello all

I have a question that may or may not be simple - I need my three
dimensional array to be of the form:

array[jj][kk][ii]

where jj and kk range from 0 to some constant fixed at the very beginnning
of the program (currently 20) but [ii] goes from 0 to some boundary that
depends on calculations performed within the program. I know it is possible
to do this:

double (*somearray)[fixed][fixed]= new double[variable
expression][fixed][fixed]

but can I have the last subscript as variable? - this is not just a question
of hypothetics, but a need to have the data in this format as an external
procedure expects the data with the first and second dimensions to be one
type of data (which has a fixed size) and the third dimension to have a
variable size.

Many thanks for any help!

Currently I do this:

const int griddef=20;
int somefunction(unsigned int wldepth,other arguments...)
int status, ii, jj, kk;

double *array[griddef][wldepth]; /*<------This doesn't work as wldepth is a
variable, but it shows what I want to do!*/

long naxes[3] = { griddef, griddef,wldepth };

array[0][0] = (double *)malloc( naxes[0] * naxes[1] * naxes[2] * sizeof(
double ) );

for(jj=0;jj<griddef;jj++)

{

for(ii=0;ii<griddef;ii++)

{

array[jj][ii] = array[0][0] + griddef*(griddef*jj+ii);

}

}

for(kk=0;kk<griddef;kk++)

{

for (jj=0;jj<griddef;jj++)

{

for (ii=0;ii<wldepth;ii++)

{

array[jj][kk][ii] = some calculation based on ii,jj and kk;

}

}

}

return 0;

}
Jul 22 '05 #1
Share this Question
Share on Google+
4 Replies


P: n/a
"Tom Page" <t.******@durham.ac.uk> wrote...
Hello all

I have a question that may or may not be simple - I need my three
dimensional array to be of the form:

array[jj][kk][ii]

where jj and kk range from 0 to some constant fixed at the very beginnning
of the program (currently 20) but [ii] goes from 0 to some boundary that
depends on calculations performed within the program. I know it is possible to do this:

double (*somearray)[fixed][fixed]= new double[variable
expression][fixed][fixed]

but can I have the last subscript as variable? - this is not just a question of hypothetics, but a need to have the data in this format as an external
procedure expects the data with the first and second dimensions to be one
type of data (which has a fixed size) and the third dimension to have a
variable size.
There are several ways to skin your cat. You can have a two-dimensional
array of vector<double>. You can have an array of pointers each of which
is dynamically allocated, almost like you did below (I snipped it, but you
know what I am talking about), you just need to do

double *tda[fixed1][fixed2], **ptda = &tda[0][0];
for (int i = 0; i < fixed1 * fixed2; ++i)
ptda[i] = new double[variable];

thus allocating 'variable' doubles for each of tda elements. Now access
them using

tda[jj][kk][ii]
[...]


Also take a look at the FAQ, see "Dynamic multidimensional arrays".

Victor
Jul 22 '05 #2

P: n/a
Victor

Thanks so much for your response. I am having some troubles with it though.
I have posted my efforts on to a web site to avoid copying large amounts of
code into the message - it's not very long but I thought it would be
cleaner.

http://www.tompagenet.co.uk/fits.php

there are links on the right to my original code (as hinted at in my first
post) and the code that I created after your suggestions. The new code fails
to run, almost certainly because of the:
fits_write_img(fptr, TDOUBLE, fpixel, nelements, array[0][0], &status)line
in the code. This calls an external procedure (one of the CFITSIO
procedures - http://heasarc.gsfc.nasa.gov/docs/so...io/fitsio.html
for those who are interested).The trouble is that this appears to expect an
array of the form array[0][0] (which is two dimensional, but then it knows
it is three dimensional and works out the third dimension by using the
nelements argument which explains the total number of elements and thus if
you know two dimensions it can calculate the third.Should it be of
importance, these are the argements both procedures take:* wldepth - the
size of the dynamic array dimension (the other two are of static size
griddef)* inarray[][griddef][griddef] - the inputed array (basically the
data to write out by the procedure seen above)* line - a number that simply
alters the filename (irrelevant)* type - ditto (irrelevant)Thanks for any
help with this, it is very much appreciated!Thanks, Tom
"Victor Bazarov" <v.********@comAcast.net> wrote in message
news:YPcYb.46506$_44.44246@attbi_s52...
"Tom Page" <t.******@durham.ac.uk> wrote...
Hello all

I have a question that may or may not be simple - I need my three
dimensional array to be of the form:

array[jj][kk][ii]

where jj and kk range from 0 to some constant fixed at the very
beginnning
of the program (currently 20) but [ii] goes from 0 to some boundary that
depends on calculations performed within the program. I know it is

possible
to do this:

double (*somearray)[fixed][fixed]= new double[variable
expression][fixed][fixed]

but can I have the last subscript as variable? - this is not just a

question
of hypothetics, but a need to have the data in this format as an external
procedure expects the data with the first and second dimensions to be one
type of data (which has a fixed size) and the third dimension to have a
variable size.


There are several ways to skin your cat. You can have a two-dimensional
array of vector<double>. You can have an array of pointers each of which
is dynamically allocated, almost like you did below (I snipped it, but you
know what I am talking about), you just need to do

double *tda[fixed1][fixed2], **ptda = &tda[0][0];
for (int i = 0; i < fixed1 * fixed2; ++i)
ptda[i] = new double[variable];

thus allocating 'variable' doubles for each of tda elements. Now access
them using

tda[jj][kk][ii]
[...]


Also take a look at the FAQ, see "Dynamic multidimensional arrays".

Victor

Jul 22 '05 #3

P: n/a
/*Sorry - the post should have read*/

Victor

Thanks so much for your response. I am having some troubles with it though.
I have posted my efforts on to a web site to avoid copying large amounts of
code into the message - it's not very long but I thought it would be
cleaner.

http://www.tompagenet.co.uk/fits.php

there are links on the right to my original code (as hinted at in my first
post) and the code that I created after your suggestions. The new code fails
to run, almost certainly because of the:
fits_write_img(fptr, TDOUBLE, fpixel, nelements, array[0][0], &status)

line in the code. This calls an external procedure (one of the CFITSIO
procedures - http://heasarc.gsfc.nasa.gov/docs/so...io/fitsio.html
for those who are interested).

The trouble is that this appears to expect an array of the form array[0][0]
(which is two dimensional, but then it knows it is three dimensional and
works out the third dimension by using the nelements argument which explains
the total number of elements and thus if you know two dimensions it can
calculate the third.

Should it be of importance, these are the argements both procedures take:
* wldepth - the size of the dynamic array dimension (the other two are of
static size griddef)
* inarray[][griddef][griddef] - the inputed array (basically the data to
write out by the procedure seen above)
* line - a number that simply alters the filename (irrelevant)
* type - ditto (irrelevant)

Thanks for any help with this, it is very much appreciated!

Thanks, Tom
Jul 22 '05 #4

P: n/a
"Tom Page" <t.******@durham.ac.uk> wrote...
/*Sorry - the post should have read*/

Victor

Thanks so much for your response. I am having some troubles with it though. [...]


My fault, probably.

This is what I meant to supply as an example:

const int griddef = 100;

void foo(double *inarray[griddef][griddef], int thirddim)
{
for (int kk = 0; kk < griddef; ++kk)
for (int jj = 0; jj < griddef; ++jj)
for (int ii = 0; ii < thirddim; ++ii)
inarray[kk][jj][ii] = 3.1415926;
}

int main()
{
double *myarray[griddef][griddef];

int third_dimension = 20;

for (int kk = 0; kk < griddef; ++kk)
for (int jj = 0; jj < griddef; ++jj)
myarray[kk][jj] = new double[third_dimension];

foo(myarray, third_dimension);

for (int kk = 0; kk < griddef; ++kk)
for (int jj = 0; jj < griddef; ++jj)
delete[] myarray[kk][jj];
}

Victor
Jul 22 '05 #5

This discussion thread is closed

Replies have been disabled for this discussion.