void mul_real_matrix_product(const real_array_t * a,const real_array_t * b,real_array_t* dest) { modelica_real tmp; size_t i_size; size_t j_size; size_t k_size; size_t i; size_t j; size_t k; /* Assert that dest has correct size */ i_size = dest->dim_size[0]; j_size = dest->dim_size[1]; k_size = a->dim_size[1]; for (i = 0; i < i_size; ++i) { for (j = 0; j < j_size; ++j) { tmp = 0; for (k = 0; k < k_size; ++k) { tmp += real_get(a, (i * k_size) + k)*real_get(b, (k * j_size) + j); } real_set(dest, (i * j_size) + j, tmp); } } }
void mul_real_array(const real_array_t *a,const real_array_t *b,real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert that a,b have same sizes? */ nr_of_elements = base_array_nr_of_elements(*a); for(i=0; i < nr_of_elements; ++i) { real_set(dest, i, real_get(*a, i) * real_get(*b, i)); } }
void sub_real_array(const real_array_t * a, const real_array_t * b, real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert a and b are of the same size */ /* Assert that dest are of correct size */ nr_of_elements = base_array_nr_of_elements(a); for (i = 0; i < nr_of_elements; ++i) { real_set(dest, i, real_get(a, i)-real_get(b, i)); } }
void sub_real_array_data_mem(const real_array_t * a, const real_array_t * b, modelica_real* dest) { size_t nr_of_elements; size_t i; /* Assert a and b are of the same size */ /* Assert that dest are of correct size */ nr_of_elements = base_array_nr_of_elements(a); for (i = 0; i < nr_of_elements; ++i) { dest[i] = real_get(a, i) - real_get(b, i); } }
modelica_real mul_real_scalar_product(const real_array_t * a, const real_array_t * b) { size_t nr_of_elements; size_t i; modelica_real res; /* Assert that a and b are vectors */ /* Assert that vectors are of matching size */ nr_of_elements = real_array_nr_of_elements(a); res = 0.0; for (i = 0; i < nr_of_elements; ++i) { res += real_get(a, i)*real_get(b, i); } return res; }
/* function: transpose_real_array * * Implementation of transpose(A) for matrix A. */ void transpose_real_array(const real_array_t * a, real_array_t* dest) { size_t i; size_t j; /* size_t k;*/ size_t n,m; if (a->ndims == 1) { copy_real_array_data(a,dest); return; } assert(a->ndims==2 && dest->ndims==2); n = a->dim_size[0]; m = a->dim_size[1]; assert(dest->dim_size[0] == m && dest->dim_size[1] == n); for (i = 0; i < n; ++i) { for (j = 0; j < m; ++j) { real_set(dest, (j * n) + i, real_get(a, (i * m) + j)); } } }
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); }
void array_real_array(real_array_t* dest,int n,real_array_t* first,...) { int i,j,c,m; va_list ap; real_array_t **elts = (real_array_t**)malloc(sizeof(real_array_t *) * n); assert(elts); /* collect all array ptrs to simplify traversal.*/ va_start(ap,first); elts[0] = first; for (i = 1; i < n; ++i) { elts[i] = va_arg(ap, real_array_t*); } va_end(ap); check_base_array_dim_sizes((const base_array_t **)elts,n); for (i = 0, c = 0; i < n; ++i) { m = base_array_nr_of_elements(elts[i]); for (j = 0; j < m; ++j) { real_set(dest, c, real_get(elts[i], j)); c++; } } free(elts); }
/* Indexing 4 dimensions */ modelica_real real_get_4D(const real_array_t *a, size_t i, size_t j, size_t k, size_t l) { modelica_real value = real_get(a, (i * a->dim_size[1] * a->dim_size[2] * a->dim_size[3]) + (j * a->dim_size[2] * a->dim_size[3]) + (k * a->dim_size[3]) + l); return value; }
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); }
/* Zero based index */ void simple_indexed_assign_real_array1(const real_array_t * source, int i1, real_array_t* dest) { /* Assert that source has the correct dimension */ /* Assert that dest has the correct dimension */ real_set(dest, i1, real_get(source, i1)); }
int main() { object_t *object, *copy; plan(10); object = hash( "string", string("foo"), "real", real(4.2), "integer", integer(42), "boolean", boolean(true), "array", array( integer(1), integer(2), integer(3) ) ); copy = object_copy(object); hash_set(object, "string", string("bar")); ok(!strcmp("bar", string_to_c_str(hash_get(object, "string"))), "object[\"string\"] is \"bar\""); ok(!strcmp("foo", string_to_c_str(hash_get(copy, "string"))), "copy[\"string\"] is \"foo\""); hash_set(object, "real", real(3.4)); ok(real_get(hash_get(object, "real")) == 3.4, "object[\"real\"] == 3.4"); ok(real_get(hash_get(copy, "real")) == 4.2, "copy[\"real\"] == 4.2"); hash_set(object, "integer", integer(34)); ok(integer_get(hash_get(object, "integer")) == 34, "object[\"integer\"] == 34"); ok(integer_get(hash_get(copy, "integer")) == 42, "copy[\"integer\"] == 42"); hash_set(object, "boolean", boolean(false)); ok(boolean_get(hash_get(object, "boolean")) == false, "object[\"boolean\"] is false"); ok(boolean_get(hash_get(copy, "boolean")) == true, "copy[\"boolean\"] is true"); array_splice(hash_get(object, "array"), 0, 3, NULL); ok(array_size(hash_get(object, "array")) == 0, "object[\"array\"] contains 0 elements"); ok(array_size(hash_get(copy, "array")) == 3, "copy[\"array\"] contains 3 elements"); object_free(copy); object_free(object); return 0; }
void usub_real_array(real_array_t* a) { size_t nr_of_elements, i; nr_of_elements = base_array_nr_of_elements(a); for(i = 0; i < nr_of_elements; ++i) { real_set(a, i, -real_get(a, i)); } }
void simple_indexed_assign_real_array2(const real_array_t * source, int i1, int i2, real_array_t* dest) { size_t index; /* Assert that source has correct dimension */ /* Assert that dest has correct dimension */ index = (i1 * source->dim_size[1]) + i2; real_set(dest, index, real_get(source, index)); }
void division_real_array_scalar(const real_array_t * a,modelica_real b,real_array_t* dest, const char* division_str) { size_t nr_of_elements; size_t i; /* Assert that dest has correct size*/ nr_of_elements = base_array_nr_of_elements(a); for (i=0; i < nr_of_elements; ++i) { real_set(dest, i, DIVISIONNOTIME(real_get(a, i),b,division_str)); } }
void mul_scalar_real_array(modelica_real a,const real_array_t * b,real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert that dest has correct size*/ nr_of_elements = base_array_nr_of_elements(b); for (i=0; i < nr_of_elements; ++i) { real_set(dest, i, a * real_get(b, i)); } }
void mul_real_array_scalar(const real_array_t * a,modelica_real b,real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert that dest has correct size*/ nr_of_elements = base_array_nr_of_elements(a); for (i=0; i < nr_of_elements; ++i) { real_set(dest, i, real_get(a, i) * b); } }
void cast_real_array_to_integer(const real_array_t * a, integer_array_t* dest) { int els = base_array_nr_of_elements(a); int i; clone_base_array_spec(a,dest); alloc_integer_array_data(dest); for (i=0; i<els; i++) { put_integer_element((modelica_integer)real_get(a,i),i,dest); } }
/* function: cat_real_array * * Concatenates n real arrays along the k:th dimension. * k is one based */ void cat_real_array(int k, real_array_t* dest, int n, real_array_t* first,...) { va_list ap; int i, j, r, c; int n_sub = 1, n_super = 1; int new_k_dim_size = 0; real_array_t **elts = (real_array_t**)malloc(sizeof(real_array_t *) * n); assert(elts); /* collect all array ptrs to simplify traversal.*/ va_start(ap, first); elts[0] = first; for (i = 1; i < n; i++) { elts[i] = va_arg(ap,real_array_t*); } va_end(ap); /* check dim sizes of all inputs and dest */ assert(elts[0]->ndims >= k); for (i = 0; i < n; i++) { assert(dest->ndims == elts[i]->ndims); for (j = 0; j < (k - 1); j++) { assert(dest->dim_size[j] == elts[i]->dim_size[j]); } new_k_dim_size += elts[i]->dim_size[k-1]; for (j = k; j < elts[0]->ndims; j++) { assert(dest->dim_size[j] == elts[i]->dim_size[j]); } } assert(dest->dim_size[k-1] == new_k_dim_size); /* calculate size of sub and super structure in 1-dim data representation */ for (i = 0; i < (k - 1); i++) { n_super *= elts[0]->dim_size[i]; } for (i = k; i < elts[0]->ndims; i++) { n_sub *= elts[0]->dim_size[i]; } /* concatenation along k-th dimension */ j = 0; for (i = 0; i < n_super; i++) { for (c = 0; c < n; c++) { int n_sub_k = n_sub * elts[c]->dim_size[k-1]; for (r = 0; r < n_sub_k; r++) { real_set(dest, j, real_get(elts[c], r + (i * n_sub_k))); j++; } } } free(elts); }
void pow_real_array_scalar(const real_array_t *a, modelica_real b, real_array_t* dest) { size_t nr_of_elements = base_array_nr_of_elements(a); size_t i; assert(nr_of_elements == base_array_nr_of_elements(dest)); for(i = 0; i < nr_of_elements; ++i) { real_set(dest, i, pow(real_get(a, i), b)); } }
void vector_real_array(const real_array_t * a, real_array_t* dest) { size_t i, nr_of_elements; /* Assert that a has at most one dimension with dim_size>1*/ nr_of_elements = base_array_nr_of_elements(a); for (i = 0; i < nr_of_elements; ++i) { real_set(dest, i, real_get(a, i)); } }
void div_scalar_real_array(modelica_real a, const real_array_t* b, real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert that dest has correct size*/ /* Do we need to check for b=0? */ nr_of_elements = base_array_nr_of_elements(b); for (i=0; i < nr_of_elements; ++i) { real_set(dest, i, a / real_get(b, i)); } }
void div_real_array_scalar(const real_array_t * a,modelica_real b,real_array_t* dest) { size_t nr_of_elements; size_t i; /* Assert that dest has correct size*/ /* Do we need to check for b=0? */ nr_of_elements = base_array_nr_of_elements(a); for (i=0; i < nr_of_elements; ++i) { real_set(dest, i, real_get(a, i)/b); } }
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 usub_alloc_real_array(const real_array_t a, real_array_t* dest) { size_t nr_of_elements, i; clone_real_array_spec(&a,dest); alloc_real_array_data(dest); nr_of_elements = base_array_nr_of_elements(*dest); for(i = 0; i < nr_of_elements; ++i) { real_set(dest, i, -real_get(a, i)); } }
void symmetric_real_array(const real_array_t * a,real_array_t* dest) { size_t i; size_t j; size_t nr_of_elements; nr_of_elements = base_array_nr_of_elements(a); /* Assert that a is a two dimensional square array */ /* Assert that dest is a two dimensional square array */ for (i = 0; i < nr_of_elements; ++i) { for (j = 0; j < i; ++j) { real_set(dest, (i * nr_of_elements) + j, real_get(a, (j * nr_of_elements) + i)); } for ( ; j < nr_of_elements; ++j) { real_set(dest, (i * nr_of_elements) + j, real_get(a, (i * nr_of_elements) + j)); } } }
void outer_product_real_array(const real_array_t * v1, const real_array_t * v2, real_array_t* dest) { size_t i; size_t j; size_t number_of_elements_a; size_t number_of_elements_b; number_of_elements_a = base_array_nr_of_elements(v1); number_of_elements_b = base_array_nr_of_elements(v2); /* Assert a is a vector */ /* Assert b is a vector */ for (i = 0; i < number_of_elements_a; ++i) { for (j = 0; i < number_of_elements_b; ++j) { real_set(dest, (i * number_of_elements_b) + j, real_get(v1, i) * real_get(v2, j)); } } }
/* Returns dest := source[i1,:,:...]*/ void simple_index_real_array1(const real_array_t * source, int i1, real_array_t* dest) { size_t i; size_t nr_of_elements = base_array_nr_of_elements(dest); size_t off = nr_of_elements * i1; for (i = 0 ; i < nr_of_elements ; i++) { real_set(dest, i, real_get(source, off + i)); } }
/* Returns dest := source[i1,i2,:,:...]*/ void simple_index_real_array2(const real_array_t * source, int i1, int i2, real_array_t* dest) { size_t i; size_t nr_of_elements = base_array_nr_of_elements(dest); size_t off = nr_of_elements * ((source->dim_size[1] * i1) + i2); for (i = 0 ; i < nr_of_elements ; i++) { real_set(dest, i, real_get(source, off + i)); } }
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; }