Array
# 简介
数组(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]]