diff --git a/Compiler/runtime/Dynload.cpp b/Compiler/runtime/Dynload.cpp
index 2ff01739e8b..c0836f05c28 100644
--- a/Compiler/runtime/Dynload.cpp
+++ b/Compiler/runtime/Dynload.cpp
@@ -593,25 +593,25 @@ void *type_desc_to_value(type_description *desc)
   };
   case TYPE_DESC_REAL_ARRAY: {
     void *ptr = (modelica_real *) desc->data.real_array.data
-      + real_array_nr_of_elements(&(desc->data.real_array)) - 1;
+      + base_array_nr_of_elements(desc->data.real_array) - 1;
     return generate_array(TYPE_DESC_REAL, 1, desc->data.real_array.ndims,
                           desc->data.real_array.dim_size, &ptr);
   };
   case TYPE_DESC_INT_ARRAY: {
     void *ptr = (modelica_integer *) desc->data.int_array.data
-      + integer_array_nr_of_elements(&(desc->data.int_array)) - 1;
+      + base_array_nr_of_elements(desc->data.int_array) - 1;
     return generate_array(TYPE_DESC_INT, 1, desc->data.int_array.ndims,
                           desc->data.int_array.dim_size, &ptr);
   };
   case TYPE_DESC_BOOL_ARRAY: {
     void *ptr = (modelica_boolean *) desc->data.bool_array.data
-      + boolean_array_nr_of_elements(&(desc->data.bool_array)) - 1;
+      + base_array_nr_of_elements(desc->data.bool_array) - 1;
     return generate_array(TYPE_DESC_BOOL, 1, desc->data.bool_array.ndims,
                           desc->data.bool_array.dim_size, &ptr);
   };
   case TYPE_DESC_STRING_ARRAY: {
     void *ptr = (modelica_string_t *) desc->data.string_array.data
-      + string_array_nr_of_elements(&(desc->data.string_array)) - 1;
+      + base_array_nr_of_elements(desc->data.string_array) - 1;
     return generate_array(TYPE_DESC_STRING, 1, desc->data.string_array.ndims,
                           desc->data.string_array.dim_size, &ptr);
   };
diff --git a/SimulationRuntime/c/optimization/initialOptimizer/allocate_optimizer_vars.c b/SimulationRuntime/c/optimization/initialOptimizer/allocate_optimizer_vars.c
index f47ce1a8ff5..202de0ea825 100644
--- a/SimulationRuntime/c/optimization/initialOptimizer/allocate_optimizer_vars.c
+++ b/SimulationRuntime/c/optimization/initialOptimizer/allocate_optimizer_vars.c
@@ -234,7 +234,7 @@ static int freeIpoptData(IPOPT_DATA_ *iData)
   free(sopt->Hg);
 
   for(i = 0; i < dim->nx; i++)
-    iData->scaling.scaldt[i];
+    free(iData->scaling.scaldt[i]);
   free(iData->scaling.scaldt);
 
   for(i = 0; i < dim->nJ; i++){
diff --git a/SimulationRuntime/c/util/base_array.c b/SimulationRuntime/c/util/base_array.c
index 30f3f28160c..b0d59e8709d 100644
--- a/SimulationRuntime/c/util/base_array.c
+++ b/SimulationRuntime/c/util/base_array.c
@@ -204,17 +204,6 @@ int index_spec_fit_base_array(const index_spec_t *s, const base_array_t *a)
     return 1;
 }
 
-size_t base_array_nr_of_elements(const base_array_t *a)
-{
-  int i;
-  size_t nr_of_elements = 1;
-  for(i = 0; i < a->ndims; ++i)
-  {
-     nr_of_elements *= a->dim_size[i];
-  }
-  return nr_of_elements;
-}
-
 void simple_alloc_1d_base_array(base_array_t *dest, int n, void *data)
 {
     dest->ndims = 1;
diff --git a/SimulationRuntime/c/util/base_array.h b/SimulationRuntime/c/util/base_array.h
index f191fda0daa..34b2b5bc599 100644
--- a/SimulationRuntime/c/util/base_array.h
+++ b/SimulationRuntime/c/util/base_array.h
@@ -37,6 +37,10 @@
 #include <stdarg.h>
 #include "omc_msvc.h"
 
+static OMC_INLINE size_t getIndex_2D(_index_t *dim, int i, int j) {return i*dim[1]+j;}
+static OMC_INLINE size_t getIndex_3D(_index_t *dim, int i, int j, int k) {return i*dim[1]*dim[2]+j*dim[2]+k;}
+static OMC_INLINE size_t getIndex_4D(_index_t *dim, int i, int j, int k, int l) {return i*dim[1]*dim[2]*dim[3]+j*dim[2]*dim[3]+k*dim[3]+l;}
+
 /* Settings the fields of a base_array */
 void base_array_create(base_array_t *dest, void *data, int ndims, va_list ap);
 
@@ -50,7 +54,15 @@ void simple_alloc_2d_base_array(base_array_t *dest, int r, int c, void *data);
 size_t alloc_base_array(base_array_t *dest, int ndims, va_list ap);
 
 /* Number of elements in array. */
-size_t base_array_nr_of_elements(const base_array_t *a);
+static OMC_INLINE size_t base_array_nr_of_elements(const base_array_t a)
+{
+  int i;
+  size_t nr_of_elements = 1;
+  for(i = 0; i < a.ndims; ++i) {
+     nr_of_elements *= a.dim_size[i];
+  }
+  return nr_of_elements;
+}
 
 /* Clones fields */
 void clone_base_array_spec(const base_array_t *source, base_array_t *dest);
diff --git a/SimulationRuntime/c/util/boolean_array.c b/SimulationRuntime/c/util/boolean_array.c
index 58282993817..66a34d8b285 100644
--- a/SimulationRuntime/c/util/boolean_array.c
+++ b/SimulationRuntime/c/util/boolean_array.c
@@ -84,7 +84,7 @@ void alloc_boolean_array(boolean_array_t *dest, int ndims, ...)
 
 void alloc_boolean_array_data(boolean_array_t* a)
 {
-    a->data = boolean_alloc(base_array_nr_of_elements(a));
+    a->data = boolean_alloc(base_array_nr_of_elements(*a));
 }
 
 void copy_boolean_array_data(const boolean_array_t source, boolean_array_t *dest)
@@ -95,7 +95,7 @@ void copy_boolean_array_data(const boolean_array_t source, boolean_array_t *dest
     assert(base_array_ok(dest));
     assert(base_array_shape_eq(&source, dest));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    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));
@@ -116,7 +116,7 @@ void and_boolean_array(const boolean_array_t *source1, const boolean_array_t *so
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source1);
+    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));
@@ -137,7 +137,7 @@ void or_boolean_array(const boolean_array_t *source1, const boolean_array_t *sou
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source1);
+    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));
@@ -154,7 +154,7 @@ void not_boolean_array(const boolean_array_t *source, boolean_array_t *dest)
     alloc_boolean_array_data(dest);
 
 
-    nr_of_elements = base_array_nr_of_elements(source);
+    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));
@@ -167,7 +167,7 @@ void copy_boolean_array_data_mem(const boolean_array_t source, modelica_boolean
 
     assert(base_array_ok(&source));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         dest[i] = boolean_get(source, i);
@@ -242,7 +242,7 @@ void print_boolean_array(const boolean_array_t *source)
         }
     } else if(source->ndims > 1) {
         size_t k, n;
-        n = base_array_nr_of_elements(source) /
+        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) {
@@ -492,7 +492,7 @@ void simple_index_boolean_array1(const boolean_array_t* source, int i1,
                                  boolean_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    size_t nr_of_elements = base_array_nr_of_elements(*dest);
     size_t off = nr_of_elements * i1;
 
     assert(dest->ndims == (source->ndims - 1));
@@ -507,7 +507,7 @@ void simple_index_boolean_array2(const boolean_array_t* source,
                                  boolean_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    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++) {
@@ -533,7 +533,7 @@ void array_boolean_array(boolean_array_t* dest,int n,boolean_array_t* first,...)
     check_base_array_dim_sizes((const base_array_t **)elts,n);
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[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++;
@@ -575,7 +575,7 @@ void array_alloc_boolean_array(boolean_array_t* dest, int n,
     }
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[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++;
@@ -863,7 +863,7 @@ void vector_boolean_array(const boolean_array_t* a, boolean_array_t* dest)
 
     /* Assert that a has at most one dimension with dim_size>1*/
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    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));
     }
@@ -953,7 +953,7 @@ 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);
+    nr_of_elements = base_array_nr_of_elements(*dest);
     for(i = 0; i < nr_of_elements; ++i) {
         boolean_set(dest, i, s);
     }
diff --git a/SimulationRuntime/c/util/boolean_array.h b/SimulationRuntime/c/util/boolean_array.h
index da587f38094..a582bfd1b52 100644
--- a/SimulationRuntime/c/util/boolean_array.h
+++ b/SimulationRuntime/c/util/boolean_array.h
@@ -45,23 +45,17 @@ static OMC_INLINE modelica_boolean boolean_get(const boolean_array_t a, size_t i
 
 static OMC_INLINE modelica_boolean boolean_get_2D(const boolean_array_t a, size_t i, size_t j)
 {
-    modelica_boolean value = boolean_get(a, (i * a.dim_size[1]) + j);
-    return value;
+    return boolean_get(a, getIndex_2D(a.dim_size,i,j));
 }
 
 static OMC_INLINE modelica_boolean boolean_get_3D(const boolean_array_t a, size_t i, size_t j, size_t k)
 {
-    modelica_boolean value = boolean_get(a, (i * a.dim_size[1] * a.dim_size[2])
-                                          + (j * a.dim_size[2]) + k);
-    return value;
+    return boolean_get(a, getIndex_3D(a.dim_size,i,j,k));
 }
 
 static OMC_INLINE modelica_boolean boolean_get_4D(const boolean_array_t a, size_t i, size_t j, size_t k, size_t l)
 {
-    modelica_boolean value = boolean_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;
+    return boolean_get(a, getIndex_4D(a.dim_size,i,j,k,l));
 }
 
 /* Setting the fields of a boolean_array */
@@ -192,9 +186,6 @@ extern void transpose_boolean_array(const boolean_array_t* a, boolean_array_t* d
 
 extern void fill_boolean_array(boolean_array_t* dest,modelica_boolean s);
 
-static inline size_t boolean_array_nr_of_elements(const boolean_array_t*a)
-{ return base_array_nr_of_elements(a); }
-
 static inline void clone_reverse_boolean_array_spec(const boolean_array_t*source,
                                                     boolean_array_t *dest)
 { clone_reverse_base_array_spec(source, dest); }
diff --git a/SimulationRuntime/c/util/generic_array.c b/SimulationRuntime/c/util/generic_array.c
index fbce365bbda..93146ed983b 100644
--- a/SimulationRuntime/c/util/generic_array.c
+++ b/SimulationRuntime/c/util/generic_array.c
@@ -41,10 +41,6 @@
 #include <math.h>
 
 
-static inline size_t generic_array_nr_of_elements(const base_array_t *a)
-{ return base_array_nr_of_elements(a); }
-
-
 void* generic_ptrget(const base_array_t *a, size_t sze, size_t i) {
   return (a->data) + (i*sze);
 }
@@ -72,7 +68,7 @@ void* generic_array_element_addr(const base_array_t* source, size_t sze, int ndi
 
 void alloc_generic_array_data(base_array_t* a, size_t sze)
 {
-    a->data = generic_alloc(base_array_nr_of_elements(a),sze);
+    a->data = generic_alloc(base_array_nr_of_elements(*a),sze);
 }
 
 // void copy_generic_array_data(const base_array_t * source, base_array_t* dest)
diff --git a/SimulationRuntime/c/util/integer_array.c b/SimulationRuntime/c/util/integer_array.c
index 8eb3e0f1a13..f7d06024efc 100644
--- a/SimulationRuntime/c/util/integer_array.c
+++ b/SimulationRuntime/c/util/integer_array.c
@@ -86,7 +86,7 @@ void alloc_integer_array(integer_array_t* dest,int ndims,...)
 
 void alloc_integer_array_data(integer_array_t* a)
 {
-    a->data = integer_alloc(base_array_nr_of_elements(a));
+    a->data = integer_alloc(base_array_nr_of_elements(*a));
 }
 
 void copy_integer_array_data(const integer_array_t source, integer_array_t* dest)
@@ -97,7 +97,7 @@ void copy_integer_array_data(const integer_array_t source, integer_array_t* dest
     assert(base_array_ok(dest));
     assert(base_array_shape_eq(&source, dest));
 
-    nr_of_elements = integer_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(source, i));
@@ -111,7 +111,7 @@ void copy_integer_array_data_mem(const integer_array_t source,
 
     assert(base_array_ok(&source));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         dest[i] = integer_get(source, i);
@@ -240,7 +240,7 @@ void print_integer_array(const integer_array_t * source)
         }
     } else if(source->ndims > 1) {
         size_t k, n;
-        n = base_array_nr_of_elements(source) /
+        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) {
@@ -489,7 +489,7 @@ void simple_index_integer_array1(const integer_array_t * source,
                                  integer_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    size_t nr_of_elements = base_array_nr_of_elements(*dest);
     size_t off = nr_of_elements * i1;
 
     assert(dest->ndims == (source->ndims - 1));
@@ -505,7 +505,7 @@ void simple_index_integer_array2(const integer_array_t * source,
                                  integer_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    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++) {
@@ -531,7 +531,7 @@ void array_integer_array(integer_array_t* dest,int n,integer_array_t* first,...)
     check_base_array_dim_sizes((const base_array_t **)elts,n);
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             integer_set(dest, c, integer_get(*elts[i], j));
             c++;
@@ -573,7 +573,7 @@ void array_alloc_integer_array(integer_array_t* dest,int n,
     }
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             integer_set(dest, c, integer_get(*elts[i], j));
             c++;
@@ -792,12 +792,12 @@ void add_integer_array(const integer_array_t * a, const integer_array_t * b, int
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert a and b are of the same size */
-    assert(integer_array_nr_of_elements(b) == nr_of_elements);
+    assert(base_array_nr_of_elements(*b) == nr_of_elements);
     /* Assert that dest are of correct size */
-    assert(integer_array_nr_of_elements(dest) == nr_of_elements);
+    assert(base_array_nr_of_elements(*dest) == nr_of_elements);
 
     for(i = 0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(*a, i)+integer_get(*b, i));
@@ -816,12 +816,12 @@ void sub_integer_array(const integer_array_t * a, const integer_array_t * b, int
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert a and b are of the same size */
-    assert(integer_array_nr_of_elements(b) == nr_of_elements);
+    assert(base_array_nr_of_elements(*b) == nr_of_elements);
     /* Assert that dest are of correct size */
-    assert(integer_array_nr_of_elements(dest) == nr_of_elements);
+    assert(base_array_nr_of_elements(*dest) == nr_of_elements);
 
     for(i = 0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(*a, i)-integer_get(*b, i));
@@ -834,10 +834,10 @@ void sub_integer_array_data_mem(const integer_array_t * a, const integer_array_t
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert a and b are of the same size */
-    assert(integer_array_nr_of_elements(b) == nr_of_elements);
+    assert(base_array_nr_of_elements(*b) == nr_of_elements);
     /* Assert that dest are of correct size */
 
     for(i = 0; i < nr_of_elements; ++i) {
@@ -857,10 +857,10 @@ void mul_scalar_integer_array(modelica_integer a,const integer_array_t * b,integ
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(b);
+    nr_of_elements = base_array_nr_of_elements(*b);
 
     /* Assert that dest has correct size*/
-    assert(integer_array_nr_of_elements(dest) == nr_of_elements);
+    assert(base_array_nr_of_elements(*dest) == nr_of_elements);
 
     for(i=0; i < nr_of_elements; ++i) {
         integer_set(dest, i, a * integer_get(*b, i));
@@ -879,10 +879,10 @@ void mul_integer_array_scalar(const integer_array_t * a,modelica_integer b,integ
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert that dest has correct size*/
-    assert(integer_array_nr_of_elements(dest) == nr_of_elements);
+    assert(base_array_nr_of_elements(*dest) == nr_of_elements);
 
     for(i=0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(*a, i) * b);
@@ -909,7 +909,7 @@ modelica_integer mul_integer_scalar_product(const integer_array_t a, const integ
     /* Assert that vectors are of matching size */
     assert(a.dim_size[0] == b.dim_size[0]);
 
-    nr_of_elements = integer_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
     res = 0;
     for(i = 0; i < nr_of_elements; ++i) {
         res += integer_get(a, i)*integer_get(b, i);
@@ -1019,10 +1019,10 @@ void div_integer_array_scalar(const integer_array_t * a,modelica_integer b,integ
     size_t i;
 
     /* Do we need to check for b=0? */
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert that dest has correct size*/
-    assert(nr_of_elements == base_array_nr_of_elements(dest));
+    assert(nr_of_elements == base_array_nr_of_elements(*dest));
 
     for(i=0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(*a, i)/b);
@@ -1041,10 +1041,10 @@ void division_integer_array_scalar(threadData_t *threadData, const integer_array
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert that dest has correct size*/
-    assert(nr_of_elements == base_array_nr_of_elements(dest));
+    assert(nr_of_elements == base_array_nr_of_elements(*dest));
 
     for(i=0; i < nr_of_elements; ++i) {
         integer_set(dest, i, (modelica_integer)DIVISIONNOTIME(integer_get(*a, i),b,division_str));
@@ -1064,7 +1064,7 @@ void div_scalar_integer_array(modelica_integer a, const integer_array_t* b, inte
     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);
+    nr_of_elements = base_array_nr_of_elements(*b);
     for(i=0; i < nr_of_elements; ++i) {
         integer_set(dest, i, a / integer_get(*b, i));
     }
@@ -1079,10 +1079,10 @@ void div_alloc_scalar_integer_array(modelica_integer a, const integer_array_t* b
 
 void pow_integer_array_scalar(const integer_array_t *a, modelica_integer b, integer_array_t* dest)
 {
-  size_t nr_of_elements = base_array_nr_of_elements(a);
+  size_t nr_of_elements = base_array_nr_of_elements(*a);
   size_t i;
 
-  assert(nr_of_elements == base_array_nr_of_elements(dest));
+  assert(nr_of_elements == base_array_nr_of_elements(*dest));
 
   for(i = 0; i < nr_of_elements; ++i) {
     integer_set(dest, i, (modelica_integer)pow(integer_get(*a, i), b));
@@ -1219,7 +1219,7 @@ void vector_integer_array(const integer_array_t * a, integer_array_t* dest)
 
     /* Assert that a has at most one dimension with dim_size>1*/
 
-    nr_of_elements = integer_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
     for(i = 0; i < nr_of_elements; ++i) {
         integer_set(dest, i, integer_get(*a, i));
     }
@@ -1311,8 +1311,8 @@ void outer_product_integer_array(const integer_array_t * v1,const integer_array_
   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);
+  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 */
@@ -1328,8 +1328,8 @@ void outer_product_alloc_integer_array(const integer_array_t* v1, const integer_
 {
   size_t dim1,dim2;
   assert(base_array_ok(v1));
-  dim1 = base_array_nr_of_elements(v1);
-  dim2 = base_array_nr_of_elements(v2);
+  dim1 = base_array_nr_of_elements(*v1);
+  dim2 = base_array_nr_of_elements(*v2);
   alloc_integer_array(dest,dim1,dim2);
   outer_product_integer_array(v1,v2,dest);
 }
@@ -1406,7 +1406,7 @@ void fill_integer_array(integer_array_t* dest,modelica_integer s)
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(dest);
+    nr_of_elements = base_array_nr_of_elements(*dest);
     for(i = 0; i < nr_of_elements; ++i) {
         integer_set(dest, i, s);
     }
@@ -1431,7 +1431,7 @@ modelica_integer max_integer_array(const integer_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     if(nr_of_elements > 0) {
         size_t i;
@@ -1453,7 +1453,7 @@ modelica_integer min_integer_array(const integer_array_t a)
 
   assert(base_array_ok(&a));
 
-  nr_of_elements = base_array_nr_of_elements(&a);
+  nr_of_elements = base_array_nr_of_elements(a);
 
   if(nr_of_elements > 0) {
     size_t i;
@@ -1475,7 +1475,7 @@ modelica_integer sum_integer_array(const integer_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     for(i = 0;i < nr_of_elements; ++i) {
         sum += integer_get(a, i);
@@ -1492,7 +1492,7 @@ modelica_integer product_integer_array(const integer_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     for(i = 0;i < nr_of_elements; ++i) {
         product *= integer_get(a, i);
@@ -1507,7 +1507,7 @@ void symmetric_integer_array(const integer_array_t * a,integer_array_t* dest)
     size_t j;
     size_t nr_of_elements;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
 
     /* Assert that a is a two dimensional square array */
     assert((a->ndims == 2) && (a->dim_size[0] == a->dim_size[1]));
@@ -1545,7 +1545,7 @@ void pack_integer_array(integer_array_t *a)
   if(sizeof(int) != sizeof(modelica_integer)) {
     long i;
     int * int_data = (int*)a->data;
-    size_t n = integer_array_nr_of_elements(a);
+    size_t n = base_array_nr_of_elements(*a);
 
     for(i = 0; i < n; ++i) {
       int_data[i] = (int)integer_get(*a, i);
@@ -1559,7 +1559,7 @@ void unpack_integer_array(integer_array_t *a)
   if(sizeof(int) != sizeof(modelica_integer)) {
     long i;
     int * int_data = (int*)a->data;
-    long n = (long)integer_array_nr_of_elements(a);
+    long n = (long)base_array_nr_of_elements(*a);
 
     for(i = n - 1; i >= 0; --i) {
       integer_set(a, i, int_data[i]);
diff --git a/SimulationRuntime/c/util/integer_array.h b/SimulationRuntime/c/util/integer_array.h
index f55fd37d99f..1c27e928b0c 100644
--- a/SimulationRuntime/c/util/integer_array.h
+++ b/SimulationRuntime/c/util/integer_array.h
@@ -46,20 +46,17 @@ static OMC_INLINE modelica_integer integer_get(const integer_array_t a, size_t i
 
 static OMC_INLINE modelica_integer integer_get_2D(const integer_array_t a, size_t i, size_t j)
 {
-  return integer_get(a, (i * a.dim_size[1]) + j);
+  return integer_get(a, getIndex_2D(a.dim_size,i,j));
 }
 
 static OMC_INLINE modelica_integer integer_get_3D(const integer_array_t a, size_t i, size_t j, size_t k)
 {
-  return integer_get(a, (i * a.dim_size[1] * a.dim_size[2])
-                        + (j * a.dim_size[2]) + k);
+  return integer_get(a, getIndex_3D(a.dim_size,i,j,k));
 }
 
 static OMC_INLINE modelica_integer integer_get_4D(const integer_array_t a, size_t i, size_t j, size_t k, size_t l)
 {
-  return integer_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 integer_get(a, getIndex_4D(a.dim_size,i,j,k,l));
 }
 
 /* Settings the fields of a integer_array */
@@ -269,9 +266,6 @@ extern void cross_integer_array(const integer_array_t * x,const integer_array_t
 extern void cross_alloc_integer_array(const integer_array_t * x,const integer_array_t * y,integer_array_t* dest);
 extern void skew_integer_array(const integer_array_t * x,integer_array_t* dest);
 
-static inline size_t integer_array_nr_of_elements(const integer_array_t * a)
-{ return base_array_nr_of_elements(a); }
-
 extern _index_t* integer_array_make_index_array(const integer_array_t *arr);
 
 static inline void clone_reverse_integer_array_spec(const integer_array_t * source,
diff --git a/SimulationRuntime/c/util/read_write.c b/SimulationRuntime/c/util/read_write.c
index 2e7bad14810..af78d35a527 100644
--- a/SimulationRuntime/c/util/read_write.c
+++ b/SimulationRuntime/c/util/read_write.c
@@ -241,7 +241,7 @@ void free_type_description(type_description *desc)
   case TYPE_DESC_STRING_ARRAY:
     if(desc->retval) {
       size_t i, cnt;
-      cnt = string_array_nr_of_elements(&(desc->data.string_array));
+      cnt = base_array_nr_of_elements(desc->data.string_array);
       for(i = 0; i < cnt; ++i) {
         modelica_string_t s = ((modelica_string_t*)desc->data.string_array.data)[i];
         if(s != NULL) {
@@ -485,7 +485,7 @@ void write_real_array(type_description *desc, const real_array_t *arr)
     desc->data.real_array.ndims = arr->ndims;
     desc->data.real_array.dim_size = (_index_t*)malloc(sizeof(*(arr->dim_size)) * arr->ndims);
     memcpy(desc->data.real_array.dim_size, arr->dim_size, sizeof(*(arr->dim_size)) * arr->ndims);
-    nr_elements = real_array_nr_of_elements(arr);
+    nr_elements = base_array_nr_of_elements(*arr);
     desc->data.real_array.data = malloc(sizeof(modelica_real) * nr_elements);
     memcpy(desc->data.real_array.data, arr->data,
            sizeof(modelica_real) * nr_elements);
@@ -506,7 +506,7 @@ void write_integer_array(type_description *desc, const integer_array_t *arr)
     desc->data.int_array.ndims = arr->ndims;
     desc->data.int_array.dim_size = (_index_t*)malloc(sizeof(*(arr->dim_size)) * arr->ndims);
     memcpy(desc->data.int_array.dim_size, arr->dim_size, sizeof(*(arr->dim_size)) * arr->ndims);
-    nr_elements = integer_array_nr_of_elements(arr);
+    nr_elements = base_array_nr_of_elements(*arr);
     desc->data.int_array.data = malloc(sizeof(modelica_integer) * nr_elements);
     memcpy(desc->data.int_array.data, arr->data,
            sizeof(modelica_integer) * nr_elements);
@@ -528,7 +528,7 @@ void write_boolean_array(type_description *desc, const boolean_array_t *arr)
     desc->data.bool_array.ndims = arr->ndims;
     desc->data.bool_array.dim_size = (_index_t*)malloc(sizeof(*(arr->dim_size)) * arr->ndims);
     memcpy(desc->data.bool_array.dim_size, arr->dim_size, sizeof(*(arr->dim_size)) * arr->ndims);
-    nr_elements = boolean_array_nr_of_elements(arr);
+    nr_elements = base_array_nr_of_elements(*arr);
     desc->data.bool_array.data = malloc(sizeof(modelica_boolean) * nr_elements);
     memcpy(desc->data.bool_array.data, arr->data,
            sizeof(modelica_boolean) * nr_elements);
@@ -550,7 +550,7 @@ void write_string_array(type_description *desc, const string_array_t *arr)
     desc->data.string_array.ndims = arr->ndims;
     desc->data.string_array.dim_size = (_index_t*)malloc(sizeof(*(arr->dim_size)) * arr->ndims);
     memcpy(desc->data.string_array.dim_size, arr->dim_size, sizeof(*(arr->dim_size)) * arr->ndims);
-    nr_elements = string_array_nr_of_elements(arr);
+    nr_elements = base_array_nr_of_elements(*arr);
     desc->data.string_array.data = malloc(sizeof(modelica_string)* nr_elements);
     dst = (modelica_string_t*)desc->data.string_array.data;
     src = (modelica_string_t*)arr->data;
diff --git a/SimulationRuntime/c/util/real_array.c b/SimulationRuntime/c/util/real_array.c
index 01c9a7eed0c..e7f6520b97b 100644
--- a/SimulationRuntime/c/util/real_array.c
+++ b/SimulationRuntime/c/util/real_array.c
@@ -87,7 +87,7 @@ void alloc_real_array(real_array_t *dest, int ndims, ...)
 
 void alloc_real_array_data(real_array_t *a)
 {
-    a->data = real_alloc(base_array_nr_of_elements(a));
+    a->data = real_alloc(base_array_nr_of_elements(*a));
 }
 
 void copy_real_array_data(const real_array_t source, real_array_t *dest)
@@ -98,7 +98,7 @@ void copy_real_array_data(const real_array_t source, real_array_t *dest)
     assert(base_array_ok(dest));
     assert(base_array_shape_eq(&source, dest));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    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));
@@ -111,7 +111,7 @@ void copy_real_array_data_mem(const real_array_t source, modelica_real *dest)
 
     assert(base_array_ok(&source));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         dest[i] = real_get(source, i);
@@ -220,7 +220,7 @@ void print_real_array(const real_array_t *source)
     } else if(source->ndims > 1) {
         size_t k, n;
 
-        n = base_array_nr_of_elements(source) /
+        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) {
@@ -332,7 +332,7 @@ void indexed_assign_real_array(const real_array_t source, real_array_t* dest, co
 
     } while(0 == next_index(dest_spec->ndims, idx_vec1, idx_size));
 
-    assert(j == base_array_nr_of_elements(&source));
+    assert(j == base_array_nr_of_elements(source));
 }
 
 /*
@@ -411,7 +411,7 @@ void index_real_array(const real_array_t * source,
 
     } while(0 == next_index(source->ndims, idx_vec1, idx_size));
 
-    assert(j == base_array_nr_of_elements(dest));
+    assert(j == base_array_nr_of_elements(*dest));
 }
 
 /*
@@ -527,7 +527,7 @@ void simple_index_real_array1(const real_array_t * source,
                                  real_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    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++) {
@@ -541,7 +541,7 @@ void simple_index_real_array2(const real_array_t * source,
                                  real_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    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++) {
@@ -567,7 +567,7 @@ void array_real_array(real_array_t* dest,int n,real_array_t* first,...)
     check_base_array_dim_sizes((const base_array_t **)elts,n);
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             real_set(dest, c, real_get(*elts[i], j));
             c++;
@@ -608,7 +608,7 @@ void array_alloc_real_array(real_array_t* dest, int n, real_array_t* first,...)
     }
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             real_set(dest, c, real_get(*elts[i], j));
             c++;
@@ -828,7 +828,7 @@ void add_real_array(const real_array_t * a, const real_array_t * b, real_array_t
 
     /* 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);
+    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));
     }
@@ -847,7 +847,7 @@ void usub_real_array(real_array_t* a)
 {
     size_t nr_of_elements, i;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    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));
@@ -860,7 +860,7 @@ void usub_alloc_real_array(const real_array_t a, real_array_t* dest)
     clone_real_array_spec(&a,dest);
     alloc_real_array_data(dest);
 
-    nr_of_elements = base_array_nr_of_elements(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));
@@ -874,7 +874,7 @@ void sub_real_array(const real_array_t * a, const real_array_t * b, real_array_t
 
     /* 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);
+    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));
     }
@@ -888,7 +888,7 @@ void sub_real_array_data_mem(const real_array_t * a, const real_array_t * b,
 
     /* 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);
+    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);
     }
@@ -908,7 +908,7 @@ void mul_scalar_real_array(modelica_real a,const real_array_t * b,real_array_t*
     size_t nr_of_elements;
     size_t i;
     /* Assert that dest has correct size*/
-    nr_of_elements = base_array_nr_of_elements(b);
+    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));
     }
@@ -928,7 +928,7 @@ void mul_real_array_scalar(const real_array_t * a,modelica_real b,real_array_t*
     size_t nr_of_elements;
     size_t i;
     /* Assert that dest has correct size*/
-    nr_of_elements = base_array_nr_of_elements(a);
+    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);
     }
@@ -948,7 +948,7 @@ void mul_real_array(const real_array_t *a,const real_array_t *b,real_array_t* de
   size_t nr_of_elements;
   size_t i;
   /* Assert that a,b have same sizes? */
-  nr_of_elements = base_array_nr_of_elements(a);
+  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));
   }
@@ -971,7 +971,7 @@ modelica_real mul_real_scalar_product(const real_array_t a, const real_array_t b
     /* Assert that a and b are vectors */
     /* Assert that vectors are of matching size */
 
-    nr_of_elements = real_array_nr_of_elements(&a);
+    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);
@@ -1078,7 +1078,7 @@ void div_real_array_scalar(const real_array_t * a,modelica_real b,real_array_t*
     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);
+    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);
     }
@@ -1098,7 +1098,7 @@ void division_real_array_scalar(threadData_t *threadData, const real_array_t * a
     size_t nr_of_elements;
     size_t i;
     /* Assert that dest has correct size*/
-    nr_of_elements = base_array_nr_of_elements(a);
+    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));
     }
@@ -1119,7 +1119,7 @@ void div_scalar_real_array(modelica_real a, const real_array_t* b, real_array_t*
     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);
+    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));
     }
@@ -1139,7 +1139,7 @@ void div_real_array(const real_array_t *a, const real_array_t *b, real_array_t*
   size_t nr_of_elements;
   size_t i;
   /* Assert that a,b have same sizes? */
-  nr_of_elements = base_array_nr_of_elements(a);
+  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));
   }
@@ -1157,10 +1157,10 @@ real_array_t div_alloc_real_array(const real_array_t a, const real_array_t b)
 
 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 nr_of_elements = base_array_nr_of_elements(*a);
   size_t i;
 
-  assert(nr_of_elements == base_array_nr_of_elements(dest));
+  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));
@@ -1301,7 +1301,7 @@ void vector_real_array(const real_array_t * a, real_array_t* dest)
 
     /* Assert that a has at most one dimension with dim_size>1*/
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    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));
     }
@@ -1394,8 +1394,8 @@ void outer_product_real_array(const real_array_t * v1, const real_array_t * v2,
     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);
+    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 */
@@ -1412,8 +1412,8 @@ void outer_product_alloc_real_array(real_array_t* v1, real_array_t* v2, real_arr
 {
   size_t dim1,dim2;
   assert(base_array_ok(v1));
-  dim1 = base_array_nr_of_elements(v1);
-  dim2 = base_array_nr_of_elements(v2);
+  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);
 }
@@ -1468,7 +1468,7 @@ 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);
+    nr_of_elements = base_array_nr_of_elements(*dest);
     for(i = 0; i < nr_of_elements; ++i) {
         real_set(dest, i, s);
     }
@@ -1493,7 +1493,7 @@ modelica_real max_real_array(const real_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     if(nr_of_elements > 0) {
         size_t i;
@@ -1515,7 +1515,7 @@ modelica_real min_real_array(const real_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     if(nr_of_elements > 0) {
         size_t i;
@@ -1538,7 +1538,7 @@ modelica_real sum_real_array(const real_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     for(i = 0; i < nr_of_elements; ++i) {
         sum += real_get(a, i);
@@ -1555,7 +1555,7 @@ modelica_real product_real_array(const real_array_t a)
 
     assert(base_array_ok(&a));
 
-    nr_of_elements = base_array_nr_of_elements(&a);
+    nr_of_elements = base_array_nr_of_elements(a);
 
     for(i = 0; i < nr_of_elements; ++i) {
         product *= real_get(a, i);
@@ -1570,7 +1570,7 @@ void symmetric_real_array(const real_array_t * a,real_array_t* dest)
     size_t j;
     size_t nr_of_elements;
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    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 */
@@ -1648,7 +1648,7 @@ void convert_alloc_real_array_from_f77(const real_array_t * a, real_array_t* des
 
 void cast_integer_array_to_real(const integer_array_t* a, real_array_t* dest)
 {
-    int els = base_array_nr_of_elements(a);
+    int els = base_array_nr_of_elements(*a);
     int i;
     clone_base_array_spec(a,dest);
     alloc_real_array_data(dest);
@@ -1659,7 +1659,7 @@ void cast_integer_array_to_real(const integer_array_t* a, real_array_t* dest)
 
 void cast_real_array_to_integer(const real_array_t * a, integer_array_t* dest)
 {
-    int els = base_array_nr_of_elements(a);
+    int els = base_array_nr_of_elements(*a);
     int i;
     clone_base_array_spec(a,dest);
     alloc_integer_array_data(dest);
diff --git a/SimulationRuntime/c/util/real_array.h b/SimulationRuntime/c/util/real_array.h
index 73d28136476..6fcedfeda8e 100644
--- a/SimulationRuntime/c/util/real_array.h
+++ b/SimulationRuntime/c/util/real_array.h
@@ -47,20 +47,17 @@ static OMC_INLINE modelica_real real_get(const real_array_t a, size_t i)
 
 static OMC_INLINE modelica_real real_get_2D(const real_array_t a, size_t i, size_t j)
 {
-  return real_get(a, (i * a.dim_size[1]) + j);
+  return real_get(a, getIndex_2D(a.dim_size,i,j));
 }
 
 static OMC_INLINE modelica_real real_get_3D(const real_array_t a, size_t i, size_t j, size_t k)
 {
-  return real_get(a, (i * a.dim_size[1] * a.dim_size[2])
-                     + (j * a.dim_size[2]) + k);
+  return real_get(a, getIndex_3D(a.dim_size,i,j,k));
 }
 
 static OMC_INLINE modelica_real real_get_4D(const real_array_t a, size_t i, size_t j, size_t k, size_t l)
 {
-  return 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 real_get(a, getIndex_4D(a.dim_size,i,j,k,l));
 }
 
 /* Setting the fields of a real_array */
@@ -244,8 +241,7 @@ extern void cross_real_array(const real_array_t * x,const real_array_t * y, real
 extern void cross_alloc_real_array(const real_array_t * x,const real_array_t * y, real_array_t* dest);
 extern void skew_real_array(const real_array_t * x,real_array_t* dest);
 
-static inline size_t real_array_nr_of_elements(const real_array_t *a)
-{ return base_array_nr_of_elements(a); }
+#define real_array_nr_of_elements(X) base_array_nr_of_elements(X)
 
 static inline void clone_reverse_real_array_spec(const real_array_t *source,
                                                  real_array_t *dest)
diff --git a/SimulationRuntime/c/util/string_array.c b/SimulationRuntime/c/util/string_array.c
index a96a73e9dfa..31ebed2d070 100644
--- a/SimulationRuntime/c/util/string_array.c
+++ b/SimulationRuntime/c/util/string_array.c
@@ -85,7 +85,7 @@ void alloc_string_array(string_array_t *dest, int ndims, ...)
 
 void alloc_string_array_data(string_array_t* a)
 {
-    a->data = string_alloc(base_array_nr_of_elements(a));
+    a->data = string_alloc(base_array_nr_of_elements(*a));
 }
 
 void copy_string_array_data(const string_array_t source, string_array_t *dest)
@@ -96,7 +96,7 @@ void copy_string_array_data(const string_array_t source, string_array_t *dest)
     assert(base_array_ok(dest));
     assert(base_array_shape_eq(&source, dest));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         string_set(dest, i, string_get(source, i));
@@ -109,7 +109,7 @@ void copy_string_array_data_mem(const string_array_t source, modelica_string_t *
 
     assert(base_array_ok(&source));
 
-    nr_of_elements = base_array_nr_of_elements(&source);
+    nr_of_elements = base_array_nr_of_elements(source);
 
     for(i = 0; i < nr_of_elements; ++i) {
         dest[i] = string_get(*&source, i);
@@ -186,7 +186,7 @@ void print_string_array(const string_array_t *source)
         size_t k, n;
         _index_t j;
  
-        n = base_array_nr_of_elements(source) /
+        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) {
@@ -431,7 +431,7 @@ void simple_index_string_array1(const string_array_t * source, int i1,
                                 string_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    size_t nr_of_elements = base_array_nr_of_elements(*dest);
     size_t off = nr_of_elements * i1;
 
     assert(dest->ndims == (source->ndims - 1));
@@ -446,7 +446,7 @@ void simple_index_string_array2(const string_array_t * source,
                                 string_array_t* dest)
 {
     size_t i;
-    size_t nr_of_elements = base_array_nr_of_elements(dest);
+    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++) {
@@ -472,7 +472,7 @@ void array_string_array(string_array_t* dest,int n,string_array_t* first,...)
     check_base_array_dim_sizes((const base_array_t **)elts,n);
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             string_set(dest, c, string_get(*elts[i], j));
             c++;
@@ -514,7 +514,7 @@ void array_alloc_string_array(string_array_t* dest, int n,
     }
 
     for(i = 0, c = 0; i < n; ++i) {
-        int m = base_array_nr_of_elements(elts[i]);
+        int m = base_array_nr_of_elements(*elts[i]);
         for(j = 0; j < m; ++j) {
             string_set(dest, c, string_get(*elts[i], j));
             c++;
@@ -805,7 +805,7 @@ void vector_string_array(const string_array_t * a, string_array_t* dest)
 
     /* Assert that a has at most one dimension with dim_size>1*/
 
-    nr_of_elements = base_array_nr_of_elements(a);
+    nr_of_elements = base_array_nr_of_elements(*a);
     for(i = 0; i < nr_of_elements; ++i) {
         string_set(dest, i, string_get(*a, i));
     }
@@ -895,7 +895,7 @@ void fill_string_array(string_array_t* dest,modelica_string_t s)
     size_t nr_of_elements;
     size_t i;
 
-    nr_of_elements = base_array_nr_of_elements(dest);
+    nr_of_elements = base_array_nr_of_elements(*dest);
     for(i = 0; i < nr_of_elements; ++i) {
         string_set(dest, i, s);
     }
diff --git a/SimulationRuntime/c/util/string_array.h b/SimulationRuntime/c/util/string_array.h
index de0b2cd8a8b..72bdc7eedf0 100644
--- a/SimulationRuntime/c/util/string_array.h
+++ b/SimulationRuntime/c/util/string_array.h
@@ -167,9 +167,6 @@ extern void transpose_string_array(const string_array_t * a, string_array_t* des
 
 extern void fill_string_array(string_array_t* dest,modelica_string_t s);
 
-static inline size_t string_array_nr_of_elements(const string_array_t *a)
-{ return base_array_nr_of_elements(a); }
-
 static inline void clone_reverse_string_array_spec(const string_array_t *source,
                                                    string_array_t *dest)
 { clone_reverse_base_array_spec(source, dest); }