void index_alloc_real_array(const real_array_t * source,
const index_spec_t* source_spec,
real_array_t* dest)
{
int i;
int j;
omc_assert_macro(base_array_ok(source));
omc_assert_macro(index_spec_ok(source_spec));
omc_assert_macro(index_spec_fit_base_array(source_spec, source));
for(i = 0, j = 0; i < source_spec->ndims; ++i) {
if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
++j;
}
}
dest->ndims = j;
dest->dim_size = size_alloc(dest->ndims);
for(i = 0, j = 0; i < source_spec->ndims; ++i) {
if(source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
if(source_spec->index[i] != NULL) { /* is 'A' */
dest->dim_size[j] = source_spec->dim_size[i];
} else { /* is 'W' */
dest->dim_size[j] = source->dim_size[i];
}
++j;
}
}
alloc_real_array_data(dest);
index_real_array(source, source_spec, dest);
}
size_t calc_base_index_spec(int ndims, const _index_t *idx_vec,
const base_array_t *arr, const index_spec_t *spec)
{
/* idx_vec is zero based */
/* spec is one based */
int i;
int d,d2;
size_t index = 0;
assert(base_array_ok(arr));
assert(index_spec_ok(spec));
assert(index_spec_fit_base_array(spec, arr));
assert((ndims == arr->ndims) && (ndims == spec->ndims));
index = 0;
for (i = 0; i < ndims; ++i) {
d = idx_vec[i];
if (spec->index[i] != NULL) {
d2 = spec->index[i][d] - 1;
} else {
d2 = d;
}
index = (index * arr->dim_size[i]) + d2;
}
return index;
}
void index_boolean_array(const boolean_array_t* source,
const index_spec_t* source_spec,
boolean_array_t* dest)
{
_index_t* idx_vec1;
_index_t* idx_vec2;
_index_t* idx_size;
int j;
int i;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec,source));
for(i = 0, j = 0; i < source->ndims; ++i) {
if((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
++j;
}
}
assert(j == dest->ndims);
idx_vec1 = size_alloc(source->ndims); /*indices in the source array*/
idx_vec2 = size_alloc(dest->ndims); /* indices in the destination array*/
idx_size = size_alloc(source_spec->ndims);
for(i = 0; i < source->ndims; ++i) {
idx_vec1[i] = 0;
}
for(i = 0; i < source_spec->ndims; ++i) {
if(source_spec->index[i]) {
idx_size[i] = imax(source_spec->dim_size[i],1);
} else {
idx_size[i] = source->dim_size[i];
}
}
do {
for(i = 0, j = 0; i < source->ndims; ++i) {
if((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
idx_vec2[j] = idx_vec1[i];
j++;
}
}
boolean_set(dest, calc_base_index(dest->ndims, idx_vec2, dest),
boolean_get(*source,
calc_base_index_spec(source->ndims, idx_vec1,
source, source_spec)));
} while(0 == next_index(source->ndims, idx_vec1, idx_size));
}
void indexed_assign_string_array(const string_array_t * source,
string_array_t* dest,
const index_spec_t* dest_spec)
{
_index_t* idx_vec1;
_index_t* idx_vec2;
_index_t* idx_size;
int i,j;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(dest_spec));
assert(index_spec_fit_base_array(dest_spec, dest));
for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
if(dest_spec->dim_size[i] != 0) {
++j;
}
}
assert(j == source->ndims);
idx_vec1 = size_alloc(dest->ndims);
idx_vec2 = size_alloc(source->ndims);
idx_size = size_alloc(dest_spec->ndims);
for(i = 0; i < dest_spec->ndims; ++i) {
idx_vec1[i] = 0;
if(dest_spec->index[i] != NULL) {
idx_size[i] = imax(dest_spec->dim_size[i],1);
} else {
idx_size[i] = dest->dim_size[i];
}
}
do {
for(i = 0, j = 0; i < dest_spec->ndims; ++i) {
if(dest_spec->dim_size[i] != 0) {
idx_vec2[j] = idx_vec1[i];
++j;
}
}
string_set(dest, calc_base_index_spec(dest->ndims, idx_vec1,
dest, dest_spec),
string_get(*source, calc_base_index(source->ndims,
idx_vec2, source)));
} while(0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
}
void indexed_assign_real_array(const real_array_t source, real_array_t* dest,
const index_spec_t* dest_spec)
{
_index_t* idx_vec1;
_index_t* idx_size;
int i,j;
omc_assert_macro(base_array_ok(&source));
omc_assert_macro(base_array_ok(dest));
omc_assert_macro(index_spec_ok(dest_spec));
omc_assert_macro(index_spec_fit_base_array(dest_spec, dest));
for(i = 0,j = 0; i < dest_spec->ndims; ++i) {
if(dest_spec->dim_size[i] != 0) {
++j;
}
}
omc_assert_macro(j == source.ndims);
idx_vec1 = size_alloc(dest->ndims);
idx_size = size_alloc(dest_spec->ndims);
for(i = 0; i < dest_spec->ndims; ++i) {
idx_vec1[i] = 0;
if(dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
idx_size[i] = imax(dest_spec->dim_size[i],1);
} else { /* is 'W' */
idx_size[i] = dest->dim_size[i];
}
}
j = 0;
do {
real_set(dest,
calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec),
real_get(source, j));
j++;
} while(0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
omc_assert_macro(j == base_array_nr_of_elements(source));
}
void index_alloc_string_array(const string_array_t * source,
const index_spec_t* source_spec,
string_array_t* dest)
{
int i;
int j;
int ndimsdiff;
assert(base_array_ok(source));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec, source));
ndimsdiff = 0;
for(i = 0; i < source_spec->ndims; ++i) {
if((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
ndimsdiff--;
}
}
dest->ndims = source->ndims + ndimsdiff;
dest->dim_size = size_alloc(dest->ndims);
for(i = 0,j = 0; i < dest->ndims; ++i) {
while(source_spec->index_type[i+j] == 'S') { /* Skip scalars */
j++;
}
if(source_spec->index_type[i+j] == 'W') { /*take whole dimension from source*/
dest->dim_size[i]=source->dim_size[i+j];
} else if(source_spec->index_type[i+j] == 'A') { /* Take dimension size from splice*/
dest->dim_size[i]=source_spec->dim_size[i+j];
}
}
alloc_string_array_data(dest);
index_string_array(source, source_spec, dest);
}
void index_alloc_real_array(const real_array_t * source,
const index_spec_t* source_spec,
real_array_t* dest)
{
int i;
int j;
/*int ndimsdiff;*/
assert(base_array_ok(source));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec, source));
/*
ndimsdiff = 0;
for (i = 0; i < source_spec->ndims; ++i) {
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A'))
ndimsdiff--;
}
/ * !!! this is a major bug here, it should be
* dest->ndims = -ndimsdiff;
* for example in
* (to be allocated)dest := source[{2,3}];
* it leads to 0 ndims ... 1 - 1
* and, in the next lines,
* memory was written after its allocated area (not used in fact)
* /
dest->ndims = source->ndims + ndimsdiff;
assert(dest->ndims > 0); / * dest->ndims <= 0 was happenning ... * /
dest->dim_size = size_alloc(0,dest->ndims);
for (i = 0,j = 0; i < dest->ndims; ++i) {
/ * !!! a little bug is here !!!
* When source_spec is in line with dest, everything is ok,
* for every dest dimension there has to be a 'W' or 'A',
* but when the input is incorrect, what is not tested/asserted yet,
* there can be the last index_type[i+j] == 'S'
* --> index out of bounds
* --> corrupted memory in the next lines --> nondeterministic behavior
* /
while (source_spec->index_type[i+j] == 'S') ++j; / * Skip scalars * /
if (source_spec->index_type[i+j] == 'W') { / *take whole dimension from source* /
dest->dim_size[i]=source->dim_size[i+j];
} else if (source_spec->index_type[i+j] == 'A') { / * Take dimension size from splice* /
dest->dim_size[i]=source_spec->dim_size[i+j];
}
}
*/
for (i = 0, j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
++j;
}
}
dest->ndims = j;
dest->dim_size = size_alloc(0,dest->ndims);
for (i = 0, j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) { /* is 'W' or 'A' */
if(source_spec->index[i] != NULL) { /* is 'A' */
dest->dim_size[j] = source_spec->dim_size[i];
} else { /* is 'W' */
dest->dim_size[j] = source->dim_size[i];
}
++j;
}
}
alloc_real_array_data(dest);
index_real_array(source, source_spec, dest);
}
void index_real_array(const real_array_t * source,
const index_spec_t* source_spec,
real_array_t* dest)
{
_index_t* idx_vec1;
_index_t* idx_size;
int j;
int i;
state mem_state;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(source_spec));
assert(index_spec_fit_base_array(source_spec,source));
/*for (i = 0, j = 0; i < source->ndims; ++i)
{
printf("source_spec->index_type[%d] = %c\n", i, source_spec->index_type[i]);
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A'))
++j;
}
assert(j == dest->ndims);*/
for (i = 0,j = 0; i < source_spec->ndims; ++i) {
if (source_spec->dim_size[i] != 0) {
++j;
}
}
assert(j == dest->ndims);
mem_state = get_memory_state();
idx_vec1 = size_alloc(0,source->ndims); /*indices in the source array*/
/* idx_vec2 = size_alloc(0,dest->ndims); / * indices in the destination array* / */
idx_size = size_alloc(0,source_spec->ndims);
for (i = 0; i < source->ndims; ++i) {
idx_vec1[i] = 0;
}
for (i = 0; i < source_spec->ndims; ++i) {
if (source_spec->index[i] != NULL) { /* is 'S' or 'A' */
idx_size[i] = imax(source_spec->dim_size[i],1); /* the imax() is not needed, because there is (idx[d] >= size[d]) in the next_index(), but ... */
} else { /* is 'W' */
idx_size[i] = source->dim_size[i];
}
}
j = 0;
do {
/*
for (i = 0, j = 0; i < source->ndims; ++i) {
if ((source_spec->index_type[i] == 'W')
||
(source_spec->index_type[i] == 'A')) {
idx_vec2[j] = idx_vec1[i];
j++;
}
}
*/
real_set(dest, j, /* calc_base_index(dest->ndims, idx_vec2, dest), */
real_get(source,
calc_base_index_spec(source->ndims, idx_vec1,
source, source_spec)));
j++;
} while (0 == next_index(source->ndims, idx_vec1, idx_size));
assert(j == base_array_nr_of_elements(dest));
restore_memory_state(mem_state);
}
void indexed_assign_real_array(const real_array_t * source,
real_array_t* dest,
const index_spec_t* dest_spec)
{
_index_t* idx_vec1;
_index_t* idx_size;
int i,j;
state mem_state;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(index_spec_ok(dest_spec));
assert(index_spec_fit_base_array(dest_spec, dest));
for (i = 0,j = 0; i < dest_spec->ndims; ++i) {
if (dest_spec->dim_size[i] != 0) {
++j;
}
}
assert(j == source->ndims);
mem_state = get_memory_state();
idx_vec1 = size_alloc(0,dest->ndims);
/* idx_vec2 = size_alloc(0,source->ndims); */
idx_size = size_alloc(0,dest_spec->ndims);
for (i = 0; i < dest_spec->ndims; ++i) {
idx_vec1[i] = 0;
if (dest_spec->index[i] != NULL) { /* is 'S' or 'A' */
idx_size[i] = imax(dest_spec->dim_size[i],1);
} else { /* is 'W' */
idx_size[i] = dest->dim_size[i];
}
}
j = 0;
do {
/*for (i = 0, j = 0; i < dest_spec->ndims; ++i) {
if (dest_spec->dim_size[i] != 0) {
idx_vec2[j] = idx_vec1[i];
++j;
}
}*/
/*for (i = 0, j = 0; i < dest_spec->ndims; ++i) {
if ((dest_spec->index_type[i] == 'W')
||
(dest_spec->index_type[i] == 'A')) {
idx_vec2[j] = idx_vec1[i];
++j;
}
}*/
real_set(dest,
calc_base_index_spec(dest->ndims, idx_vec1, dest, dest_spec),
real_get(source, j));
j++;
/* calc_base_index(source->ndims, idx_vec1, source)));*/
/* calc_base_index(source->ndims, idx_vec2, source)));*/
} while (0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
assert(j == base_array_nr_of_elements(source));
restore_memory_state(mem_state);
}