简介

数组（Array）是一种灵活的数据结构，数组类型包括一维数组、二维数组、三维数组、多维数组等。当待解决问题涉及高维度模型、线性代数等时，用户可以使用Array类。PIE-Engine Studio提供构建数组算子及数组相关算法，包括但不限于四则运算、按位运算、逻辑运算、切片、矩阵计算。

Array

构造函数，返回一个由给定参数构建的Array对象。

函数	返回值
Array(values, pixelType=7,row=0, col=0 ,depth=0)	Image

参数	类型	说明
values	Number|Array	数值或Js的数组对象
pixelType	Number	数据类型，5:整型，6:单精度浮点型，7:双精度浮点型
row	Number	矩阵的行数
col	Number	矩阵的列数
depth	Number	矩阵的深度

var array1 = pie.Array([0,1,2,3,4,5,6,7,8]);
print(array1)
var array2 = pie.Array([[0,1,2,3,4,5,6,7,8]]);
print(array2)
var array3 = pie.Array([[0],[1],[2],[3],[4],[5],[6],[7],[8]]);
print(array3)
var array4 = pie.Array([[[0,1,2,3,4,5,6,7,8]]]);
print(array4)
var array5 = pie.Array([[0,1,2],[3,4,5],[6,7,8]]);
print(array5)
var array6 = pie.Array([[[0,1,2],[3,4,5],[6,7,8]]]);
print(array6)
var array7 = pie.Array([[[0,1,2],[3,4,5]],[[6,7,8],[3,2,1]]]);
print(array7)
// var array8 = pie.Array([[0,1,2],[3,"s",5],[6,"k",8]]); // 异常
// var array9 = pie.Array([[[0,"1",2],[3,4,5]],[[6,7,8],[3,2,1]]]); // 异常

abs

以一个元素为单位，计算输入值的绝对值。

函数	返回值
abs()	Array

var array=new pie.Array([[[0, -1], [-2, 3]], [[4, -5], [-6, 7]]]);
print(array.abs());  //[[[0, 1], [2, 3]], [[4, 5], [6, 7]]]

accum

通过将结果的每个元素设置为沿该轴到当前位置（包括当前位置）的元素累积值。可用于累积和、单调递增序列等。

函数	返回值
accum(axis,reducer)	Array

参数	类型	说明
axis	Int	沿其进行累加的轴
reducer	Reducer	累积计算器。默认值为SUM，以生成沿给定轴的每个向量的累计计算值

var array1=new pie.Array([-1]);
print(array1.accum(0));  // [-1]
var array2=new pie.Array([-2, 1]);
print(array2.accum(0));  // [-2, -1]
var array3=new pie.Array([-2, 1, 9]);
print(array3.accum(0));  //  [-2, -1, 8]

var array4=new pie.Array([[1, 3], [5, 7]]);
print(array4.accum(0));  // [[1,3],[6,10]]
print(array4.accum(1));  // [[1,4],[5,12]]

var array5=new pie.Array([2, -2, 3, 1]);
print(array5.accum(0));  // [2,0,3,4]
print(array5.accum(0,pie.Reducer.sum()));  // [2,0,3,4]
print(array5.accum(0,pie.Reducer.max()));  // [2,2,3,3]
print(array5.accum(0,pie.Reducer.mean()));  // [2,0,1,1]
print(array5.accum(0,pie.Reducer.min()));  // [2,-2,-2,-2]

add

以每个元素为单位，做左边矩阵与右边矩阵相加的运算。

函数	返回值
add(right)	Array

参数	类型	说明
right	Array|Int	加号右侧矩阵或数值

var array1=new pie.Array([0]);
print(array1.add(1));  // [1]
print(array1.add([2]));  // [2]

var array2=new pie.Array([5, 6]);
print(array2.add(1));  // [6,7]
print(array2.add([7, 8]));  // [12,14]

var array3 = new pie.Array([[0, 1, 2], [3, 4, 5]]);
print(array3.add(1));  // [[1,2,3],[4,5,6]]
print(array3.add(array3));  // [[0,2,4],[6,8,10]]

and

以每个元素为单位，做矩阵“与”运算。如果左右两个矩阵相对应位置上的元素值都不为零，则返回1。

函数	返回值
and(right)	Array

参数	类型	说明
right	Array|Int	右侧矩阵或数值

var array1=new pie.Array([1, 0, 3]);
print(array1.and(1));  // [1,0,1]
print(array1.and([0,5,4]));  //[0,0,1]

var array2=new pie.Array([[1,2,0]]);
print(array2.and(3));  // [[1,1,0]]
print(array2.and(new pie.Array([[0.5,0,0]])));  // [[1,0,0]]

bitsToArray

将整数位转换为数组。输出数组的元素个数与输入值的位数相同，当输入值为0时输出数组中只有0。

函数	返回值
bitsToArray(input)	Array

参数	类型	说明
input	Number	输入数值

print(pie.Array().bitsToArray(0));  // [0]
print(pie.Array().bitsToArray(1));  // [1]
print(pie.Array().bitsToArray(5));  // [1, 0 , 1]
print(pie.Array().bitsToArray(0xFF));  // [1,1,1,1,1,1,1,1]
print(pie.Array().bitsToArray(-1));  // [0,1]

bitwiseAnd

矩阵按位“与”运算。

函数	返回值
bitwiseAnd(right)	Array

参数	类型	说明
right	Array|Int	右侧矩阵或数值

var array0=new pie.Array(0);
var array1=new pie.Array(1);
print(array1.bitwiseAnd(1));  //[1]
print(array1.bitwiseAnd(array0));  //[0]
print(array1.bitwiseAnd(0));  //[0]

var array2=new pie.Array(0xFF);
var array3=new pie.Array(0xFFFF);
print(array2.bitwiseAnd(array3));  //[255]
print(array3.bitwiseAnd(array2));  //[255]

var array4=new pie.Array(-1);
var array5=new pie.Array(-2);
print(array4.bitwiseAnd(array2));  //[255]
print(array4.bitwiseAnd(array5));  //[-2]

var array6=new pie.Array([6,6]);
var array7=new pie.Array([1,11]);
print(array6.bitwiseAnd(array7));  //[0,2]

bitwiseNot

矩阵按位“非”运算。

函数	返回值
bitwiseNot()	Array

var array0=new pie.Array(0);
var array1=new pie.Array(1);
var array2=new pie.Array(0xFF);
var array3=new pie.Array(-1);
var array4=new pie.Array(-2);
var array5=new pie.Array([1,-1]);
print(array0.bitwiseNot());  //[-1]
print(array1.bitwiseNot());  //[-2]
print(array2.bitwiseNot());  //[-256]
print(array3.bitwiseNot());  //[0]
print(array4.bitwiseNot());  //[1]
print(array5.bitwiseNot());  //[-2,0]

bitwiseOr

矩阵按位“或”运算。

函数	返回值
bitwiseOr(right)	Array

参数	类型	说明
right	Array|Int	右侧矩阵或数值

var array0=new pie.Array(0);
var array1=new pie.Array(1);
print(array1.bitwiseOr(1));  //[1]
print(array1.bitwiseOr(array0));  //[1]
print(array1.bitwiseOr(0));  //[1]
print(array0.bitwiseOr(0));  //[0]

var array2=new pie.Array(0xFF);
var array3=new pie.Array(0xFFFF);
print(array2.bitwiseOr(array3));  //[65535]
print(array3.bitwiseOr(array2));  //[65535]

var array4=new pie.Array(-1);
var array5=new pie.Array(-2);
print(array4.bitwiseOr(array2));  //[-1]
print(array5.bitwiseOr(-4));  //[-2]

var array6=new pie.Array([6,6]);
var array7=new pie.Array([1,11]);
print(array6.bitwiseOr(array7));  //[7,15]

bitwiseXor

矩阵按位“异或”运算。

函数	返回值
bitwiseXor(right)	Array

参数	类型	说明
right	Array|Int	右侧矩阵或数值

var array0=new pie.Array(0);
var array1=new pie.Array(1);
print(array1.bitwiseXor(1));  //[0]
print(array1.bitwiseXor(array0));  //[1]
print(array0.bitwiseXor(array1));  //[1]
print(array0.bitwiseXor(0));  //[0]

var array2=new pie.Array(0x00FF);
var array3=new pie.Array(0xFF00);
print(array2.bitwiseXor(array3));  //[65535]

var array4=new pie.Array([1,2,3]);
var array5=new pie.Array([5,8,16]);
print(array4.bitwiseXor(array5));  //[4,10,19]

cat

沿着给定的轴将多个数组连接成一个数组。除连接轴外，被连接的每个数组在所有轴上的维度和长度必须相同。

函数	返回值
cat (arrays,axis)	Array

参数	类型	说明
arrays	Array	要连接的数组
axis	Int	要连接的轴，默认为0

var array1 = new pie.Array([1]);
var array2 = new pie.Array([2]);
print(array1.cat(array2)); //[1,2]
print(array1.cat([array1, array2], 0)); //[1,1,2]
print(array1.cat([array2], 1)); //[[1,2]]

var array3 = new pie.Array([0, 1, 2]);
var array4 = new pie.Array([3, 4, 5]);
print(array3.cat(array4));   //[0,1,2,3,4,5]
print(array3.cat([array4], 0));   //[0,1,2,3,4,5]
print(array3.cat(array4, 1));   //[[0,3],[1,4],[2,5]]
print(array3.cat([array4, array2], 0));   //[0,1,2,3,4,5,2]

var array5 = new pie.Array([[0], [1], [2]]);
var array6 = new pie.Array([[3], [4], [5]]);
var array9 = new pie.Array([[6], [7], [8]]);
var array10 = new pie.Array([[6]]);
print(array5.cat(array6));   // [[0],[1],[2],[3],[4],[5]]
print(array5.cat([array6], 0));   // [[0],[1],[2],[3],[4],[5]]
print(array5.cat(array6, 1));   //[[0,3],[1,4],[2,5]]
print(array5.cat([array5, array6], 2));   //[[[0,0,3]],[[1,1,4]],[[2,2,5]]]
print(array5.cat([array6, array9], 0));   // [[0],[1],[2],[3],[4],[5],[6],[7],[8]]
print(array5.cat([array10], 0));   // [[0],[1],[2],[6]]

var array7 = new pie.Array([[[0, 1], [2, 3]], [[4, 5], [6, 7]]]);
var array8 = new pie.Array([[[10, 11], [12, 13]], [[14, 15], [16, 17]]])
var array11 = new pie.Array([[[10, 11], [12, 13]]])
var array12 = new pie.Array([[[0, 1]], [[4, 5]]]);
var array13 = new pie.Array([[[0]], [[4]]]);
print(array7.cat(array8));//[[[0,1],[2,3]],[[4,5],[6,7]],[[10,11],[12,13]],[[14,15],[16,17]]]
print(array7.cat([array8], 0));//[[[0,1],[2,3]],[[4,5],[6,7]],[[10,11],[12,13]],[[14,15],[16,17]]]
print(array7.cat(array8, 1));// [[[0,1],[2,3],[10,11],[12,13]],[[4,5],[6,7],[14,15],[16,17]]]
print(array7.cat(array8, 2));// [[[0,1,10,11],[2,3,12,13]],[[4,5,14,15],[6,7,16,17]]]
print(array7.cat([array11], 0));//[[[0,1],[2,3]],[[4,5],[6,7]],[[10,11],[12,13]]]
print(array12.cat(array8, 1));// [[[0,1],[10,11],[12,13]],[[4,5],[14,15],[16,17]]]
print(array12.cat(array13, 2));// [[[0,1,0]],[[4,5,4]]]

divide

以每个元素为单位，做左边矩阵除以右边矩阵的运算。

函数	返回值
divide(right)	Array

参数	类型	说明
right	Array|Int	除号右侧矩阵或数值

var array1=new pie.Array([1, 2, 3]);
print(array1.divide(2));  // [0.5,1,1.5]
print(array1.divide([2,0,5]));  //[0.5,0,0.6]

var array2=new pie.Array([[3,6,9]]);
print(array2.divide(3));  // [[1,2,3]]
print(array2.divide(array2));  // [[1,1,1]]

get

从输入数组中提取给定位置的值。

函数	返回值
get(position)	Number

参数	类型	说明
position	List	指定位置的索引值

print(pie.Array([9]).get([0]));  // 9
print(pie.Array([8, 7, 6]).get([2]));  // 6

var array = pie.Array([[0, 1, 2], [3, 4, 5]]);
print(array.get([0, 0]));  // 0
print(array.get([0, 1]));  // 1
print(array.get([1, 0]));  // 3
print(array.get([1, 2]));  // 5

var array2 = pie.Array([[[0, 1, 2], [3, 4, 5]],[[6,7,8],[9,10,11]]]);
print(array2.get([0, 0,2]));  // 2
print(array2.get([0, 1,0]));  // 3
print(array2.get([1, 0,1]));  // 7
print(array2.get([1, 1,2]));  // 11

length

获取Array长度。

函数	返回值
length()	Number

var array = new pie.Array([2,2,3]);
print(array.length());  //3

matrixCholeskyDecomposition

计算矩阵Cholesky方式分解，分解后满足A = L*L'，返回包含1个名为“L”的条目的字典。目标矩阵必须为对称正定矩阵。

函数	返回值
matrixCholeskyDecomposition()	Dictionary

var array=new pie.Array([[1,1,1],[1,2,1],[1,1,3]]);
print(array.matrixCholeskyDecomposition());  // L:[[1, 0, 0],[ 1, 1, 0], [1, 0, 1.4142135623730951]]

matrixDeterminant

计算矩阵行列式。

函数	返回值
matrixDeterminant()	Double

var array=new pie.Array([[1,2],[3,4]]);
print(array.matrixDeterminant());  //-2

matrixDiagonal

计算矩阵的单列对角线矩阵。

函数	返回值
matrixDiagonal()	Array

var array1=new pie.Array([[1,2,3],[4,5,6],[7,8,9]]);
print(array1.matrixDiagonal());  //[[1],[5],[9]]
var array2=new pie.Array([[1,2,3,4,3,4],[5,6,7,8,9,0]]);
print(array2.matrixDiagonal());  //[[1],[6]]
var array3=new pie.Array([[1,2,3],[4,3,11],[5,6,7],[8,9,0],[11,12,13]]);
print(array3.matrixDiagonal());  //[[1],[3],[7]]

matrixFnorm

获取矩阵的Frobenius范数

函数	返回值
matrixFnorm()	Double

var array=new pie.Array([[1,2],[-1,-3]]);
print(array.matrixFnorm());  //3.872983346207417

matrixInverse

获取矩阵的逆矩阵。

函数	返回值
matrixInverse()	Array

var array=new pie.Array([[1,2],[-1,-3]]);
print(array.matrixInverse());  //[[3,2],[-1,-1]]

matrixLUDecomposition

计算矩阵的LU分解，使得P×input=L×U，其中L是下三角矩阵（具有单位对角线项），U是上三角矩阵，P是置换矩阵。输入矩阵必须是可逆方阵。返回包含名为“L”、“U”和“P”的条目的字典。

函数	返回值
matrixLUDecomposition()	Dictionary

var array = new pie.Array([[0,3,1],[0,4,-2],[2,1,2]]);
print(array.matrixLUDecomposition());
//L:[[1,0,0],[0,1,0],[0,0.75,1]]
//U:[[2,1,2],[0,4,-2],[0,0,2.5]]
//P:[[0,0,1],[0,1,0],[1,0,0]]

matrixMultiply

矩阵乘法，返回矩阵A*B的结果。要求左操作数矩阵的列数和右操作数矩阵的行数相同。

函数	返回值
matrixMultiply(right)	Image

参数	类型	说明
this	Image	影像矩阵相乘左操作影像
right	Image	影像矩阵相乘右操作影像

var array2D_1 = pie.Array(100,7,50,50,0);
var arrayResult_1 = array2D_1.matrixMultiply(array2D_1);
print(arrayResult_1);

var array2D_2 = pie.Array([[0,1,2],[3,4,5],[6,7,8]]);
var arrayResult_2 = array2D_2.matrixMultiply(array2D_2);
print(arrayResult_2);

matrixPseudoInverse

计算矩阵的伪逆矩阵。

函数	返回值
matrixPseudoInverse()	Array

var array=new pie.Array([[0.68,0.597,-0.211],[0.823,0.566,-0.605]]);
print(array.matrixPseudoInverse()); //list:[0.6617875902899146,0.10598833168162608]
// [1.8516869517632997,-0.9769994411472234]
// [2.632571903316739,-2.4227327053146284]

matrixQRDecomposition

计算矩阵的QR分解，求解两个矩阵Q和R，使得输入矩阵=Q*R，其中Q是正交矩阵，R是上三角矩阵。返回包含名为“Q”和“R”的条目的字典。

函数	返回值
matrixQRDecomposition ()	Dictionary

var array=new pie.Array([[0,3,1],[0,4,-2],[2,1,2]]);
print(array.matrixQRDecomposition());
//Q:[[0, -0.6, -0.8],[ 0, -0.8, 0.6], [-1, 0, 0]]
//R:[[-2, -1, -2],[ 0, -5, 1],[0, 0, -2]]

matrixSingularValueDecomposition

计算矩阵的奇异值分解，使得A= USV'，其中U和V正交阵，S是对角阵。返回包含名为“U”、“S”和“V”的条目的字典。

函数	返回值
matrixSingularValueDecomposition()	Dictionary

var array = new pie.Array([[0,3,1],[0,4,-2],[2,1,2]]);
print(array.matrixSingularValueDecomposition());
//S:[[5.156714587672306,0,0],[0,3.3236396541361146,0],[0,0,1.1669250664638078]]
//U:[[0.5437474178251441,0.34887107411769774,-0.7633005432019889],
// [0.8248964264706629,-0.3896512121287633,0.40953365976744244],
// [0.15454653410677902,0.8523267604214646,0.4996543427861234]]
//V:[[0.059939921622282295,0.5128875865714163,0.8563606304220569],
//  [0.9861655918716171,0.10239832523239198,-0.13035339810723937],
//  [-0.154546534106779,0.8523267604214648,-0.4996543427861233]]

matrixSolve

求解矩阵方程A*x=B中的x，若A超定，则求最小二乘解。

函数	返回值
matrixSolve(right)	Array

参数	类型	说明
right	Array	右侧矩阵

var arrayA = new pie.Array([[1, 2, 3], [4, 5, 6], [7, 8, 10]]);
var arrayB = new pie.Array([[3], [3], [4]]);
var arrayX = arrayA.matrixSolve(arrayB);
print(arrayX);  //[[-2.000000000000005], [1.0000000000000042], [1]]

matrixToDiag

计算单列矩阵的正方形对角矩阵。

函数	返回值
matrixToDiag()	Array

var array1=new pie.Array([[1],[2],[3]]);
print(array1.matrixToDiag());   //[[1,0,0],[0,2,0],[0,0,3]]
var array2=new pie.Array([[1]]);
print(array2.matrixToDiag());  //[[1]]

matrixTrace

计算矩阵的迹。

函数	返回值
matrixTrace()	Number

var array1=new pie.Array([[1,2,3,4,5],[6,7,8,9,10]]);
print(array1.matrixTrace());  //8
var array2=new pie.Array([[1,2,3],[3,4,5],[6,7,8],[8,9,10]]);
print(array2.matrixTrace());  //13
var array3=new pie.Array([[1,2],[3,4],[6,7],[8,9]]);
print(array3.matrixTrace());  //5

matrixTranspose

获取矩阵的转置矩阵。

函数	返回值
matrixTranspose()	Array

var array1=new pie.Array([[1,2,3,4,5],[6,7,8,9,10]]);
print(array1.matrixTranspose());  //[[1,6],[2,7],[3,8],[4,9],[5,10]]
var array2=new pie.Array([[1,2,3],[3,4,5],[6,7,8],[8,9,10]]);
print(array2.matrixTranspose());  //[[1,3,6,8],[2,4,7,9],[3,5,8,10]]
var array3=new pie.Array([[1,2],[3,4],[6,7],[8,9]]);
print(array3.matrixTranspose());  //[[1,3,6,8],[2,4,7,9]]

multiply

以每个元素为单位，做左边矩阵与右边矩阵相乘的运算。

函数	返回值
multiply(right)	Array

参数	类型	说明
right	Array|Int	乘号右侧矩阵或数值

var array1=new pie.Array([1, 2, 3]);
print(array1.multiply(3));  // [3,6,9]
print(array1.multiply([6,5,4]));  //[6,10,12]

var array2=new pie.Array([[1,2,3]]);
print(array2.multiply(3));  // [[3,6,9]]
print(array2.multiply(array2));  // [[1,4,9]]

not

以每个元素为单位，做矩阵“非”运算。如果输入元素为非零，则在该元素位置上返回0，否则返回1。

函数	返回值
not()	Array

var array1=new pie.Array([1, 0, -3]);
print(array1.not());  // [0,1,0]
var array2=new pie.Array([[1,-2],[-0,0]]);
print(array2.not());  // [[0,0][1,1]]

or

以每个元素为单位，做矩阵“或”运算。如果左右两个矩阵相对应位置上的元素中任意一个不为零，则返回1。

函数	返回值
or(right)	Array

参数	类型	说明
right	Array|Int	右侧矩阵或数值

var array1=new pie.Array([1, 0, 3]);
print(array1.or(0));  // [1,0,1]
print(array1.or([0,0,4]));  //[1,0,1]

var array2=new pie.Array([[1,2,0]]);
print(array2.or(3));  // [[1,1,1]]
print(array2.or(new pie.Array([[0.5,0,0]])));  // [[1,1,0]]

slice

通过按“step”的增量沿给定轴从“start”（包含）到“end”（不包含）的每个位置切片，创建子阵列。结果将具有与输入一样多的维度，并且在除切片轴之外的所有方向上的长度都相同，其中长度是从“start”到“end”根据在沿“axis”轴的输入数组长度范围内的“step”得到的位置数。这意味着，如果start=end，或者start或end值完全超出范围，则结果为沿着给定轴的长度0。

函数	返回值
slice(axis, start, end, step)	Array

参数	类型	说明
axis	Int	轴
start	Int	沿“axis”的第一个切片（包括第一个切片）的坐标。负数用于表示切片的开始位置相对于数组末尾的位置，其中-1表示从轴上的最后一个位置开始，-2表示从倒数第二个位置开始，依此类推。默认值为0
end	Int	停止切片的坐标（不包含切片）。默认情况下，值为给定轴的长度。负数用于表示切片的结束位置相对于数组末尾的位置，其中-1将排除最后一个位置，-2将排除最后两个位置，依此类推。默认值为null
step	Int	沿“轴”的每个切片之间的间隔；从“start”（包括在内）到“end”（不包括在内）的每一个“step”的整数倍处都将取一个切片。值必须为正整数。默认值为1

var array1=new pie.Array([1, 2, 3, 4, 5, 6]);
print(array1.slice());  // [1,2,3,4,5,6]
print(array1.slice(0));  // [1,2,3,4,5,6]
print(array1.slice(0, 0, 6, 1));  // [1,2,3,4,5,6]
print(array1.slice(0, 0, 10, 1));  // [1,2,3,4,5,6]
print(array1.slice(0,2));  //[3,4,5,6]
print(array1.slice(0,5));  //[6]
print(array1.slice(0,6));  //[]
print(array1.slice(0,0,2));  //[1,2]
print(array1.slice(0,0,0));  //[]
print(array1.slice(0,0, -3));  //[1,2,3]
print(array1.slice(0, -2, 6));  //[5,6]
print(array1.slice(0, 0, 6, 2));  //[1,3,5]
print(array1.slice(0, 0, 6, 3));  // [1,4]
print(array1.slice(0, 0, 6, 4));  // [1,5]
print(array1.slice(0, 0, 6, 6));  // [1]
print(array1.slice(0, 2, 6, 2));  //[3,5]
print(array1.slice(0, 2, 6, 2));  //[3,5]

var array2=new pie.Array([[1, 2], [3, 4], [5, 6]]);
print(array2.slice());  //[[1,2],[3,4],[5,6]]
print(array2.slice(0));  //[[1,2],[3,4],[5,6]]
print(array2.slice(0,0));  //[[1,2],[3,4],[5,6]]
print(array2.slice(0,0,1));  //[[1,2]]
print(array2.slice(0,0,2));  //[[1,2],[3,4]]
print(array2.slice(0, 0, 3, 1));  // [[1,2],[3,4],[5,6]]
print(array2.slice(0, 0, 3, 2));  //[[1,2],[5,6]]
print(array2.slice(0, 1, 3, 2));  //[[3,4]]
print(array2.slice(0, 0, 3, 3));  //[[1,2]]

print(array2.slice(1));  //[[1,2],[3,4],[5,6]]
print(array2.slice(1,1));  //[[2],[4],[6]]
print(array2.slice(1,0,1));  //[[1],[3],[5]]

subtract

以每个元素为单位，做左边矩阵与右边矩阵相减的运算。

函数	返回值
subtract(right)	Array

参数	类型	说明
right	Array|Int	减号右侧矩阵或数值

var array1=new pie.Array([1, 2, 3, 4, 5, 6]);
print(array1.subtract(3));  // [-2,-1,0,1,2,3]
print(array1.subtract([6,5,4,3,2,1]));  //[-5,-3,-1,1,3,5]

var array2=new pie.Array([[1,2,3]]);
print(array2.subtract(3));  // [[-2,-1,0]]
print(array2.subtract(array2));  // [[0,0,0]]

transpos

将数组的两个维度进行转置。

函数	返回值
transpose(axis1,axis2)	Array

参数	类型	说明
axis1	Int	被转置的第一个轴，默认值为0
axis2	Int	被转置的第二个轴，默认值为1

var array1=new pie.Array([1, 2, 3, 4, 5, 6]);
print(array1.transpose(0,0));  // [1,2,3,4,5,6]

var array2=new pie.Array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]]);
print(array2.transpose(0,0));  // [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print(array2.transpose(0,1));  // [[1,4,7,10],[2,5,8,11],[3,6,9,12]]
print(array2.transpose(1,0));  // [[1,4,7,10],[2,5,8,11],[3,6,9,12]]
print(array2.transpose(1,1));  // [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print(array2.transpose());  // [[1,4,7,10],[2,5,8,11],[3,6,9,12]]