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"); } } } }