mwArray

Construct empty array of type mxDOUBLE_CLASS.

Construct empty array of specified type.

Create a 2–D matrix of the specified type and complexity. For nonnumeric types, mxComplexity will be ignored. For numeric types, pass mxCOMPLEX for the last argument to create a complex matrix; otherwise, the matrix will be real. All elements are initialized to zero. For cell matrices, all elements are initialized to empty cells.

Create an n-dimensional array of the specified type and complexity. For nonnumeric types, mxComplexity will be ignored. For numeric types, pass mxCOMPLEX for the last argument to create a complex matrix; otherwise, the array will be real. All elements are initialized to zero. For cell arrays, all elements are initialized to empty cells.

Create a 1-by-n array of type mxCHAR_CLASS, with n = strlen(str), and initialize the array's data with the characters in the supplied string.

Create a matrix of type mxCHAR_CLASS, and initialize the array's data with the characters in the supplied strings. The created array has dimensions m-by-max, where m is the number of strings and max is the length of the longest string in str.

Create a matrix of type mxSTRUCT_CLASS, with the specified field names. All elements are initialized with empty cells.

Create an n-dimensional array of type mxSTRUCT_CLASS, with the specified field names. All elements are initialized with empty cells.

Create a deep copy of an existing array.

Create a real scalar array.

The scalar array is created with the type of the input argument.

Create a complex scalar array.

The scalar array is created with the type of the input argument.

<type> can be any of the following:

Create a new array representing deep copy of array.

Create a shared copy of an existing array. The new array and the original array both point to the same data.

Serialize an array into bytes. A 1-by-n numeric matrix of type mxUINT8_CLASS is returned containing the serialized data. The data can be deserialized back into the original representation by calling mwArray::Deserialize().

Determine the type of the array. See Work with mxArrays for more information on mxClassID.

Determine the size, in bytes, of an element of array type. If the array is complex, the return value will represent the size, in bytes, of the real part of an element.

Determine the total size of the array.

Determine the size of the array's data. If the underlying array is not sparse, this returns the same value as NumberOfElements().

Determine the allocated size of the array's data. If the underlying array is not sparse, this returns the same value as NumberOfElements().

Determine the dimensionality of the array.

Determine the number of fields in a struct array. If the underlying array is not of type struct, zero is returned.

Determine the name of a given field in a struct array. If the underlying array is not of type struct, an exception is thrown.

Determine the size of each dimension in the array. The size of the returned array is 1-by-NumberOfDimensions().

Determine if an array is empty.

Determine if an array is sparse.

Determine if an array is numeric.

Determine if an array is complex.

Returns true if the input array is byte-wise equal to this array. This method makes a byte-wise comparison of the underlying arrays. Therefore, arrays of the same type should be compared. Arrays of different types will not in general be equal, even if they are initialized with the same data.

Compares this array with the specified array for order. This method makes a byte-wise comparison of the underlying arrays. Therefore, arrays of the same type should be compared. Arrays of different types will, in general, not be ordered equivalently, even if they are initialized with the same data.

Constructs a unique hash value from the underlying bytes in the array. Therefore, arrays of different types will have different hash codes, even if they are initialized with the same data.

Returns a string representation of the underlying array. The string returned is the same one that is returned by typing a variable's name at the MATLAB command prompt.

Returns an array representing the row indices (first dimension) of the elements of this array in column-major order. For sparse arrays, the indices are returned for just the non-zero elements and the size of the array returned is 1-by-NumberOfNonZeros(). For nonsparse arrays, the size of the array returned is 1-by-NumberOfElements(), and the row indices of all of the elements are returned.

Returns an array representing the column indices (second dimension) of the elements of this array in column-major order. For sparse arrays, the indices are returned for just the non-zero elements and the size of the array returned is 1-by-NumberOfNonZeros(). For nonsparse arrays, the size of the array returned is 1-by-NumberOfElements(), and the column indices of all of the elements are returned.

Convert a numeric array that has been previously allocated as real to complex. If the underlying array is of a nonnumeric type, an mwException is thrown.

Fetches a single element at a specified index. The number of indices is passed, followed by a comma-separated list of 1-based indices. The valid number of indices that can be passed in is either 1 (single subscript indexing) or NumberOfDimensions() (multiple subscript indexing). In single subscript indexing the element at the specified 1-based offset is returned, accessing data in column-major order. In multiple subscript indexing the index list is used to access the specified element. The valid range for indices is 1 <= index <= NumberOfElements(), for single subscript indexing. For multiple subscript indexing, the ith index has the valid range: 1 <= index[i] <= GetDimensions().Get(1, i). An mwException is thrown if an invalid number of indices is passed in or if any index is out of bounds.

Fetches a single element at a specified field name and index. This method may only be called on an array that is of type mxSTRUCT_CLASS. An mwException is thrown if the underlying array is not a struct array. The field name passed must be a valid field name in the struct array. The index is passed by first passing the number of indices followed by a comma-separated list of 1-based indices. The valid number of indices that can be passed in is either 1 (single subscript indexing) or NumberOfDimensions() (multiple subscript indexing). In single subscript indexing the element at the specified 1-based offset is returned, accessing data in column-wise order. In multiple subscript indexing the index list is used to access the specified element. The valid range for indices is 1 <= index <= NumberOfElements(), for single subscript indexing. For multiple subscript indexing, the ith index has the valid range: 1 <= index[i] <= GetDimensions().Get(1, i). An mwException is thrown if an invalid number of indices is passed in or if any index is out of bounds.

Accesses the real part of a complex array. The returned mwArray is considered real and has the same dimensionality and type as the original.

Complex arrays consist of Complex numbers, which are 1-by-2 vectors (pairs). For example, if the number is 3+5i, then the pair is (3,5i). An array of Complex numbers is therefore two dimensional (N-by-2), where N is the number of complex numbers in the array. 2+4i, 7-3i, 8+6i would be represented as (2,4i) (7,3i) (8,6i). Complex numbers have two components, real and imaginary.

Accesses the imaginary part of a complex array. The returned mwArray is considered real and has the same dimensionality and type as the original.

Complex arrays consist of Complex numbers, which are 1-by-2 vectors (pairs). For example, if the number is 3+5i, then the pair is (3,5i). An array of Complex numbers is therefore two dimensional (N-by-2), where N is the number of complex numbers in the array. 2+4i, 7-3i, 8+6i would be represented as (2,4i) (7,3i) (8,6i). Complex numbers have two components, real and imaginary.

Assign shared copy of input array to currently referenced cell for arrays of type mxCELL_CLASS and mxSTRUCT_CLASS.

Copies the array's data into supplied numeric buffer.

The data is copied in column-major order. If the underlying array is not of the same type as the input buffer, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

Copies the array's data into supplied mxLogical buffer.

The data is copied in column-major order. If the underlying array is not of type mxLOGICAL_CLASS, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

Copies the array's data into supplied mxChar buffer.

The data is copied in column-major order. If the underlying array is not of type mxCHAR_CLASS, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

Copies the data from supplied numeric buffer into the array.

The data is copied in column-major order. If the underlying array is not of the same type as the input buffer, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

You cannot use SetData to dynamically resize an mwArray.

Copies the data from the supplied mxLogical buffer into the array.

The data is copied in column-major order. If the underlying array is not of type mxLOGICAL_CLASS, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

Copies the data from the supplied mxChar buffer into the array.

The data is copied in column-major order. If the underlying array is not of type mxCHAR_CLASS, the data is converted to this type as it is copied. If a conversion cannot be made, an mwException is thrown.

Deserializes an array that has been serialized with mwArray::Serialize(). The input array must be of type mxUINT8_CLASS and contain the data from a serialized array. If the input data does not represent a serialized mwArray, the behavior of this method is undefined.

Creates real sparse matrix of type double with specified number of rows and columns.

The lengths of input row, column index, and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated throughout the construction of the matrix.

If the same row/column pair occurs more than once, the data value assigned to that element is the sum of all values associated with that pair. If any element of the rowindex or colindex array is greater than the specified values in num_rows or num_cols respectively, an exception is thrown.

This example constructs a sparse 4-by-4 tridiagonal matrix:

2 -1  0  0
-1  2 -1  0
0 -1  2 -1
0  0 -1  2

The following code, when run:

double rdata[]        = 
           {2.0, -1.0, -1.0, 2.0, -1.0, 
            -1.0, 2.0, -1.0, -1.0, 2.0};
mwIndex row_tridiag[] = 
           {1,    2,    1,   2,    3,
            2,   3,    4,    3,   4  };
mwIndex col_tridiag[] = 
           {1,    1,    2,   2,    2, 
              3,   3,    3,    4,   4  };

mwArray mysparse = 
           mwArray::NewSparse(10, row_tridiag, 
                              10, col_tridiag, 
                              10, rdata, 4, 4, 10);
std::cout << mysparse << std::endl;

will display the following output to the screen:

 (1,1)        2
 (2,1)       -1
 (1,2)       -1
 (2,2)        2
 (3,2)       -1
 (2,3)       -1
 (3,3)        2
 (4,3)       -1
 (3,4)       -1
 (4,4)        2

Creates real sparse matrix of type double with number of rows and columns inferred from input data.

The lengths of input row and column index and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated through out the construction of the matrix.

If the same row/column pair occurs more than once, the data value assigned to that element is the sum of all values associated with that pair. The number of rows and columns in the created matrix are calculated from the input rowindex and colindex arrays as num_rows = max{rowindex}, num_cols = max{colindex}.

In this example, we construct a sparse 4-by-4 identity matrix. The value of 1.0 is copied to each non-zero element defined by row and column index arrays:

double one = 1.0;
mwIndex row_diag[] = {1, 2, 3, 4};
mwIndex col_diag[] = {1, 2, 3, 4};

mwArray mysparse = 
  mwArray::NewSparse(4, row_diag, 
                     4, col_diag, 
                     1, &one, 
                     0);
std::cout << mysparse << std::endl;

(1,1)        1
(2,2)        1
(3,3)        1
(4,4)        1

Creates complex sparse matrix of type double with specified number of rows and columns.

The lengths of input row and column index and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated through out the construction of the matrix.

If the same row/column pair occurs more than once, the data value assigned to that element is the sum of all values associated with that pair. If any element of the rowindex or colindex array is greater than the specified values in num_rows, num_cols, respectively, then an exception is thrown.

This example constructs a complex tridiagonal matrix:

double rdata[] = 
  {2.0, -1.0, -1.0, 2.0, -1.0, -1.0, 2.0, -1.0, -1.0, 2.0};
double idata[] = 
  {20.0, -10.0, -10.0, 20.0, -10.0, -10.0, 20.0, -10.0, 
                                              -10.0, 20.0};
mwIndex row_tridiag[] = 
  {1,    2,    1,   2,    3,    2,   3,    4,    3,   4};
mwIndex col_tridiag[] =
  {1,    1,    2,   2,    2,    3,   3,    3,    4,   4};

mwArray mysparse = mwArray::NewSparse(10, row_tridiag, 
                                      10, col_tridiag, 
                                      10, rdata, 
                                      idata, 4, 4, 10);
std::cout << mysparse << std::endl;

It displays the following output to the screen:

(1,1)      2.0000 +20.0000i
(2,1)     -1.0000 -10.0000i
(1,2)     -1.0000 -10.0000i
(2,2)      2.0000 +20.0000i
(3,2)     -1.0000 -10.0000i
(2,3)     -1.0000 -10.0000i
(3,3)      2.0000 +20.0000i
(4,3)     -1.0000 -10.0000i
(3,4)     -1.0000 -10.0000i
(4,4)      2.0000 +20.0000i

Creates complex sparse matrix of type double with number of rows and columns inferred from input data.

The lengths of input row and column index and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated through out the construction of the matrix.

If the same row/column pair occurs more than once, the data value assigned to that element is the sum of all values associated with that pair. The number of rows and columns in the created matrix are calculated form the input rowindex and colindex arrays as num_rows = max{rowindex}, num_cols = max{colindex}.

This example constructs a complex matrix by inferring dimensions and storage allocation from the input data.

mwArray mysparse = 
   mwArray::NewSparse(10, row_tridiag, 
                      10, col_tridiag,
                      10, rdata, idata, 
                      0);
std::cout << mysparse << std::endl;

(1,1)      2.0000 +20.0000i
(2,1)     -1.0000 -10.0000i
(1,2)     -1.0000 -10.0000i
(2,2)      2.0000 +20.0000i
(3,2)     -1.0000 -10.0000i
(2,3)     -1.0000 -10.0000i
(3,3)      2.0000 +20.0000i
(4,3)     -1.0000 -10.0000i
(3,4)     -1.0000 -10.0000i
(4,4)      2.0000 +20.0000i

Creates logical sparse matrix with specified number of rows and columns.

The lengths of input row and column index and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated throughout the construction of the matrix.

If the same row/column pair occurs more than once, the data value assigned to that element is the sum of all values associated with that pair. If any element of the rowindex or colindex array is greater than the specified values in num_rows, num_cols, respectively, then an exception is thrown.

This example creates a sparse logical 4-by-4 tridiagonal matrix, assigning true to each non-zero value:

mxLogical one = true;
mwIndex row_tridiag[] = 
      {1,    2,    1,   2,    3,    
       2,   3,    4,    3,   4};
mwIndex col_tridiag[] = 
      {1,    1,    2,   2,    2,    
       3,   3,    3,    4,   4};

mwArray mysparse = 
      mwArray::NewSparse(10, row_tridiag,
                         10, col_tridiag, 
                          1, &one, 
                          4, 4, 10);
std::cout << mysparse << std::endl;

(1,1)        1
(2,1)        1
(1,2)        1
(2,2)        1
(3,2)        1
(2,3)        1
(3,3)        1
(4,3)        1
(3,4)        1
(4,4)        1

Creates logical sparse matrix with number of rows and columns inferred from input data.

The lengths of input row and column index and data arrays must all be the same or equal to 1. In the case where any of these arrays are equal to 1, the value is repeated through out the construction of the matrix.

The number of rows and columns in the created matrix are calculated form the input rowindex and colindex arrays as num_rows = max {rowindex}, num_cols = max {colindex}.

This example uses the data from the first example, but allows the number of rows, number of columns, and allocated storage to be calculated from the input data:

mwArray mysparse = 
    mwArray::NewSparse(10, row_tridiag, 
                       10, col_tridiag, 
                       1, &one, 
                       0);
std::cout << mysparse << std::endl;

(1,1)        1
(2,1)        1
(1,2)        1
(2,2)        1
(3,2)        1
(2,3)        1
(3,3)        1
(4,3)        1
(3,4)        1
(4,4)        1

Creates an empty sparse matrix. All elements in an empty sparse matrix are initially zero, and the amount of allocated storage for non-zero elements is specified by nzmax.

This example constructs a real 3-by-3 empty sparse matrix of type double with reserved storage for 4 non-zero elements:

mwArray mysparse = mwArray::NewSparse
                (3, 3, 4, mxDOUBLE_CLASS);
std::cout << mysparse << std::endl;

All zero sparse: 3-by-3

Get value of NaN (Not-a-Number).

Call mwArray::GetNaN to return the value of NaN for your system. NaN is the IEEE arithmetic representation for Not-a-Number. Certain mathematical operations return NaN as a result, for example:

The value of NaN is built in to the system; you cannot modify it.

Returns the value of the MATLAB eps variable. This variable is the distance from 1.0 to the next largest floating-point number. Consequently, it is a measure of floating-point accuracy. The MATLAB pinv and rank functions use eps as a default tolerance.

Returns the value of the MATLAB internal Inf variable. Inf is a permanent variable representing IEEE arithmetic positive infinity. The value of Inf is built into the system; you cannot modify it.

Operations that return Inf include

Determine whether or not a value is finite. A number is finite if it is greater than -Inf and less than Inf.

Determines whether or not a value is equal to infinity or minus infinity. MATLAB stores the value of infinity in a permanent variable named Inf, which represents IEEE arithmetic positive infinity. The value of the variable, Inf, is built into the system; you cannot modify it.

Operations that return infinity include

Determines whether or not the value is NaN. NaN is the IEEE arithmetic representation for Not-a-Number. NaN is obtained as a result of mathematically undefined operations such as

The system understands a family of bit patterns as representing NaN. In other words, NaN is not a single value, rather it is a family of numbers that the MATLAB software (and other IEEE-compliant applications) use to represent an error condition or missing data.

Fetches a single element at a specified index. The index is passed as a comma-separated list of 1-based indices. This operator is overloaded to support 1 through 32 indices. The valid number of indices that can be passed in is either 1 (single subscript indexing) or NumberOfDimensions() (multiple subscript indexing). In single subscript indexing the element at the specified 1-based offset is returned, accessing data in column-wise order. In multiple subscript indexing the index list is used to access the specified element. The valid range for indices is 1 <= index <= NumberOfElements(), for single subscript indexing. For multiple subscript indexing, the ith index has the valid range: 1 <= index[i] <= GetDimensions().Get(1, i). An mwException is thrown if an invalid number of indices is passed in or if any index is out of bounds.

Fetches a single element at a specified field name and index. This method may only be called on an array that is of type mxSTRUCT_CLASS. An mwException is thrown if the underlying array is not a struct array. The field name passed must be a valid field name in the struct array. The index is passed by first passing the number of indices, followed by an array of 1-based indices. This operator is overloaded to support 1 through 32 indices. The valid number of indices that can be passed in is either 1 (single subscript indexing) or NumberOfDimensions() (multiple subscript indexing). In single subscript indexing the element at the specified 1-based offset is returned, accessing data in column-wise order. In multiple subscript indexing the index list is used to access the specified element. The valid range for indices is 1 <= index <= NumberOfElements(), for single subscript indexing. For multiple subscript indexing, the ith index has the valid range: 1 <= index[i] <= GetDimensions().Get(1, i). An mwException is thrown if an invalid number of indices is passed in or if any index is out of bounds.

Sets a single scalar value. This operator is overloaded for all numeric and logical types.

Fetches a single scalar value. This operator is overloaded for all numeric and logical types.

Write mwArray to output stream. The output has the same format as the output when a variable's name is typed at the MATLAB command prompt. See ToString().