Array Functions¶

fill¶

The fill function is used to create an array where each element in the array has the same value. The arguments for fill are:

fill(v, d1, d2, ..., dN)

where v is the value to be given to each element in the array and the remaining arguments are the sizes of each dimension. The elements in the resulting array will have the same type as v. So, to fill a 5x7 array of reals with the value 1.7, we could use the following:

parameter Real x[5,7] = fill(1.7, 5, 7);

This would result in a matrix filled as follows:

zeros¶

When working with arrays, a common use case is to create an array that contains only zero elements. This is essentially the same functionality as the fill function, but since the value is known it is only necessary to specify the sizes. Using zeros we can initialize an array as follows:

parameter Real y[2,3,5] = zeros(2, 3, 5);

ones¶

The ones function is identical to the zeros function except that every element in the resulting array has the value . So, for example:

parameter Real z[3,5] = ones(3, 5);

This would result in a matrix filled as follows:

identity¶

Another common need is to easily build an identity matrix, one whose diagonal elements are all while all other elements are . This can be done very easily with the identity. The identity function takes a single integer argument. This argument determines the number of rows and columns in the resulting matrix. So, invoking identity as:

identity(5);

would produce the following matrix:

diagonal¶

The diagonal function is used to create a matrix where all non-diagonal elements are . The only argument to diagonal is an array containing the values of the diagonal elements. So, to create the following diagonal matrix:

one could use the following Modelica code:

diagonal({2.0, 3.0, 4.0, 5.0});

linspace¶

The linspace function builds a vector where the values of the elements are all linearly distributed over an interval. The linspace function is invoked as follows:

linspace(v0, v1, n);

where v0 is the value of the first elements in the vector, v1 is the last element in the vector and n is the total number of values in the vector. So, for example, invoking linspace as:

linspace(1.0, 5.0, 9);

would yield the vector:

{1.0, 1.5, 2.0, 3.5, 3.0, 3.5, 4.0, 4.5, 5.0}

scalar¶

The scalar function is invoked as follows:

scalar(A)

where A is an array with an arbitrary number of dimensions as long as each dimension is of size . The scalar function returns the (only) scalar value contained in the array. For example,

scalar([5]) // Argument is a two-dimensional array (matrix)

and

scalar({5}) // Argument is a one-dimensional array (vector)

would both give the scalar value 5.

vector¶

The vector function is invoked as follows:

vector(A)

where A is an array with an arbitrary number of dimensions as long as only one dimension has a size greater than . The vector function returns the contents of the array as a vector (i.e., an array with only a single dimension). So, for example, if we passed a column or row matrix, e.g.,

vector([1;2;3;4]) // Argument is a column matrix

or

vector([1,2,3,4]) // Argument is a row matrix

we would get back:

{1,2,3,4}

matrix¶

The matrix function is invoked as follows:

matrix(A)

where A is an array with an arbitrary number of dimensions as long as only two dimension have a size greater than . The matrix function returns the contents of the array as a matrix (i.e., an array with only two dimensions).

Addition (+)¶

Subtraction (-)¶

Multiplication (* and .*)¶

There are two types of multiplication operators. The first is the normal multiplication operator, *, that follows the usual mathematical conventions of linear algebra that matrix-vector products, etc.. The behavior of the * operator is summarized in the following table:

The second type of multiplication operator is a special element-wise version, .*, which doesn’t perform any summations and simply applies the operator element-wise to all array elements.

Division (/ and ./)¶

As with Multiplication (* and .*), there are two division operators. The first is the normal division operator, /, which can be used to divide arrays by a scalar value. The following table summarizes its behavior:

In addition, there is also an element-wise version of the division operator, ./, whose behavior is summarized in the following table:

Exponentiation (^ and .^)¶

As with Multiplication (* and .*) and Division (/ and ./), the exponentiation operator comes in two forms. The first is the standard exponentiation operator, ^. The standard version can be used in two different ways. The first is to raise one scalar to the power of another (i.e., ^ ). The other is to raise a square matrix to a scalar power (i.e., ^ ).

The other form of exponentiation is the element-wise form indicated with the .^ operator. Its behavior is summarized in the following table:

Equality (=)¶

The equality operator, = used to construct equations can be used with scalars as well as arrays as long as the left hand side and right hand side have the same number of dimensions and the sizes of each dimension are the same. Assuming this requirement is met, then the operator is simply applied element-wise. This means that the operator is applied between each element on the left hand side and its counterpart on the right hand side.

Assignment (:=)¶

The := (assignment) operator is applied in the same element-wise way as the Equality (=) operator.

Relational Operators¶

All relational operators (and, or, not, >, >=, <=, <) are applied in the same element-wise way as the Equality (=) operator.

transpose¶

The transpose function takes a matrix as an argument and returns a transposed version of that matrix.

outerProduct¶

The outerProduct function takes two arguments. Each argument must be a vector and they must have the same size. The function returns a matrix which represents the outer product of the two vectors. Mathematically speaking, assume and are vectors of the same size. Invoking outerProduct(a,b) will return a matrix, , whose elements are defined as:

symmetric¶

The symmetric function takes a square matrix as an argument. It returns a matrix of the same size where all the elements below the diagonal of the original matrix have been replaced by elements transposed from above the diagonal. In other words,

skew¶

The skew function takes a vector with three components and returns the following skew-symmetric matrix:

cross¶

The cross function takes two vectors (each with 3 components) and returns the following vector (with three components):

min¶

The min function takes an array and returns the smallest value in the array. For example:

min({10, 7, 2, 11})  // 2
min([1, 2; 3, -4])   // -4

max¶

The max function takes an array and returns the largest value in the array. For example:

max({10, 7, 2, 11})  // 11
max([1, 2; 3, -4])   // 3

sum¶

The sum function takes an array and returns the sum of all elements in the array. For example:

sum({10, 7, 2, 11})  // 30
sum([1, 2; 3, -4])   // 2

product¶

The product function takes an array and returns the product of all elements in the array. For example:

product({10, 7, 2, 11})  // 1540
product([1, 2; 3, -4])   // -24

ndims¶

The ndims function takes an array as its argument and returns the number of dimensions in that array. For example:

ndims({10, 7, 2, 11})  // 1
ndims([1, 2; 3, -4])   // 2

size¶

The size function can be invoked two different ways. The first way is with a single argument that is an array. In this case, size returns a vector where each component in the vector corresponds to the size of the corresponding dimension in the array. For example:

size({10, 7, 2, 11})       // {4}
size([1, 2, 3; 3, -4, 5])  // {2, 3}

It is also possible to call size with an optional additional argument indicating a specific dimension number. In that case, it will return the size of that specific dimension as a scalar integer. For example,

size({10, 7, 2, 11}, 1)       // 4
size([1, 2, 3; 3, -4, 5], 1)  // 2
size([1, 2, 3; 3, -4, 5], 2)  // 3