com.mathworks.toolbox.javabuilder.MWNumericArray 类

public abstract <T> T applyVisitor(AbstractMWArrayVisitor<T> v)

此方法是抽象的，返回由类型参数<T>指定的类型。它以 AbstractMWArrayVisitor<T> 的一个实例作为参量。此方法的目的是将访问者模式应用于 MWArray 对象。通过使用适当的访问者调用此方法，您可以以类型安全的方式遍历 MWArray 的元素并执行操作。

参数：

返回：

public MWClassID classID()

返回此数组的 MATLAB 类型。

指定方：MWArray 类中的 classID

返回：此数组的 MWClassID

public java.lang.Object clone() throws java.lang.CloneNotSupportedException

创建并返回此数组的深层副本。更改深层复制中的数据不会改变原始数组。

示例：克隆数值数组对象

创建一个 double 类型的 3×6 数组：

double[][] AData = {{ 1, 2, 3, 4, 5, 6},
                    { 7, 8 , 9, 10, 11, 12},
                    {13, 14, 15, 16, 17, 18}};
 
MWNumericArray A = new MWNumericArray(AData, MWClassID.DOUBLE);

Object C = A.clone();
System.out.println("Clone of matrix A is:");
System.out.println(C.toString());

 Clone of matrix A is:
    1   2   3   4   5   6
    7   8   9  10  11  12
   13  14  15  16  17  18 Clone of matrix A is:
    1   2   3   4   5   6
    7   8   9  10  11  12
   13  14  15  16  17  18

返回：MWNumericArray 实例表示底层 MATLAB^® 数组的深度复制。

抛出：

public int[] columnIndex()

返回一个数组，包含底层 MATLAB 数组中每个元素的列索引。

指定者： columnIndex 类中的 MWArray

返回：索引数组。

public int compareTo(java.lang.Object obj)

将此数组与指定数组进行比较以确定其顺序。

指定者： compareTo 接口中的 java.lang.Comparable

指定者： compareTo 类中的 MWArray

参数：

public MWComplexity complexity()

返回此数组的复杂度。

示例：测试复杂数组

创建矩阵 A：

double AReal = 24;
double AImag = 5;
 
MWNumericArray A = new MWNumericArray(AReal, AImag);

System.out.println("A is a " + A.complexity() + " matrix");

 A is a complex matrix

返回：MWComplexity.REAL 实数组的。返回复数数组的 MWComplexity.COMPLEX。

public static MWArray deserialize(byte[] data)

从序列化数据创建一个新的 MWArray。

参数：

返回：反序列化的 MWArray

public void dispose()

释放此数组包含的原生 MATLAB 数组。

指定者： dispose 接口中的 Disposable

指定者： dispose 类中的 MWArray

public boolean equals(java.lang.Object obj)

指示其他数组是否与此数组相等。

指定者： equals 类中的 MWArray

参数：

public java.lang.Object get(int index)

返回此数组中指定从 1 开始的偏移量的元素。

指定者： get 类中的 MWArray

参数：

返回：包含所请求元素的对象。

抛出：

public java.lang.Object get(int[] index)

将此数组作为标量字节返回。

指定者： get 类中的 MWArray

参数：

返回：包含所请求元素的对象。

抛出：

public byte getByte()

将此数组作为标量字节返回。

返回：标量值。

public byte getByte(int index)

以字节值形式返回指定的基于 1 的偏移量的实部。

示例：从数值数组中获取短值

以下示例使用此数组：

short[][] Adata = {{ 1, 2, 3, 4, 5, 6},
                  { 7, 8 , 9, 10, 11, 12},
                  {13, 14, 15, 16, 17, 18}};
 
MWNumericArray A = new MWNumericArray(Adata, MWClassID.INT16);
int[] index = {2, 4};
System.out.println("A(2,4) = " + A.getShort(index));

A(2,4) = 10

示例：对数值数组使用 get 和 set

给定上例中使用的相同 MWNumericArray，获取然后修改元素 (2, 3) 的值：

int[] idx = {2, 3};
 
System.out.println("A(2, 3) is " + A.get(idx).toString());
System.out.println("");
System.out.println("Setting A(2, 3) to a new value ...");
A.set(idx, 555);
System.out.println("");
 
System.out.println("A(2, 3) is now " + A.get(idx).toString());

A(2, 3) is 9.0

A(2, 3) is now 555.0

参数：

返回：所请求元素的值。

抛出：

public byte getByte(int[] index)

以字节值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public byte[] getByteData()

该方法返回与原始类型字节匹配的 Java 类型的一维数组。例如，如果调用 getByteData，则无论底层数组中的数据类型如何，都会返回一个字节类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java^® 基本类型字节元素的一维数组

public java.lang.Object getData()

返回一个一维数组，其中包含底层 MATLAB 数组中数据的副本。返回数组的元素按照默认转换规则进行转换。如果底层 MATLAB 数组是复数数值类型，getData 将返回实部。如果底层数组是元胞或结构体数组，则在每个元胞上递归调用 toArray。

指定者： MATLAB 类中的 getData

参数：

返回：按列顺序存储的元素的一维数组。对于非稀疏数组，返回数组的长度等于 numberOfElements()；对于稀疏数组，返回数组的长度等于 numberOfNonZeros()。

public int[] getDimensions()

返回包含此数组每一维的大小的数组。

指定方：MWArray 类中的 getDimensions

返回：包含每个维度大小的数组

public double getDouble()

将此数组作为双精度标量返回。

返回：标量值。

public double getDouble(int index)

以双精度值形式返回指定的基于 1 的偏移量的实部。

参数：

返回：所请求元素的值。

抛出：

public double getDouble(int[] index)

以双精度值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public double[] getDoubleData()

该方法返回与原始类型 double 匹配的 Java 类型的一维数组。例如，如果调用 getDoubleData，则无论底层数组中的数据类型如何，都会返回 double 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 double 元素的一维数组

public static double getEps()

返回 MATLAB 的 eps 概念。

回报：双倍 eps

public float getFloat()

将此数组作为标量浮点数返回。

返回：标量值

public float getFloat(int index)

以浮点值形式返回指定的基于 1 的偏移量的实部。

参数：

返回：所请求元素的值。

抛出：

public float getFloat(int[] index)

以浮点值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public float[] getFloatData()

该方法返回与原始类型 float 匹配的 Java 类型的一维数组。例如，如果调用 getFloatData，则无论底层数组中的数据类型如何，都会返回 float 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 float 元素的一维数组

public java.lang.Object getImag(int index)

返回此数组中指定的基于 1 的偏移量的虚部。

示例：获取数组的实部和虚部

首先创建一个二维复数数组：

double[][] Rdata = {{ 2, 3, 4},
                   { 8 , 9, 10},
                   {14, 15, 16}};
 
double[][] Idata = {{ 6, 5, 14},
                          { 7 , 1, 23},
                          { 1, 1, 9}};
 
MWNumericArray A = new MWNumericArray(Rdata, Idata,
                              MWClassID.DOUBLE);
 
System.out.println("Complex matrix A =");
System.out.println(A.toString());

 2.0000 + 6.0000i 3.0000 + 5.0000i 4.0000 + 14.0000i
8.0000 + 7.0000i 9.0000 + 1.0000i 10.0000 + 23.0000i
14.0000 + 1.0000i 15.0000 + 1.0000i 16.0000 + 9.0000i

int[] index = {2, 3};
System.out.println("The real part of A(2,3) = " +
                         A.get(index));
System.out.println("The imaginary part of A(2,3) = " +
                         A.getImag(index));

The real part of A(2,3) = 10.0
The imaginary part of A(2,3) = 23.0

参数：

返回：包含所请求元素的对象。

抛出：

public java.lang.Object getImag(int[] index)

返回此数组中指定的基于 1 的索引数组的虚部。

参数：

返回：包含所请求元素的对象。

抛出：

public byte getImagByte()

以标量字节形式返回该数组的虚组件。

返回：标量值

public byte getImagByte(int index)

以字节值形式返回指定的基于 1 的偏移量的虚部。

示例：

参数：

返回：所请求元素的值。

抛出：

public byte getImagByte(int[] index)

以字节值形式返回指定的基于 1 的索引数组中的虚部。

参数：

返回：所请求元素的值。

抛出：

public byte[] getImagByteData()

该方法返回 Java 原始类型字节的虚数元素的一维数组。例如，如果调用 getImagByteData，则无论底层数组中的数据类型如何，都会返回一个字节类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 原始类型字节的虚数元素的一维数组。

public java.lang.Object getImagData()

返回一个一维数组，其中包含底层 MATLAB 数组中虚部的副本。

示例：从复杂数组中获取数据

首先创建一个二维复数数组：

double[][] Rdata = {{ 2, 3, 4},
                   { 8 , 9, 10},
                   {14, 15, 16}};
 
double[][] Idata = {{ 6, 5, 14},
                   { 7 , 1, 23},
                   { 1, 1, 9}};
 
MWNumericArray A = new MWNumericArray(Rdata, Idata,
                              MWClassID.DOUBLE);
 
System.out.println("Complex matrix A =");
System.out.println(A.toString());

2.0000 + 6.0000i 3.0000 + 5.0000i 4.0000 + 14.0000i
8.0000 + 7.0000i 9.0000 + 1.0000i 10.0000 + 23.0000i
14.0000 + 1.0000i 15.0000 + 1.0000i 16.0000 + 9.0000i

int[] index = {2, 3};
double[] x;
System.out.println("The real data in matrix A is:");
x = (double[]) A.getData();
for (int i = 0; i < x.length; i++)
    System.out.print(" " + x[i]);
System.out.println();
 
System.out.println();
 
System.out.println("The imaginary data in matrix A is:");
x = (double[]) A.getImagData();
for (int i = 0; i < x.length; i++)
    System.out.print(" " + x[i]);
System.out.println();

The real data in matrix A is:
2.0 8.0 14.0 3.0 9.0 15.0 4.0 10.0 16.0
 
The imaginary data in matrix A is:
6.0 7.0 1.0 5.0 1.0 1.0 14.0 23.0 9.0

返回：按列顺序存储的元素的一维数组。返回数组的元素按照默认转换规则进行转换。

public double getImagDouble()

以双精度标量形式返回该数组的虚组件。

返回：标量值

public double getImagDouble(int index)

以双精度值形式返回指定基于 1 的偏移量的虚部。

示例：获取特定类型的复杂数据

首先创建一个二维复数数组：

double[][] Rdata = {{ 2, 3, 4},
  	          { 8 , 9, 10},
		     {14, 15, 16}};
 
double[][] Idata = {{ 6, 5, 14},
		      { 7 , 1, 23},
  		    { 1, 1, 9}};
 
MWNumericArray A = new MWNumericArray(Rdata, Idata,
MWClassID.DOUBLE);
 
System.out.println("Complex matrix A =");
System.out.println(A.toString());

2.0000 + 6.0000i 3.0000 + 5.0000i 4.0000 + 14.0000i
8.0000 + 7.0000i 9.0000 + 1.0000i 10.0000 + 23.0000i
14.0000 + 1.0000i 15.0000 + 1.0000i 16.0000 + 9.0000i

int[] index = {2, 3};
 
System.out.println("The real part of A(2,3) = " +
  A.getDouble(index));
 
System.out.println("The imaginary part of A(2,3) = " +
  A.getImagDouble(index));

The real part of A(2,3) = 10.0
The imaginary part of A(2,3) = 23.0

参数：

返回：所请求元素的值。

抛出：

public double getImagDouble(int[] index)

以双精度值形式返回指定的基于 1 的索引数组中的虚部。

参数：

返回：所请求元素的值。

抛出：

public double[] getImagDoubleData()

该方法返回 Java 原始类型 double 的虚数元素的一维数组。例如，如果调用 getImagDoubleData，则无论底层数组中的数据类型如何，都会返回 double 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 double 的虚数元素的一维数组

public float getImagFloat()

以浮点值形式返回指定的基于 1 的偏移量的虚部。

参数：

返回：所请求元素的值。

抛出：

public float getImagFloat(int index)

以浮点值形式返回指定的基于 1 的偏移量的虚部。

参数：

返回：所请求元素的值。

抛出：

public float getImagFloat(int[] index)

以浮点值形式返回指定的基于 1 的偏移量的虚部。

参数：

返回：所请求元素的值。

抛出：

public float[] getImagFloatData()

该方法返回 Java 原始类型 float 的虚数元素的一维数组。例如，如果调用 getImagFloatData，则无论底层数组中的数据类型如何，都会返回 float 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 float 的虚数元素的一维数组

public int getImagInt()

以标量整数形式返回该数组的虚组件。

返回：标量值

public int getImagInt(int index)

以 int 值形式返回指定的基于 1 的偏移量的虚部。

参数：

返回：所请求元素的值。

抛出：

public int getImagInt(int[] index)

以 int 值形式返回指定的基于 1 的索引数组中的虚部。

参数：

返回：所请求元素的值。

抛出：

public int[] getImagIntData()

该方法返回 Java 原始类型 int 的虚数元素的一维数组。例如，如果调用 getImagIntData，则无论底层数组中的数据类型如何，都会返回一个 int 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 int 的虚数元素的一维数组

public long getImagLong()

以标量长整型形式返回该数组的虚组件。

返回：标量值

public long getImagLong(int index)

以长整型值形式返回指定偏移量（以 1 为基数）的虚部。

参数：

返回：所请求元素的值。

抛出：

public long getImagLong(int[] index)

以长整型值形式返回指定的基于 1 的索引数组中的虚部。

参数：

返回：所请求元素的值。

抛出：

public long[] getImagLongData()

该方法返回 Java 原始类型 long 的虚数元素的一维数组。例如，如果调用 getImagLongData，则无论底层数组中的数据类型如何，都会返回一个 long 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 long 的虚元素的一维数组

public short getImagShort()

以标量短整型形式返回该数组的虚组件。

返回：标量值

public short getImagShort(int index)

以短值形式返回指定的基于 1 的偏移量的虚部。

参数：

返回：所请求元素的值。

抛出：

public short getImagShort(int[] index)

以短值形式返回指定的基于 1 的索引数组中的虚部。

参数：

返回：所请求元素的值。

抛出：

public short[] getImagShortData()

该方法返回 Java 原始类型 short 的虚数元素的一维数组。例如，如果调用 getImagShortData，则无论底层数组中的数据类型如何，都会返回一个 short 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 short 的虚元素一维数组

public static double getInf()

返回 MATLAB 的 Inf 概念。

返回：Inf 作为双精度

public int getInt()

将此数组作为标量整数返回。

返回：标量值。

public int getInt(int index)

以 int 值形式返回指定的基于 1 的偏移量的实部。

参数：

返回：所请求元素的值。

抛出：

public int getInt(int[] index)

以 int 值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public int[] getIntData()

该方法返回与原始类型 int 匹配的 Java 类型的一维数组。例如，如果调用 getIntData，则无论底层数组中的数据类型如何，都会返回一个 int 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 int 元素的一维数组

抛出：

public long getLong()

将此数组作为标量长整型返回。

返回：标量值

public long getLong(int index)

参数：

返回：

抛出：

public long getLong(int[] index)

以长整型值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public long[] getLongData()

该方法返回与原始类型 long 匹配的 Java 类型的一维数组。例如，如果调用 getLongData，则无论底层数组中的数据类型如何，都会返回一个 long 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 long 元素的一维数组

public static double getNaN()

返回 MATLAB 的 NaN 概念。

返回：NaN 作为双精度值。

public short getShort()

将此数组作为标量短整型返回。

返回：标量值

public short getShort(int index)

以短值形式返回指定的基于 1 的偏移量的实部。

参数：

返回：所请求元素的值。

抛出：

public short getShort(int[] index)

以短值形式返回指定的基于 1 的索引数组中的实部。

参数：

返回：所请求元素的值。

抛出：

public short[] getShortData()

该方法返回与原始类型 short 匹配的 Java 类型的一维数组。例如，如果调用 getShortData，则无论底层数组中的数据类型如何，都会返回 short 类型的数组。如果需要的话，数据将从另一种原始类型转换而来。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型 short 元素的一维数组

public int hashCode()

返回此数组的哈希码值。

指定方：MWArray 类中的 hashCode

public boolean isEmpty()

测试此数组是否没有元素。

指定方：MWArray 类中的 isEmpty

参数：

返回：如果为空则 true，否则 false

public static boolean isFinite(double x)

以与计算机无关的方式测试有限性。

示例：测试有限数组值

测试 x 的有限性：

double x = 25;

if (MWNumericArray.isFinite(x))
        System.out.println("The input value is finite");

The input value is finite

参数：

返回：如果有限则 true，否则 false

public static boolean isInf(double x)

以与计算机无关的方式测试无穷大。

示例：测试 x 是否无穷大

double x = 1.0 / 0.0;
 
if (MWNumericArray.isInf(x))
	System.out.println("The input value is infinite");

The input value is infinite

参数：

返回：如果无限则 true，否则 false

public static boolean isNaN(double x)

以与计算机无关的方式测试 NaN。

示例：测试 NaN 数组值

测试 x 是否为 NaN：

double x = 0.0 / 0.0;
 
if (MWNumericArray.isNaN(x))
	System.out.println("The input value is not a number.");

The input value is not a number

参数：

返回：如果为 NaN，则 true，否则 false

public boolean isSparse()

测试此数组是否稀疏。

参数：

指定方：MWArray 类中的 isSparse

返回：如果稀疏则 true，否则 false

public int maximumNonZeros()

返回稀疏数组的分配容量。如果基础数组是非稀疏的，则此方法返回与 numberOfElements() 相同的值。

指定方：MWArray 类中的 maximumNonZeros

返回：当前分配的稀疏数组中的非零元素的数量。

public static MWNumericArray newInstance(int[] dims, MWClassID classid, MWComplexity cmplx)

构造具有指定维度和复杂度的数值数组。数组的元素全部初始化为 0。此方法比使用类构造函数提供更好的性能。

要构造未初始化的实数或复数数字数组，请使用以下命令：

newInstance(int[] dims, MWClassID classid, MWComplexity cmplx)

要构造并初始化实数数组，请使用：

newInstance(int[] dims, Object rData, MWClassID classid)

要构造和初始化复数数值数组，请使用

newInstance(int[] dims, Object rData, Object iData, MWClassID classid)

示例：使用 newInstance 构造数值数组对象

使用 newInstance 方法构造一个 3×6 实数数组。请注意，Java 数组中的数据必须按列主顺序存储，以便它在最终的 MWNumericArray 对象中处于正确的顺序。

int[] dims = {3, 6};
double[] Adata = { 1, 7, 13,
   	         2, 8, 14,
		     3, 9, 15,
   		  4, 10, 16,
   		  5, 11, 17,
   		  6, 12, 18};
MWNumericArray A =
   MWNumericArray.newInstance(dims, Adata, MWClassID.DOUBLE);
System.out.println("A = " + A);

  A =   1   2   3   4   5   6
        7   8   9   10  11  12
        13  14  15  16  17  18

参数：

返回：具有指定大小、类型和复杂性的新 MWNumericArray。

抛出：

public static MWNumericArray newInstance(int[] dims, java.lang.Object rData, MWClassID classid)

构造具有指定维度的实数数组，并使用提供的数据初始化该数组。输入数组必须是一维数组，且数据按列主顺序存储。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组以及 java.lang.Boolean 的 1-D 数组。

参数：

返回：具有指定维度和类型的新 MWNumericArray，并使用提供的数据进行初始化。

抛出：

public static MWNumericArray newInstance(int[] dims, java.lang.Object rData, java.lang.Object iData, MWClassID classid)

构造具有指定维度的复杂数字数组，并使用提供的数据初始化该数组。输入数组必须是一维数组，并且数据按列主顺序存储。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组以及 java.lang.Boolean 的 1-D 数组。

参数：

返回：具有指定维度和类型的新 MWNumericArray，并使用提供的数据进行初始化。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, int rows, int cols, int nzmax, MWClassID classid)

构造具有指定行数和列数、最大非零元素数的实稀疏数值矩阵，并使用提供的数据初始化数组。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k)，并为 nzmax 个非零值分配空间。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

构造不含非零元素的稀疏矩阵：

newSparse(int rows, int cols, int nzmax, MWClassID classid, MWComplexity cmplx)

要从现有的非稀疏二维数组构造实数稀疏数组，请使用：

 newSparse(Object realData, MWClassID classid)

要构建并初始化新的实数稀疏数组，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData, MWClassID classid)

要构造并初始化新的实数稀疏数组，并指定其维度，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData,
 int rows, int cols, MWClassID classid)

要构造并初始化新的实数稀疏数组，并指定其维度和最大非零数，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData,
 int rows, int cols, int nzmax, MWClassID classid)

要从现有的非稀疏二维数组构造复数稀疏数组，请使用：

newSparse(Object realData, Object imagData, MWClassID classid)

要构建并初始化新的复数稀疏数组，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData,
 Object imagData, MWClassID classid)

要构造并初始化新的复数稀疏数组，并指定其维度，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData,
 Object imagData, int rows, int cols, MWClassID classid)

要构造并初始化新的复数稀疏数组，并指定其维度和最大非零数，请使用：

newSparse(int[] rowindex, int[] colindex, Object realData,
 Object imagData, int rows, int cols, int nzmax,
 MWClassID classid)

示例：使用 newSparse 构造稀疏数组对象

要创建稀疏复数 MWNumericArray，请从实数和虚数双向量构造一个二维复数稀疏 MWNumericArray：

double[][] rData = {{ 0, 0, 0, 16, 0},
                    {71, 63, 32, 0, 0}};
 
double[][] iData = {{ 0, 0, 0, 41, 0},
                    { 0, 0, 32, 0, 2}};
 
MWNumericArray A =
	MWNumericArray.newSparse(rData, iData, MWClassID.DOUBLE);
 
System.out.println("A = " + A.toString());

A = (2,1) 71.0000
    (2,2) 63.0000
    (2,3) 32.0000 +32.0000i
    (1,4) 16.0000 +41.0000i
    (2,5) 0 + 2.0000i

示例：使用带有行和列索引的 newSparse

从向量 Adata 构造稀疏 MWNumericArray：

double[] Adata = { 0, 10, 0, 0, 40, 50, 60, 0, 0, 90};
 
int[] ri = {1, 1, 1, 1, 1, 2, 2, 2, 2, 2};
int[] ci = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5};
 
MWNumericArray A = MWNumericArray.newSparse(ri, ci,
                   Adata, MWClassID.DOUBLE);
 
System.out.println("A = " + A.toString());

(2,1)    50
(1,2)    10
(2,2)    60
(1,5)    40
(2,5)    90

示例：为单个数组元素分配多个值

使用 rowindex 和 colindex 参量创建一个稀疏 MWNumericArray，为索引 (2, 5) 处的数组元素指定多个值。结果是该元素存储了 Adata(1)、Adata(7)、Adata(8) 和 Adata(9) 的值的总和，等于 250。

double[] Adata = { 0, 10, 0, 0, 40, 50, 60, 70, 80, 90};
 
int[] ri = {1, 2, 1, 1, 1, 2, 2, 2, 2, 2};
int[] ci = {1, 5, 2, 3, 5, 1, 2, 5, 5, 5};
 
MWNumericArray A =
MWNumericArray.newSparse(ri, ci, Adata, 4, 5,
                         MWClassID.DOUBLE);
 
System.out.println("A = " + A.toString());

(2,1)   50
(2,2)   60
(1,5)   40
(2,5)  250

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, int rows, int cols, MWClassID classid)

构造具有指定行数和列数的实稀疏数值矩阵，并使用提供的数据初始化该数组。非零元素的最大数量是根据 rData.length 计算的。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k)。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, MWClassID classid)

构造一个实稀疏数值矩阵，其行数 = max{rowindex(k)} 和列数 = max{colindex(k)}，并使用提供的数据初始化该数组。非零元素的最大数量是根据 rData.length 计算的。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k)。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(java.lang.Object rArr, MWClassID classid)

根据提供的完整矩阵构造一个实稀疏数值矩阵。目前，仅支持双精度类型的数字稀疏数组。

参数：

返回：使用提供的数据初始化新的稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, java.lang.Object iData, int rows, int cols, int nzmax, MWClassID classid)

构造具有指定行数和列数、最大非零元素数的复杂稀疏数值矩阵，并使用提供的数据初始化数组。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k) + iData(k)*i，并为 nzmax 个非零值分配空间。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, java.lang.Object iData, int rows, int cols, MWClassID classid)

构造具有指定行数和列数的复杂稀疏数值矩阵，并使用提供的数据初始化该数组。非零元素的最大数量是根据 max{rData.length, iData.length} 计算的。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k) + iData(k)*i。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int[] rowindex, int[] colindex, java.lang.Object rData, java.lang.Object iData, MWClassID classid)

构造一个复杂稀疏数值矩阵，其行数 = max{rowindex(k)} 和列数 = max{colindex(k)}，并使用提供的数据初始化该数组。非零元素的最大数量是根据 max{rData.length, iData.length} 计算的。行和列索引数组用于构建稀疏数组，使得 S(rowindex(k), columnindex(k)) = rData(k) + iData(k)*i。输入数组的有效类型为：double[]、float[]、byte[]、short[]、int[]、long[]、boolean[]、java.lang.Number 的任何子类的 1-D 数组、java.lang.Boolean 的 1-D 数组和 java.lang.String 的 1-D 数组。目前，仅支持双精度类型的数字稀疏数组。数据数组中任何具有重复 rowindex 和 columnindex 值的元素都会被加在一起。

参数：

返回：具有指定大小并使用提供的数据初始化的新稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(java.lang.Object rArr, java.lang.Object iArr, MWClassID classid)

从提供的完整矩阵构造一个复杂的稀疏数值矩阵。目前，仅支持双精度类型的数字稀疏数组。

参数：

返回：使用提供的数据初始化新的稀疏 MWNumericArray。

抛出：

public static MWNumericArray newSparse(int rows, int cols, int nzmax, MWClassID classid, MWComplexity cmplx)

构造一个没有非零元素的稀疏数值矩阵。

参数：

返回：具有指定大小的新稀疏 MWNumericArray。

抛出：

public int numberOfDimensions()

返回此数组的维数。

指定方：MWArray 类中的 numberOfDimensions

返回：维度数

public int numberOfElements()

返回此数组中元素的总数。

指定方：MWArray 类中的 numberOfElements

返回：元素的数量。

public int numberOfNonZeros()

返回稀疏数组中非零元素的数量。如果基础数组是非稀疏的，则此方法返回与 numberOfElements() 相同的值。

指定方：MWArray 类中的 numberOfNonZeros

返回：稀疏数组中当前非零元素的数量。

protected java.lang.Object readResolve() throws java.io.ObjectStreamException

从字节流加载新数组时由序列化机制调用。此方法验证正确的数组类型。

返回：返回此对象，指示已验证的数组类型。

抛出：

public int[] rowIndex()

返回一个数组，包含底层 MATLAB 数组中每个元素的行索引。

指定方：MWArray 类中的 rowIndex

返回：索引数组。

public byte[] serialize() throws java.io.IOException

将 MATLAB 数组序列化为字节数组。

返回：序列化 MATLAB 数组数据。

抛出：

public void set(int index, double element)

用指定的双精度值替换此数组中指定的基于 1 的偏移量的实部。

参数：

抛出：

public void set(int index, float element)

用指定的浮点值替换此数组中指定的基于 1 的偏移处的实部。

参数：

抛出：

public void set(int index, byte element)

用指定的字节值替换此数组中指定的基于 1 的偏移量的实部。

参数：

抛出：

public void set(int index, int element)

用指定的 int 值替换此数组中指定的基于 1 的偏移量的实部。

参数：

抛出：

public void set(int index, short element)

用指定的短值替换此数组中指定的基于 1 的偏移量的实部。

参数：

抛出：

public void set(int index, long element)

用指定的长值替换此数组中指定的基于 1 的偏移量的实部。

参数：

抛出：

public void set(int[] index, double element)

用指定的双精度值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void set(int[] index, float element)

用指定的浮点值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void set(int[] index, byte element)

用指定的字节值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void set(int[] index, int element)

用指定的 int 值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void set(int[] index, short element)

用指定的短值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void set(int[] index, long element)

用指定的长值替换此数组中指定的基于 1 的索引数组的实部。

参数：

抛出：

public void setData(java.lang.Object data)

指定方：MWArray 类中的 setData

public void setImag(int index, java.lang.Object element)

用指定元素替换此数组中指定基于 1 的偏移处的虚部。

参数：

抛出：

public void setImag(int index, double element)

用指定的双精度值替换此数组中指定的以 1 为基础的偏移量处的虚部。

参数：

抛出：

public void setImag(int index, float element)

用指定的浮点值替换此数组中指定的基于 1 的偏移处的虚部。

参数：

抛出：

public void setImag(int index, byte element)

用指定的字节值替换此数组中指定的基于 1 的偏移处的虚部。

参数：

抛出：

public void setImag(int index, int element)

用指定的 int 值替换此数组中指定的基于 1 的偏移量处的虚部。

参数：

抛出：

public void setImag(int index, short element)

用指定的短值替换此数组中指定的基于 1 的偏移量处的虚部。

参数：

抛出：

public void setImag(int index, long element)

用指定的长值替换此数组中指定的基于 1 的偏移量处的虚部。

参数：

抛出：

public void setImag(int[] index, java.lang.Object element)

用指定元素替换此数组中指定的基于 1 的索引数组处的虚部。

参数：

抛出：

public void setImag(int[] index, double element)

用指定的双精度值替换此数组中指定的基于 1 的索引数组的虚部。

参数：

抛出：

public void setImag(int[] index, float element)

用指定的浮点值替换此数组中指定的基于 1 的索引数组处的虚部。

参数：

抛出：

public void setImag(int[] index, byte element)

用指定的字节值替换此数组中指定的基于 1 的索引数组处的虚部。

参数：

抛出：

public void setImag(int[] index, int element)

用指定的 int 值替换此数组中指定的基于 1 的索引数组处的虚部。

参数：

抛出：

public void setImag(int[] index, short element)

用指定的短值替换此数组中指定的基于 1 的索引数组的虚部。

参数：

抛出：

public void setImag(int[] index, long element)

用指定的长值替换此数组中指定的基于 1 的索引数组的虚部。

参数：

抛出：

public void setImagData(java.lang.Object data)

初始化 MATLAB 数组数据的虚组件。

参数：

抛出：

public java.lang.Object sharedCopy()

创建并返回此数组的一个共享副本。共享副本指向与原始数组相同的底层 MATLAB 数组。更改共享副本中的数据也会更改原始数组。

参数：

返回：MWNumericArray 实例表示底层 MATLAB 数组的共享副本。

抛出：

public java.lang.Object[] toArray()

返回一个包含底层 MATLAB 数组中数据副本的数组。返回的数组具有与底层 MATLAB 数组相同的维度。返回数组的元素按照默认转换规则进行转换。如果底层 MATLAB 数组是复数数值类型，则 toArray 返回实部。如果底层数组是稀疏的，则返回数组的完整表示。在具有较大行和列维度的稀疏数组上调用 toArray 时应小心，因为此操作可能会耗尽系统内存。如果底层数组是元胞或结构体数组，则在每个元胞上递归调用 toArray。

指定方：MWArray 类中的 toArray

返回：与 MATLAB 数组具有相同维数的数组。

public java.lang.Object toByteArray()

返回 Java 原始类型字节的元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toByteArray，则无论底层数组中的数据类型如何，都会返回一个字节类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。

返回：Java 基本类型字节元素的数组

public java.lang.Object toDoubleArray()

返回 Java 原始类型 double 元素的数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toDoubleArray，则无论底层数组中的数据类型如何，都会返回 double 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 基本类型 double 的元素数组

public java.lang.Object toFloatArray()

返回 Java 原始类型 float 的元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toFloatArray，则无论底层数组中的数据类型如何，都会返回 float 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。

示例：使用 toTypeArray 方法

此示例说明如何通过调用任何 toTypeArray 方法将数据强制转换为指定的数值类型。

Object results = null;
try {
 
     // call a compiled m-function
     results = myobject.myfunction(2);
 
     // first output is known to be a numeric matrix
     MWNumericArray resultA = (MWNumericArray) results[0];
     double[][] a = resultA.toDoubleArray();
 
     // second output is known to be a 3-dimensional numeric array
     MWNumericArray resultB = (MWNumericArray) results[1];
     int[][][] b = resultB.toIntArray();
 
 } finally {
     MWNumericArray.disposeArray(results);
 }

返回：Java 原始类型浮点型元素的数组。

public java.lang.Object toImagArray()

返回一个包含底层 MATLAB 数组中虚数据的副本的数组。

返回：与 MATLAB 数组具有相同维数的数组。返回数组的元素按照默认转换规则进行转换。

示例：使用 toImagArray 获取复杂数据

首先创建一个二维复数数组：

double[][] Rdata = {{ 2, 3, 4},
                    { 8 , 9, 10},
                    {14, 15, 16}};
 
double[][] Idata = {{ 6, 5, 14},
                    { 7 , 1, 23},
                    { 1, 1, 9}};
 
MWNumericArray A = new MWNumericArray(Rdata, Idata,
MWClassID.DOUBLE);
 
System.out.println("Complex matrix A =");
System.out.println(A.toString());

2.0000 + 6.0000i 3.0000 + 5.0000i 4.0000 + 14.0000i
8.0000 + 7.0000i 9.0000 + 1.0000i 10.0000 + 23.0000i
14.0000 + 1.0000i 15.0000 + 1.0000i 16.0000 + 9.0000i

double[][] x = (double[][]) A.toImagArray();
int[] dimA = A.getDimensions();
 
System.out.println("The imaginary part of matrix A is:");
for (int i = 0; i < dimA[0]; i++)
{
    for (int j = 0; j < dimA[1]; j++)
    {
  		System.out.print(" " + x[i][j]);
    }
    System.out.println();
}

The imaginary part of matrix A is:
  6.0 5.0 14.0
  7.0 1.0 23.0
  1.0 1.0 9.0

public java.lang.Object toImagByteArray()

返回 Java 原始类型字节的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagByteArray，则无论底层数组中的数据类型如何，都会返回一个字节类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型字节的虚数元素数组。

public java.lang.Object toImagDoubleArray()

返回 Java 原始类型 double 的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagDoubleArray，则无论底层数组中的数据类型如何，都会返回 double 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 基本类型 double 的虚数元素数组

public java.lang.Object toImagFloatArray()

返回 Java 原始类型 float 的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagFloatArray，则无论底层数组中的数据类型如何，都会返回 float 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型浮点型的虚数元素数组。

public java.lang.Object toImagIntArray()

返回 Java 原始类型 int 的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagIntArray，则无论底层数组中的数据类型如何，都会返回一个 int 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 int 的虚数元素数组。

public java.lang.Object toImagLongArray()

返回 Java 原始类型 long 的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagLongArray，则无论底层数组中的数据类型如何，都会返回一个 long 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 long 的虚数元素数组。

public java.lang.Object toImagShortArray()

返回 Java 原始类型 short 的虚数元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toImagShortArray，则无论底层数组中的数据类型如何，都会返回一个 short 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 short 的虚数元素数组。

public java.lang.Object toIntArray()

返回 Java 原始类型 int 的元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toIntArray，则无论底层数组中的数据类型如何，都会返回 int 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 int 的元素数组。

public java.lang.Object toLongArray()

返回 Java 原始类型 long 的元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toLongArray，则无论底层数组中的数据类型如何，都会返回一个 long 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 long 的元素数组。

public java.lang.Object toShortArray()

返回 Java 原始类型 short 的元素数组。返回的数组与底层 MATLAB 数组具有相同的维度。例如，如果调用 toShortArray，则无论底层数组中的数据类型如何，都会返回 short 类型的数组。如果需要，数据将从另一种原始类型转换而来，并且数组的原始维度在返回时保留。如果执行转换，则可能会发生截断或其他精度损失。请参阅 toDoubleArray 中的示例。

返回：Java 原始类型 short 的元素数组。

protected void validate()

验证内部数组句柄。由构造函数和反序列化代码调用。

public static void disposeArray(java.lang.Object obj)

此方法会销毁输入对象中包含的任何原生 MATLAB 数组并释放它们占用的内存。这是类的静态方法，因此不需要引用类的实例来调用。如果输入对象实现了 Disposable 接口，则通过调用其 Disposable.dispose() 方法来释放该对象。如果输入对象代表 Disposable 实例数组，则数组中的每个对象都会被处置。如果输入对象表示 java.lang.Object 数组或多维数组，则会递归处理该数组以释放数组中包含的每个 Disposable 实例。

示例：构造 MWNumericArray 对象

MWArray[] MArr = new MWArray[10];
for (int i = 0; i < 10; i++)
    MArr[i] = new MWNumericArray();
MWArray.disposeArray(MArr);

参数：

finalize()

当垃圾回收确定没有更多对此对象的引用时，由垃圾回收器对该对象调用。

public final Class<?> getClass()

返回此对象的运行时类。

public final void notify()

public final void notifyAll()

唤醒正在等待此对象的监视器的所有线程。

public final void wait(long timeout, int nanos) throws InterruptedException

使当前线程等待，直到另一个线程调用此对象的 notify() 方法或 notifyAll() 方法，或者某个其他线程中断当前线程，或者已经过了一定的实际时间。