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 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 array_boolean_array(boolean_array_t* dest,int n,boolean_array_t first,...)
{
int i,j,c;
va_list ap;
boolean_array_t *elts=(boolean_array_t*)malloc(sizeof(boolean_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, boolean_array_t);
}
va_end(ap);
check_base_array_dim_sizes(elts,n);
for(i = 0, c = 0; i < n; ++i) {
int m = base_array_nr_of_elements(elts[i]);
for(j = 0; j < m; ++j) {
boolean_set(dest, c, boolean_get(elts[i], j));
c++;
}
}
free(elts);
}
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);
}
void unpack_string_array(const string_array_t *a, const char **data)
{
size_t sz = base_array_nr_of_elements(*a);
long i;
for (i=0; i<sz; i++) {
((void**)a->data)[i] = mmc_mk_scon(data[i]);
}
}
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 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_integer_array_to_real(const integer_array_t* a, real_array_t* dest)
{
int els = base_array_nr_of_elements(a);
int i;
clone_base_array_spec(a,dest);
alloc_real_array_data(dest);
for (i=0; i<els; i++) {
real_set(dest, i, (modelica_real)integer_get(a,i));
}
}
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);
}
}
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 fill_real_array(real_array_t* dest,modelica_real s)
{
size_t nr_of_elements;
size_t i;
nr_of_elements = base_array_nr_of_elements(dest);
for (i = 0; i < nr_of_elements; ++i) {
real_set(dest, i, s);
}
}
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 fill_boolean_array(boolean_array_t* dest,modelica_boolean s)
{
size_t nr_of_elements;
size_t i;
nr_of_elements = base_array_nr_of_elements(*dest);
for(i = 0; i < nr_of_elements; ++i) {
boolean_set(dest, i, s);
}
}
void fill_string_array(string_array_t* dest,modelica_string s)
{
size_t nr_of_elements;
size_t i;
nr_of_elements = base_array_nr_of_elements(*dest);
for(i = 0; i < nr_of_elements; ++i) {
string_set(dest, i, s);
}
}
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 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 vector_boolean_array(const boolean_array_t* a, boolean_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) {
boolean_set(dest, i, boolean_get(*a, i));
}
}
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));
}
}
/* 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));
}
}
void simple_index_boolean_array2(const boolean_array_t* source,
int i1, int i2,
boolean_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++) {
boolean_set(dest, i, boolean_get(*source, off + 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));
}
}
/* 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));
}
}
real_array_t add_alloc_scalar_real_array(modelica_real sc, const real_array_t *arr)
{
size_t nr_of_elements, i;
real_array_t dest;
clone_real_array_spec(arr, &dest);
alloc_real_array_data(&dest);
nr_of_elements = base_array_nr_of_elements(*arr);
for(i=0; i < nr_of_elements; ++i) {
real_set(&dest, i, sc * real_get(*arr, i));
}
return dest;
}
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));
}
}
}
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 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_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 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 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);
}
}
