mwArray

用于将输入/输出参量传递给 MATLAB Compiler SDK 生成的 C++ 函数的类

描述

使用 mwArray 类将输入/输出参量传递给生成的 C++ 接口函数。该类由 MATLAB^® 数组的薄包装器组成。MATLAB 中的所有数据都以数组表示。mwArray 类提供了数组创建和初始化以及简单索引所需的构造函数、方法和运算符。

注意

从版本 14 开始，不再支持加法和减法等算术运算符。

必需标头

mclcppclass.h
mclmcrrt.h

提示

MATLAB Compiler SDK™ 会自动将这些头文件包含在为您的 MATLAB 函数生成的头文件中。

构造函数

mwArray()

描述

构造 mxDOUBLE_CLASS 类型的空数组。

mwArray(mxClassID mxID)

描述

构造指定类型的空数组。

参量

mxClassID mxID 有效的 mxClassID 指定要构造的数组的类型。看Work with mxArrays有关 mxClassID 的更多信息。

mwArray(mwSize num_rows, mwSize num_cols, mxClassID mxID, mxComplexity cmplx = mxREAL)

描述

创建指定类型和复杂度的二维矩阵。对于非数值类型，mxComplexity 将被忽略。对于数值类型，将 mxCOMPLEX 作为最后一个参量传递以创建一个复数矩阵；否则，该矩阵将是实数。所有元素都初始化为零。对于元胞矩阵，所有元素都初始化为空元胞。

参量

`mwSize num_rows`	数组中的行数
`mwSize num_cols`	数组中的列数
`mxClassID mxID`	有效的 `mxClassID` 指定要构造的数组的类型。看Work with mxArrays有关 `mxClassID` 的更多信息。
`mxComplexity cmplx`	要创建的数组的复杂性。有效值为 `mxREAL` 和 `mxCOMPLEX`。默认值为 `mxREAL`。

mwArray(mwSize num_dims, const mwSize* dims, mxClassID mxID, mxComplexity cmplx = mxREAL)

描述

创建指定类型和复杂度的 n 维数组。对于非数值类型，mxComplexity 将被忽略。对于数值类型，将 mxCOMPLEX 作为最后一个参量传递以创建一个复数矩阵；否则，该数组将是实数。所有元素都初始化为零。对于元胞数组，所有元素都被初始化为空元胞。

参量

`mwSize num_dims`	数组的维数
`const mwSize* dims`	数组的尺寸
`mxClassID mxID`	有效的 `mxClassID` 指定要构造的数组的类型。看Work with mxArrays有关 `mxClassID` 的更多信息。
`mxComplexity cmplx`	要创建的数组的复杂性。有效值为 `mxREAL` 和 `mxCOMPLEX`。默认值为 `mxREAL`。

mwArray(const char* str)

描述

创建一个 1× n 类型的 mxCHAR_CLASS 数组，其中 n = strlen(str)，并使用所提供字符串中的字符初始化数组的数据。

参量

const char* str 用于初始化数组的以空字符结尾的字符缓冲区

mwArray(mwSize num_strings, const char** str)

描述

创建一个 mxCHAR_CLASS 类型的矩阵，并使用提供的字符串中的字符初始化数组的数据。创建的数组尺寸为 m × max，其中 m 是字符串的数量，max 是 str 中最长字符串的长度。

参量

`mwSize num_strings`	输入数组中的字符串数量
`const char** str`	以空字符结尾的字符串数组

mwArray(mwSize num_rows, mwSize num_cols, int num_fields, const char** fieldnames)

描述

创建一个具有指定字段名称的 mxSTRUCT_CLASS 类型的矩阵。所有元素都用空元胞初始化。

参量

`mwSize num_rows`	数组中的行数
`mwSize num_cols`	数组中的列数
`int num_fields`	`struct` 矩阵中的字段数量。
`const char** fieldnames`	表示字段名称的以空字符结尾的字符串数组

mwArray(mwSize num_dims, const mwSize* dims, int num_fields, const char** fieldnames)

描述

创建类型为 n 的 mxSTRUCT_CLASS 维数组，具有指定的字段名称。所有元素都用空元胞初始化。

参量

`mwSize num_dims`	数组的维数
`const mwSize* dims`	数组的尺寸
`int num_fields`	`struct` 矩阵中的字段数量。
`const char** fieldnames`	表示字段名称的以空字符结尾的字符串数组

mwArray(const mwArray& arr)

描述

创建现有数组的深层副本。

参量

mwArray& arr 要复制的 mwArray

mwArray(<type> re)

描述

创建一个实数标量数组。

标量数组是根据输入参量的类型创建的。

参量

<type> re

用于初始化数组的标量值。<type> 可以是以下任一项：

mxDouble
mxSingle
mxInt8
mxUint8
mxInt16
mxUint16
mxInt32
mxUint32
mxInt64
mxUint64
mxLogical

mwArray(<type> re, <type> im)

描述

创建一个复数标量数组。

标量数组是根据输入参量的类型创建的。

参量

`<type> re`	用于初始化数组实部的标量值
`<type> im`	用于初始化数组虚部的标量值

<type> 可以是以下任一项：

mxDouble
mxSingle
mxInt8
mxUint8
mxInt16
mxUint16
mxInt32
mxUint32
mxInt64
mxUint64
mxLogical

int index 要命名的字段的索引。索引从零开始。

示例

const char* fields[] = {"a", "b", "c"};
mwArray a(2, 2, 3, fields);
mwString tempname = a.GetFieldName(1);
const char* name = (const char*)tempname;

mwArray GetDimensions() const

描述

确定数组中每个维度的大小。返回数组的大小为 1× NumberOfDimensions()。

示例

mwArray a(2, 2, mxDOUBLE_CLASS);
mwArray dims = a.GetDimensions();

bool IsEmpty() const

描述

确定数组是否为空。

示例

mwArray a;
bool b = a.IsEmpty();

bool IsSparse() const

描述

确定数组是否稀疏。

示例

mwArray a(2, 2, mxDOUBLE_CLASS);
bool b = a.IsSparse();

bool IsNumeric() const

描述

确定数组是否为数字。

示例

mwArray a(2, 2, mxDOUBLE_CLASS);
bool b = a.IsNumeric();

bool IsComplex() const

描述

确定数组是否复数。

示例

mwArray a(2, 2, mxDOUBLE_CLASS, mxCOMPLEX);
bool b = a.IsComplex();

bool Equals(const mwArray& arr) const

描述

如果输入数组按字节等于此数组，则返回 true。此方法对底层数组进行逐字节比较。因此，应该比较相同类型的数组。不同类型的数组通常不会相等，即使它们使用相同的数据初始化。

参量

mwArray& arr 要与数组进行比较的数组。

示例

mwArray a(1, 1, mxDOUBLE_CLASS);
mwArray b(1, 1, mxDOUBLE_CLASS);
a = 1.0;
b = 1.0;
bool c = a.Equals(b);

int CompareTo(const mwArray& arr) const

描述

将此数组与指定数组进行比较以确定其顺序。此方法对底层数组进行逐字节比较。因此，应该比较相同类型的数组。一般来说，不同类型的数组不会按相同的顺序排列，即使它们使用相同的数据初始化。

参量

mwArray& arr 要与数组进行比较的数组。

示例

mwArray a(1, 1, mxDOUBLE_CLASS);
mwArray b(1, 1, mxDOUBLE_CLASS);
a = 1.0;
b = 1.0;
int n = a.CompareTo(b);

int HashCode() const

描述

从数组中的基础字节构造一个唯一的哈希值。因此，不同类型的数组将具有不同的哈希码，即使它们使用相同的数据初始化。

示例

mwArray a(1, 1, mxDOUBLE_CLASS);
int n = a.HashCode();

mwString ToString() const

描述

返回底层数组的字符串表示形式。返回的字符串与在 MATLAB 命令提示符下键入变量名称所返回的字符串相同。

示例

mwArray a(1, 1, mxDOUBLE_CLASS, mxCOMPLEX);
a.Real() = 1.0;
a.Imag() = 2.0;
printf("%s\n", (const char*)(a.ToString()));

mwArray RowIndex() const

描述

返回一个数组，该数组按列主顺序表示此数组元素的行索引（第一维）。对于稀疏数组，仅返回非零元素的索引，返回的数组大小为 1× NumberOfNonZeros()。对于非稀疏数组，返回的数组的大小为 1× NumberOfElements()，并且返回所有元素的行索引。

示例

#include <stdio.h>
mwArray a(1, 1, mxDOUBLE_CLASS);
mwArray rows = a.RowIndex();

mwArray ColumnIndex() const

描述

返回一个数组，该数组按列主顺序表示此数组元素的列索引（第二维）。对于稀疏数组，仅返回非零元素的索引，返回的数组大小为 1× NumberOfNonZeros()。对于非稀疏数组，返回的数组的大小为 1× NumberOfElements()，并且返回所有元素的列索引。

示例

mwArray a(1, 1, mxDOUBLE_CLASS);
mwArray rows = a.ColumnIndex();

void MakeComplex()

描述

将先前分配为 real 的数值数组转换为 complex。如果底层数组是非数值类型，则会抛出 mwException。

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
double idata[4] = {10.0, 20.0, 30.0, 40.0};
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(rdata, 4);
a.MakeComplex();
a.Imag().SetData(idata, 4);

mwArray Get(mwSize num_indices, ...)

描述

获取指定索引处的单个元素。传递索引的数量，后跟以逗号分隔的基于 1 的索引列表。可以传入的有效索引数量是 1（单下标索引）或 NumberOfDimensions()（多下标索引）。在单下标索引中，返回位于指定的基于 1 的偏移量的元素，按列主顺序访问数据。在多重下标索引中，索引列表用于访问指定元素。对于单下标索引，索引的有效范围是 1 <= index <= NumberOfElements()。对于多个下标索引，第 i 个索引的有效范围为：1 <= index[i] <= GetDimensions().Get(1, i)。如果传入的索引数量无效或者任何索引超出范围，则会抛出 mwException。

参量

`mwSize num_indices`	传入的索引数量
`...`	以逗号分隔的输入索引列表。项数必须等于 `num_indices`，但不应超过 32。

示例

double data[4] = {1.0, 2.0, 3.0, 4.0};
double x;
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(data, 4);
x = a.Get(1,1);
x = a.Get(2, 1, 2);
x = a.Get(2, 2, 2);

mwArray Get(const char* name, mwSize num_indices, ...)

描述

在指定的字段名称和索引处获取单个元素。该方法只能在 mxSTRUCT_CLASS 类型的数组上调用。如果底层数组不是 mwException 数组，则会抛出 struct。传递的字段名称必须是 struct 数组中的有效字段名称。传递索引的方式是首先传递索引数，然后传递以逗号分隔的基于 1 的索引列表。可以传入的有效索引数量是 1（单下标索引）或 NumberOfDimensions()（多下标索引）。在单下标索引中，返回指定的基于 1 的偏移量的元素，按列顺序访问数据。在多重下标索引中，索引列表用于访问指定元素。对于单下标索引，索引的有效范围是 1 <= index <= NumberOfElements()。对于多个下标索引，第 i 个索引的有效范围为：1 <= index[i] <= GetDimensions().Get(1, i)。如果传入的索引数量无效或者任何索引超出范围，则会抛出 mwException。

参量

`char* name`	包含字段名称的以空字符结尾的缓冲区
`mwSize num_indices`	传入的索引数量
`...`	以逗号分隔的输入索引列表。项数必须等于 `num_indices`，但不应超过 32。

示例

const char* fields[] = {"a", "b", "c"};

mwArray a(1, 1, 3, fields);
mwArray b = a.Get("a", 1, 1);
mwArray b = a.Get("b", 2, 1, 1);

mwArray Real()

描述

访问复数数组的实部。返回的 mwArray 被视为实数，并且具有与原始数组相同的维数和类型。

复数数组由复数组成，复数是 1×2 的向量（对）。例如，如果数字是 3+5i，那么该对就是 (3,5i)。因此，复数数组是二维的 (N-by-2)，其中 N 是数组中复数的数量。2 2+4i, 7-3i, 8+6i 将表示为 (2,4i) (7,3i) (8,6i)。复数有两个组件：实数和虚数。

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
double idata[4] = {10.0, 20.0, 30.0, 40.0};
mwArray a(2, 2, mxDOUBLE_CLASS, mxCOMPLEX);
a.Real().SetData(rdata, 4);

mwArray Imag()

描述

访问复数数组的虚部。返回的 mwArray 被视为实数，并且具有与原始数组相同的维数和类型。

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
double idata[4] = {10.0, 20.0, 30.0, 40.0};
mwArray a(2, 2, mxDOUBLE_CLASS, mxCOMPLEX);
a.Imag().SetData(idata, 4);

void Set(const mwArray& arr)

描述

将输入数组的共享副本分配给 mxCELL_CLASS 和 mxSTRUCT_CLASS 类型数组的当前引用元胞。

参量

mwArray& arr mwArray 分配给当前引用的元胞

示例

mwArray a(2, 2, mxDOUBLE_CLASS);
mwArray b(2, 2, mxINT16_CLASS);
mwArray c(1, 2, mxCELL_CLASS);
c.Get(1,1).Set(a);
c.Get(1,2).Set(b);

void GetData(<numeric-type>* buffer, mwSize len) const

描述

将数组的数据复制到提供的数字缓冲区中。

数据按照列主顺序复制。如果基础数组与输入缓冲区的类型不同，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

参量

`<numeric-type>* buffer`	用于接收副本的缓冲区。有效类型 `<numeric-type>` 是： `mxDOUBLE_CLASS` `mxSINGLE_CLASS` `mxINT8_CLASS` `mxUINT8_CLASS` `mxINT16_CLASS` `mxUINT16_CLASS` `mxINT32_CLASS` `mxUINT32_CLASS` `mxINT64_CLASS` `mxUINT64_CLASS`
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
double data_copy[4] ;
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(rdata, 4);
a.GetData(data_copy, 4);

void GetLogicalData(mxLogical* buffer, mwSize len) const

描述

将数组的数据复制到提供的 mxLogical 缓冲区中。

数据按照列主顺序复制。如果底层数组不是 mxLOGICAL_CLASS 类型，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

参量

`mxLogical* buffer`	接收副本的缓冲区
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

mxLogical data[4] = {true, false, true, false};
mxLogical data_copy[4] ;
mwArray a(2, 2, mxLOGICAL_CLASS);
a.SetLogicalData(data, 4);
a.GetLogicalData(data_copy, 4);

void GetCharData(mxChar* buffer, mwSize len) const

描述

将数组的数据复制到提供的 mxChar 缓冲区中。

数据按照列主顺序复制。如果底层数组不是 mxCHAR_CLASS 类型，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

参量

`mxChar** buffer`	接收副本的缓冲区
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

mxChar data[6] = {'H', 'e' , `l' , 'l' , 'o' , '\0'};
mxChar data_copy[6] ;
mwArray a(1, 6, mxCHAR_CLASS);
a.SetCharData(data, 6);
a.GetCharData(data_copy, 6);

void SetData(<numeric-type>* buffer, mwSize len)

描述

将数据从提供的数字缓冲区复制到数组中。

数据按照列主顺序复制。如果基础数组与输入缓冲区的类型不同，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

您不能使用 SetData 来动态调整 mwArray 大小。

参量

`<numeric-type>* buffer`	包含要复制的数据的缓冲区。有效类型 `<numeric-type>` 是： `mxDOUBLE_CLASS` `mxSINGLE_CLASS` `mxINT8_CLASS` `mxUINT8_CLASS` `mxINT16_CLASS` `mxUINT16_CLASS` `mxINT32_CLASS` `mxUINT32_CLASS` `mxINT64_CLASS` `mxUINT64_CLASS`
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
double data_copy[4] ;
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(rdata, 4);
a.GetData(data_copy, 4);

void SetLogicalData(mxLogical* buffer, mwSize len)

描述

将数据从提供的 mxLogical 缓冲区复制到数组中。

数据按照列主顺序复制。如果底层数组不是 mxLOGICAL_CLASS 类型，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

参量

`mxLogical* buffer`	包含要复制的数据的缓冲区
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

mxLogical data[4] = {true, false, true, false};
mxLogical data_copy[4] ;
mwArray a(2, 2, mxLOGICAL_CLASS);
a.SetLogicalData(data, 4);
a.GetLogicalData(data_copy, 4);

void SetCharData(mxChar* buffer, mwSize len)

描述

将数据从提供的 mxChar 缓冲区复制到数组中。

数据按照列主顺序复制。如果底层数组不是 mxCHAR_CLASS 类型，则数据在复制时将转换为此类型。如果无法进行转换，则会抛出 mwException。

参量

`mxChar** buffer`	包含要复制的数据的缓冲区
`mwSize len`	缓冲区的最大长度。最多可复制 `len` 元素。

示例

mxChar data[6] = {'H', 'e' , `l' , 'l' , 'o' , '\0'};
mxChar data_copy[6] ;
mwArray a(1, 6, mxCHAR_CLASS);
a.SetCharData(data, 6);
a.GetCharData(data_copy, 6);

static mwArray Deserialize(const mwArray& arr)

描述

反序列化已使用 mwArray::Serialize() 序列化的数组。输入数组必须是 mxUINT8_CLASS 类型，并且包含来自序列化数组的数据。如果输入数据不代表序列化的 mwArray，则此方法的行为未定义。

参量

mwArray& arr 通过调用 mwArray 获取的 mwArray::Serialize

示例

double rdata[4] = {1.0, 2.0, 3.0, 4.0};
mwArray a(1,4,mxDOUBLE_CLASS); 
a.SetData(rdata, 4);
mwArray b = a.Serialize();
a = mwArray::Deserialize(b);

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxDouble* rdata, mwSize num_rows, mwSize num_cols, mwSize nzmax)

描述

创建具有指定行数和列数的 double 类型的实稀疏矩阵。

输入行、列索引和数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在整个矩阵的构造过程中重复。

如果同一行/列对出现多次，则分配给该元素的数据值是与该对相关的所有值的总和。如果 rowindex 或 colindex 数组中的任何元素分别大于 num_rows 或 num_cols 中指定的值，则会引发异常。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxDouble* rdata`	与非零行和列索引相关的数据
`mwSize num_rows`	矩阵的行数
`mwSize num_cols`	矩阵的列数
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

此示例构造一个稀疏的 4×4 三对角矩阵：

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

运行时代码如下：

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;

将在屏幕上显示以下输出：

 (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

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxDouble* rdata, mwSize nzmax)

描述

创建 double 类型的实稀疏矩阵，其行数和列数根据输入数据推断出来。

输入行和列索引以及数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在矩阵的整个构造过程中重复。

如果同一行/列对出现多次，则分配给该元素的数据值是与该对相关的所有值的总和。根据输入的 rowindex 和 colindex 数组计算所创建矩阵的行数和列数，即 num_rows = max{rowindex}, num_cols = max{colindex}。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxDouble* rdata`	与非零行和列索引相关的数据
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

在这个示例中，我们构建了一个稀疏的 4×4 单位矩阵。将值 1.0 复制到由行和列索引数组定义的每个非零元素：

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

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxDouble* rdata, const mxDouble* idata, mwSize num_rows, mwSize num_cols, mwSize nzmax)

描述

创建具有指定行数和列数的 double 精度型复数稀疏矩阵。

输入行和列索引以及数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在矩阵的整个构造过程中重复。

如果同一行/列对出现多次，则分配给该元素的数据值是与该对相关的所有值的总和。如果 rowindex 或 colindex 数组中的任何元素分别大于 num_rows、num_cols 中指定的值，则会引发异常。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxDouble* rdata`	与非零行和列索引相关的数据的实部
`mxDouble* idata`	与非零行和列索引相关的数据的虚部
`mwSize num_rows`	矩阵的行数
`mwSize num_cols`	矩阵的列数
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

此示例构造一个复数三对角矩阵：

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;

它在屏幕上显示以下输出：

(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

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxDouble* rdata, const mxDouble* idata, mwSize nzmax)

描述

创建 double 类型的复杂稀疏矩阵，其行数和列数根据输入数据推断出来。

输入行和列索引以及数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在矩阵的整个构造过程中重复。

如果同一行/列对出现多次，则分配给该元素的数据值是与该对相关的所有值的总和。创建的矩阵中的行数和列数是根据输入的 rowindex 和 colindex 数组计算得出的，即 num_rows = max{rowindex}, num_cols = max{colindex}。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxDouble* rdata`	与非零行和列索引相关的数据的实部
`mxDouble* idata`	与非零行和列索引相关的数据的虚部
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

此示例通过从输入数据推断维度和存储分配来构建复杂矩阵。

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

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxLogical* rdata, mwSize num_rows, mwSize num_cols, mwSize nzmax)

描述

创建具有指定行数和列数的逻辑稀疏矩阵。

输入行和列索引以及数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在整个矩阵的构造过程中重复。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxLogical* rdata`	与非零行和列索引相关的数据
`mwSize num_rows`	矩阵的行数
`mwSize num_cols`	矩阵的列数
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

此示例创建一个稀疏逻辑 4×4 三对角矩阵，为每个非零值分配 true：

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

static mwArray NewSparse(mwSize rowindex_size, const mwIndex* rowindex, mwSize colindex_size, const mwIndex* colindex, mwSize data_size, const mxLogical* rdata, mwSize nzmax)

描述

创建具有根据输入数据推断出的行数和列数的逻辑稀疏矩阵。

输入行和列索引以及数据数组的长度必须全部相同或等于 1。如果任何一个数组等于 1，则该值会在矩阵的整个构造过程中重复。

创建的矩阵中的行数和列数是根据输入的 rowindex 和 colindex 数组计算得出的，即 num_rows = max {rowindex}, num_cols = max {colindex}。

参量

`mwSize rowindex_size`	`rowindex` 数组的大小
`mwIndex* rowindex`	非零元素的行索引数组
`mwSize colindex_size`	`colindex` 数组的大小
`mwIndex* colindex`	非零元素的列索引数组
`mwSize data_size`	数据数组的大小
`mxLogical* rdata`	与非零行和列索引相关的数据
`mwSize nzmax`	为稀疏矩阵保留存储。如果 `nzmax` 为零，则存储将设置为 `max{rowindex_size, colindex_size, data_size}`。

示例

此示例使用第一个示例中的数据，但允许根据输入数据计算行数、列数和分配的存储：

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

static mwArray NewSparse (mwSize num_rows, mwSize num_cols, mwSize nzmax, mxClassID mxID, mxComplexity cmplx = mxREAL)

描述

创建一个空的稀疏矩阵。空稀疏矩阵中的所有元素最初都是零，非零元素的分配存储量由 nzmax 指定。

参量

`mwSize num_rows`	矩阵的行数
`mwSize num_cols`	矩阵的列数
`mwSize nzmax`	稀疏矩阵的保留存储
`mxClassID mxID`	矩阵中存储的数据类型。目前，支持 `double` 精度和 `logical` 类型的稀疏矩阵。传递 `mxDOUBLE_CLASS` 来创建 `double` 精度稀疏矩阵。传递 `mxLOGICAL_CLASS` 来创建 `logical` 稀疏矩阵。
`mxComplexity cmplx`	矩阵的复杂性。传递 `mxCOMPLEX` 来创建一个 `complex` 稀疏矩阵，`mxREAL` 来创建一个 `real` 稀疏矩阵。此参量可以省略，在这种情况下默认复杂度是 `real`

示例

此示例构造一个实数 3×3 空稀疏矩阵，类型为 double 并为 4 个非零元素保留存储空间：

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

All zero sparse: 3-by-3

static double GetNaN()

描述

获取 NaN（非数字）的值。

调用 mwArray::GetNaN NaN 返回系统中的 NaN 值。NaN 是非数字的 IEEE 算术表示。某些数学运算会返回 NaN 作为结果，例如：

0.0/0.0
Inf-Inf

NaN 的值是系统内置的；您无法修改它。

示例

double x = mwArray::GetNaN();

static double GetEps()

描述

返回 MATLAB eps 变量的值。这个变量是从 1.0 到下一个最大浮点数的距离。因此，它是浮点精度的度量。MATLAB pinv 和 rank 函数使用 eps 作为默认容差。

示例

double x = mwArray::GetEps();

static double GetInf()

描述

返回 MATLABInfInf 变量的值。Inf 是一个表示 IEEE 算术正无穷大的永久变量。Inf 的值内置于系统中；您无法修改它。

返回 Inf 的运算包括

除以 0。例如，5/0 返回 Inf。
导致溢出的运算。例如，exp(10000) 返回 Inf 因为结果太大，无法在您的计算机上表示。

示例

double x = mwArray::GetInf();

static bool IsFinite(double x)

描述

确定一个值是否有限。如果一个数大于 -Inf 且小于 Inf 则该数是有限的。

参量

double x 测试有限性的值

示例

bool x = mwArray::IsFinite(1.0);

static bool IsInf(double x)

描述

确定某个值是否等于无穷大或负无穷大。MATLAB 将无穷大的值存储在名为 Inf 的永久变量中，该变量表示 MATLAB 算术正无穷大。变量 Inf 的值是系统内置的；您无法修改它。

返回无穷大的运算包括

除以 0。例如，5/0 返回无穷大。
导致溢出的运算。例如，exp(10000) 返回无穷大，因为结果太大，无法在您的计算机上表示。如果值等于 NaN（非数字），则 mxIsInf 返回 false。换句话说，NaN 不等于无穷大。

参量

double x 测试无限性的值

示例

bool x = mwArray::IsInf(1.0);

static bool IsNaN(double x)

描述

确定值 NaN 为 NaN。NaN 是 IEEE 非数字的算术表示。NaN 是由于数学 NaN 未定义的运算而获得的，例如

0.0/0.0
Inf-Inf

系统将一系列位模式理解为表示 NaN。换句话说，NaN 不是一个单一的值，而是 MATLAB 软件（和其他符合 IEEE 标准的应用程序）用来表示错误条件或缺失数据的一组数字。

参量

double x 测试是否为 NaN 的值

示例

bool x = mwArray::IsNaN(1.0);

运算符

mwArray operator()(mwIndex i1, mwIndex i2, mwIndex i3, ...,)

描述

获取指定索引处的单个元素。该索引以基于 1 的索引的逗号分隔列表形式传递。此运算符已重载，可支持 1 到 32 个索引。可以传入的有效索引数量是 1（单下标索引）或 NumberOfDimensions()（多下标索引）。在单下标索引中，返回指定的基于 1 的偏移量的元素，按列顺序访问数据。在多重下标索引中，索引列表用于访问指定元素。对于单下标索引，索引的有效范围是 1 <= index <= NumberOfElements()。对于多个下标索引，第 i 个索引的有效范围为：1 <= index[i] <= GetDimensions().Get(1, i)。如果传入的索引数量无效或者任何索引超出范围，则会抛出 mwException。

参量

mwIndex i1, mwIndex i2, mwIndex i3, ..., 以逗号分隔的输入索引列表

示例

double data[4] = {1.0, 2.0, 3.0, 4.0};
double x;
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(data, 4);
x = a(1,1);
x = a(1,2);
x = a(2,2);

mwArray operator()(const char* name, mwIndex i1, mwIndex i2, mwIndex i3, ...,)

描述

在指定的字段名称和索引处获取单个元素。该方法只能在 mxSTRUCT_CLASS 类型的数组上调用。如果底层数组不是 mwException 数组，则会抛出 struct。传递的字段名称必须是 struct 数组中的有效字段名称。传递索引的方式是首先传递索引的数量，然后传递基于 1 的索引数组。此运算符已重载，可支持 1 到 32 个索引。可以传入的有效索引数量是 1（单下标索引）或 NumberOfDimensions() （多下标索引）。在单下标索引中，返回指定的基于 1 的偏移量的元素，按列顺序访问数据。在多重下标索引中，索引列表用于访问指定元素。对于单下标索引，索引的有效范围是 1 <= index <= NumberOfElements()。对于多个下标索引，第 i 个索引的有效范围为：1 <= index[i] <= GetDimensions().Get(1, i)。如果传入的索引数量无效或者任何索引超出范围，则会抛出 mwException。

参量

`char* name`	包含要获取的字段名称的以空结尾的字符串
`mwIndex i1, mwIndex i2, mwIndex i3, ...,`	以逗号分隔的输入索引列表

示例

const char* fields[] = {"a", "b", "c"};
int index[2] = {1, 1};
mwArray a(1, 1, 3, fields);
mwArray b = a("a", 1, 1);
mwArray b = a("b", 1, 1);

mwArray& operator=(const <type>& x)

描述

设置单个标量值。此运算符针对所有数字和逻辑类型进行了重载。

参量

const <type>& x 要赋的值

示例

mwArray a(2, 2, mxDOUBLE_CLASS);
a(1,1) = 1.0;
a(1,2) = 2.0;
a(2,1) = 3.0;
a(2,2) = 4.0;

const mwArray operator()(mwIndex i1, mwIndex i2, mwIndex i3, ...,) const

描述

获取单个标量值。此运算符针对所有数字和逻辑类型进行了重载。

参量

mwIndex i1, mwIndex i2, mwIndex i3, ..., 以逗号分隔的输入索引列表

示例

double data[4] = {1.0, 2.0, 3.0, 4.0};
double x;
mwArray a(2, 2, mxDOUBLE_CLASS);
a.SetData(data, 4);
x = (double)a(1,1);
x = (double)a(1,2);
x = (double)a(2,1);
x = (double)a(2,2);

std::ostream::operator<<(const mwArray &)

描述

将 mwArray 写入输出流。输出的格式与在 MATLAB 命令提示符中输入变量名称时的输出相同。请参阅 ToString()。

版本历史记录

在 R2013b 中推出