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 copy_boolean_array_data(const boolean_array_t source, boolean_array_t *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(&source));
assert(base_array_ok(dest));
assert(base_array_shape_eq(&source, dest));
nr_of_elements = base_array_nr_of_elements(source);
for(i = 0; i < nr_of_elements; ++i) {
boolean_set(dest, i, boolean_get(source, i));
}
}
void copy_real_array_data(const real_array_t *source, real_array_t *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(source));
assert(base_array_ok(dest));
assert(base_array_shape_eq(source, dest));
nr_of_elements = base_array_nr_of_elements(source);
for (i = 0; i < nr_of_elements; ++i) {
real_set(dest, i, real_get(source, i));
}
}
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 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);
}
modelica_real scalar_real_array(const real_array_t* a)
{
assert(base_array_ok(a));
assert(base_array_one_element_ok(a));
return real_get(a, 0);
}
modelica_real scalar_real_array(const real_array_t* a)
{
omc_assert_macro(base_array_ok(a));
omc_assert_macro(base_array_one_element_ok(a));
return real_get(*a, 0);
}
m_boolean scalar_boolean_array(const boolean_array_t* a)
{
assert(base_array_ok(a));
assert(base_array_one_element_ok(a));
return boolean_get(*a, 0);
}
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;
}
modelica_string scalar_string_array(const string_array_t * a)
{
assert(base_array_ok(a));
assert(base_array_one_element_ok(a));
return string_get(*a, 0);
}
void outer_product_alloc_real_array(real_array_t* v1, real_array_t* v2, real_array_t* dest)
{
size_t dim1,dim2;
omc_assert_macro(base_array_ok(v1));
dim1 = base_array_nr_of_elements(*v1);
dim2 = base_array_nr_of_elements(*v2);
alloc_real_array(dest,dim1,dim2);
outer_product_real_array(v1,v2,dest);
}
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 or_boolean_array(const boolean_array_t *source1, const boolean_array_t *source2, boolean_array_t *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(source1));
assert(base_array_ok(source2));
assert(base_array_shape_eq(source1, source2));
clone_base_array_spec(source1, dest);
// assert(base_array_ok(dest));
// assert(base_array_shape_eq(source1, dest));
alloc_boolean_array_data(dest);
nr_of_elements = base_array_nr_of_elements(*source1);
for(i = 0; i < nr_of_elements; ++i) {
boolean_set(dest, i, boolean_get(*source1, i) || boolean_get(*source2, i));
}
}
void copy_real_array_data_mem(const real_array_t *source, modelica_real *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(source));
nr_of_elements = base_array_nr_of_elements(source);
for (i = 0; i < nr_of_elements; ++i) {
dest[i] = real_get(source, i);
}
}
void copy_boolean_array_data_mem(const boolean_array_t source, modelica_boolean *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(&source));
nr_of_elements = base_array_nr_of_elements(source);
for(i = 0; i < nr_of_elements; ++i) {
dest[i] = boolean_get(source, i);
}
}
void copy_string_array_data_mem(const string_array_t source, modelica_string *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(&source));
nr_of_elements = base_array_nr_of_elements(source);
for(i = 0; i < nr_of_elements; ++i) {
dest[i] = string_get(*&source, i);
}
}
void clone_reverse_base_array_spec(const base_array_t* source, base_array_t* dest)
{
int i;
assert(base_array_ok(source));
dest->ndims = source->ndims;
dest->dim_size = size_alloc(0,dest->ndims);
assert(dest->dim_size);
for (i = 0; i < dest->ndims; ++i) {
dest->dim_size[i] = source->dim_size[dest->ndims - 1 - i];
}
}
void array_scalar_real_array(real_array_t* dest, int n, modelica_real first, ...)
{
int i;
va_list ap;
assert(base_array_ok(dest));
assert(dest->ndims == 1);
assert(dest->dim_size[0] == n);
put_real_element(first, 0, dest);
va_start(ap,first);
for (i = 0; i < n; ++i) {
put_real_element(va_arg(ap,modelica_real),i,dest);
}
va_end(ap);
}
void not_boolean_array(const boolean_array_t source, boolean_array_t *dest)
{
size_t i, nr_of_elements;
assert(base_array_ok(&source));
clone_base_array_spec(&source, dest);
alloc_boolean_array_data(dest);
nr_of_elements = base_array_nr_of_elements(source);
for(i = 0; i < nr_of_elements; ++i) {
boolean_set(dest, i, !boolean_get(source, i));
}
}
modelica_real sum_real_array(const real_array_t * a)
{
size_t i;
size_t nr_of_elements;
modelica_real sum = 0;
assert(base_array_ok(a));
nr_of_elements = base_array_nr_of_elements(a);
for (i = 0; i < nr_of_elements; ++i) {
sum += real_get(a, i);
}
return sum;
}
modelica_real product_real_array(const real_array_t * a)
{
size_t i;
size_t nr_of_elements;
modelica_real product = 1;
assert(base_array_ok(a));
nr_of_elements = base_array_nr_of_elements(a);
for (i = 0; i < nr_of_elements; ++i) {
product *= real_get(a, i);
}
return product;
}
/* Returns dest := source[i1,:,:...]*/
void simple_index_alloc_boolean_array1(const boolean_array_t* source, int i1,
boolean_array_t* dest)
{
int i;
assert(base_array_ok(source));
dest->ndims = source->ndims - 1;
dest->dim_size = size_alloc(dest->ndims);
for(i = 0; i < dest->ndims; ++i) {
dest->dim_size[i] = source->dim_size[i+1];
}
alloc_boolean_array_data(dest);
simple_index_boolean_array1(source, i1, dest);
}
/* Returns dest := source[i1,:,:...]*/
void simple_index_alloc_real_array1(const real_array_t * source, int i1,
real_array_t* dest)
{
int i;
omc_assert_macro(base_array_ok(source));
dest->ndims = source->ndims - 1;
dest->dim_size = size_alloc(dest->ndims);
omc_assert_macro(dest->dim_size);
for(i = 0; i < dest->ndims; ++i) {
dest->dim_size[i] = source->dim_size[i+1];
}
alloc_real_array_data(dest);
simple_index_real_array1(source, i1, dest);
}
void identity_real_array(int n, real_array_t* dest)
{
int i;
int j;
assert(base_array_ok(dest));
/* Check that dest size is ok */
assert(dest->ndims==2);
assert((dest->dim_size[0]==n) && (dest->dim_size[1]==n));
for (i = 0; i < (n * n); ++i) {
real_set(dest, i, 0);
}
j = 0;
for (i = 0; i < n; ++i) {
real_set(dest, j, 1);
j += n+1;
}
}
modelica_real min_real_array(const real_array_t * a)
{
size_t i;
size_t nr_of_elements;
modelica_real min_element = 0;
assert(base_array_ok(a));
nr_of_elements = base_array_nr_of_elements(a);
if (nr_of_elements > 0) {
min_element = real_get(a, 0);
for (i = 1; i < nr_of_elements; ++i) {
if (min_element > real_get(a, i)) {
min_element = real_get(a, i);
}
}
}
return min_element;
}
modelica_real min_real_array(const real_array_t a)
{
size_t nr_of_elements;
modelica_real min_element = DBL_MAX;
omc_assert_macro(base_array_ok(&a));
nr_of_elements = base_array_nr_of_elements(a);
if(nr_of_elements > 0) {
size_t i;
min_element = real_get(a, 0);
for(i = 1; i < nr_of_elements; ++i) {
if(min_element > real_get(a, i)) {
min_element = real_get(a, i);
}
}
}
return min_element;
}
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 print_string_array(const string_array_t *source)
{
_index_t i;
modelica_string *data;
assert(base_array_ok(source));
data = (modelica_string *) source->data;
if(source->ndims == 1) {
for(i = 1; i < source->dim_size[0]; ++i) {
printf("%s, ", MMC_STRINGDATA(*data));
++data;
}
if(0 < source->dim_size[0]) {
printf("%s", MMC_STRINGDATA(*data));
}
} else if(source->ndims > 1) {
size_t k, n;
_index_t j;
n = base_array_nr_of_elements(*source) /
(source->dim_size[0] * source->dim_size[1]);
for(k = 0; k < n; ++k) {
for(i = 0; i < source->dim_size[1]; ++i) {
for(j = 0; j < source->dim_size[0]; ++j) {
printf("%s, ", MMC_STRINGDATA(*data));
++data;
}
if(0 < source->dim_size[0]) {
printf("%s", MMC_STRINGDATA(*data));
}
printf("\n");
}
if((k + 1) < n) {
printf("\n ================= \n");
}
}
}
}
void print_real_array(const real_array_t *source)
{
_index_t i,j;
modelica_real *data;
omc_assert_macro(base_array_ok(source));
data = (modelica_real *) source->data;
if(source->ndims == 1) {
for(i = 1; i < source->dim_size[0]; ++i) {
printf("%e, ",*data);
++data;
}
if(0 < source->dim_size[0]) {
printf("%e",*data);
}
} else if(source->ndims > 1) {
size_t k, n;
n = base_array_nr_of_elements(*source) /
(source->dim_size[0] * source->dim_size[1]);
for(k = 0; k < n; ++k) {
for(i = 0; i < source->dim_size[1]; ++i) {
for(j = 0; j < source->dim_size[0]; ++j) {
printf("%e, ",*data);
++data;
}
if(0 < source->dim_size[0]) {
printf("%e",*data);
}
printf("\n");
}
if((k + 1) < n) {
printf("\n ================= \n");
}
}
}
}
void print_boolean_array(const boolean_array_t *source)
{
_index_t i,j;
modelica_boolean *data;
assert(base_array_ok(source));
data = (modelica_boolean *) source->data;
if(source->ndims == 1) {
for(i = 1; i < source->dim_size[0]; ++i) {
printf("%c, ", (*data) ? 'T' : 'F');
++data;
}
if(0 < source->dim_size[0]) {
printf("%c", (*data) ? 'T' : 'F');
}
} else if(source->ndims > 1) {
size_t k, n;
n = base_array_nr_of_elements(*source) /
(source->dim_size[0] * source->dim_size[1]);
for(k = 0; k < n; ++k) {
for(i = 0; i < source->dim_size[1]; ++i) {
for(j = 0; j < source->dim_size[0]; ++j) {
printf("%c, ",(*data) ? 'T' : 'F');
++data;
}
if(0 < source->dim_size[0]) {
printf("%c",(*data) ? 'T' : 'F');
}
printf("\n");
}
if((k + 1) < n) {
printf("\n ================= \n");
}
}
}
}
