示例张量的初始化：

double[] d1_A = {1, 2, 3};
double[] d1_B = {11, 21, 31};
Tensor1D t1_A =  new Tensor1D(d1_A);
Tensor1D t1_B =  new Tensor1D(d1_B);

double[][] d2_A = {{1, 2, 3}, {11, 12, 13}};
double[][] d2_B = {{11, 21, 31}, {12, 22, 32}};
Tensor2D t2_A = new Tensor2D( d2_A );
Tensor2D t2_B = new Tensor2D( d2_B );

double[][][] d3_A = {{{1, 2, 3}, {11, 12, 13}}, {{21, 22, 23}, {31, 32, 33}}};
double[][][] d3_B = {{{11, 21, 31}, {12, 22, 32}}, {{13, 23, 33}, {14, 24, 34}}};
Tensor3D t3_A = new Tensor3D( d3_A );
Tensor3D t3_B = new Tensor3D( d3_B );

1维张量初始化时，默认为行向量。

2维张量初始化时，按照输入的数列，先行后列。

3维张量初始化时，按照先行后列排成矩阵，各个矩阵组成三维张量。

张量的常数加法

每个元素和常数相加：

       Res = A+c

Tensor1D t1_add = (Tensor1D) t1_A.add(1);
t1_add.getData().print();

输出 {2, 3, 4}

Tensor2D t2_add = (Tensor2D) t2_A.add(1);
t2_add.getData().print();

输出 {{2, 3, 4}, {12, 13, 14}}

Tensor3D t3_add = (Tensor3D) t3_A.add(1);
t3_add.getData().print();

输出 {{{2, 3, 4}, {12, 13, 14}}, {{22, 23, 24}, {32, 33, 34}}};

张量间加法

对应元素相加：

       Res = A+B

Tensor1D t1_add = (Tensor1D) t1_A.add(t1_B);
t1_add.getData().print();

输出 {12, 23, 34}

Tensor2D t2_add = (Tensor2D) t2_A.add(t2_B);
t2_add.getData().print();

输出 {{12, 23, 34}, {23, 34, 45}}

Tensor3D t3_add = (Tensor3D) t3_A.add(t3_B);
t3_add.getData().print();

输出 {{{12, 23, 34}, {23, 34, 45}}, {{34, 45, 56}, {45, 56, 67}}};

当两个张量大小不完全一致时，会传出报错MatrixDimensionException

张量的常数减法

每个元素和常数相减：

       Res = A-c

Tensor1D t1_subtract = (Tensor1D) t1_A.subtract(1);
t1_subtract.getData().print();

输出 {0, 1, 2}

Tensor2D t2_subtract = (Tensor2D) t2_A.subtract(1);
t2_subtract.getData().print();

输出 {{0, 1, 2}, {10, 11, 12}}

Tensor3D t3_subtract = (Tensor3D) t3_A.subtract(1);
t3_subtract.getData().print();

输出 {{{0, 1, 2}, {10, 11, 12}}, {{20, 21, 22}, {30, 31, 32}}};

张量间减法

对应元素相减：

       Res = A-B

Tensor1D t1_subtract = (Tensor1D) t1_B.subtract(t1_A);
t1_subtract.getData().print();

输出 {10, 19, 28}

Tensor2D t2_subtract = (Tensor2D) t2_A.subtract(t2_A);
t2_subtract.getData().print();

输出 {{10, 19, 28}, {1, 10, 19}}

Tensor3D t3_subtract = (Tensor3D) t3_A.subtract(t3_A);
t3_subtract.getData().print();

输出 {{{10, 19, 28}, {1, 10, 19}}, {{-8, 1, 10}, {-17, -8, 1}}};

当两个张量大小不完全一致时，会传出报错MatrixDimensionException

张量作为减数的常数减法

每个元素被常数减去：

       Res = c-A

Tensor1D t1_subtract = (Tensor1D) t1_A.subtracted(10);
t1_subtract.getData().print();

输出 {9, 8, 7}

Tensor2D t2_subtract = (Tensor2D) t2_A.subtract(10);
t2_subtract.getData().print();

输出 {{9, 8, 7}, {-1, -2, -3}}

Tensor3D t3_subtract = (Tensor3D) t3_A.subtract(10);
t3_subtract.getData().print();

输出 {{{9, 8, 7}, {-1, -2, -3}}, {{-11, -12, -13}, {-21, -22, -23}}};

张量的常数乘法

每个元素与常数相乘：

       Res = A*c

Tensor1D t1_dot_mul = (Tensor1D) t1_A.dot_mul(2);
t1_dot_mul.getData().print();

输出{2, 4, 6}

Tensor2D t2_dot_mul = (Tensor2D) t2_A.dot_mul(2);
t2_dot_mul.getData().print();

输出 {{2, 4, 6}, {22, 24, 26}}

Tensor3D t3_dot_mul = (Tensor3D) t3_A.dot_mul(2);
t3_dot_mul.getData().print();

输出 {{{9, 8, 7}, {-1, -2, -3}}, {{-11, -12, -13}, {-21, -22, -23}}};

张量间乘法

对应元素相乘：

       Res_i = A_i*B_i

Tensor1D t1_dot_mul = (Tensor1D) t1_A.dot_mul(t1_B);
t1_dot_mul.getData().print();

输出{11, 42, 93}

Tensor2D t2_dot_mul = (Tensor2D) t2_A.dot_mul(t2_B);
t2_dot_mul.getData().print();

输出 {{11, 42, 93}, {132, 264, 416}}

Tensor3D t3_dot_mul = (Tensor3D) t3_A.dot_mul(t3_B);
t3_dot_mul.getData().print();

输出 {{{11, 42, 93}, {132, 264, 416}}, {{273, 506, 759}, {434, 768, 1122}}};

当两个张量大小不完全一致时，会传出报错MatrixDimensionException

张量的常数除法

每个元素除去常数：

       Res = A/c

Tensor1D t1_divided = (Tensor1D) t1_B.divided(2);
t1_divided.getData().print();

输出{5.5, 10.5, 15.5}

Tensor2D t2_divided = (Tensor2D) t2_A.divided(2);
t2_divided.getData().print();

输出 {{5.5, 10.5, 15.5}, {6, 11, 16}}

Tensor3D t3_divided = (Tensor3D) t3_A.dot_mul(2);
t3_divided.getData().print();

输出{{{5.5, 10.5, 15.5}, {6, 11, 16}}, {{6.5, 11.5, 16.5}, {7, 12, 17}}}

张量间除法

对应元素相除：

       Res = A/B

Tensor1D t1_divided = (Tensor1D) t1_B.divided(t1_A);
t1_divided.getData().print();

输出{11, 10.5, 10.333…}

Tensor2D t2_divided = (Tensor2D) t2_B.divided(t2_A);
t2_divided.getData().print();

输出{{11, 10.5, 10.333…}, {1.0909…, 1.8333…, 2.4615}}

Tensor3D t3_divided = (Tensor3D) t3_B.divided(t3_A);
t3_divided.getData().print();

输出{{{11, 10.5, 10.333…}, {1.0909…, 1.8333…, 2.4615}}, {{0.6190…, 1.0455…, 1.4248…}, {0.4516…, 0.75, 1.0303…}}

张量作为除数的常数除法

每个元素被常数除：

       Res = c/A

Tensor1D t1_divide = (Tensor1D) t1_A.divide(10);
t1_divide.getData().print();

输出{10, 5, 3.333…}

Tensor2D t2_divide = (Tensor2D) t2_A.divide(10);
t2_divide.getData().print();

输出{{10, 5, 3.333…}, {0.9090…, 0.8333…, 0.7692…}}

Tensor3D t3_divide = (Tensor3D) t3_A.divide(10);
t3_divide.getData().print();

输出{{{10, 5, 3.333…}, {0.9090…, 0.8333…, 0.7692…}}, {{0.4762…, 0.4545…, 0.4348…}, {0.3226…, 0.3125, 0.3030…}}}

张量间的矩阵乘法

按照矩阵乘法进行运算：

       Res = A*B

Tensor1D t1_cross_mul = (Tensor1D)(t1_A.transpose()).cross_mul(t1_B);
t1_cross_mul.getData().print();

输出{{11, 21, 31}, {22, 42, 62}, {33, 63, 93}}

Tensor2D t2_cross_mul = (Tensor2D)t2_A.cross_mul(t2_B.transpose());
t2_cross_mul.getData().print();

输出 {{146, 152}, {776, 812}}

Tensor3D t3_cross_mul = (Tensor3D) t3_A.cross_mul(t3_B.transpose());
t3_cross_mul.getData().print();

输出 {{{146, 152}, {776, 812}}, {{1538, 1604}, {2228, 2324}}}

张量的幂运算

每个元素作为底数，常数作为指数：

       Res = A^c

Tensor1D t1_pow = (Tensor1D)(t1_A).pow(2);
t1_pow.getData().print();

输出{1, 4, 9}

Tensor2D t2_pow = (Tensor2D)t2_A.pow(2);
t2_pow.getData().print();

输出 {{1, 4, 9}, {121, 144, 169}}

Tensor3D t3_pow = (Tensor3D) t3_A.pow(2);
t3_pow.getData().print();

输出 {{{1, 4, 9}, {121, 144, 169}}, {{441, 484, 529}, {961, 1024, 1089}}}

张量的对数运算

每个元素进行底数为e的对数运算：

       Res = ln(A)

Tensor1D t1_ln = (Tensor1D)(t1_A).ln();
t1_ln.getData().print();

输出{0, 0.6931…, 1.0986…}

Tensor2D t2_ln = (Tensor2D)t2_A.ln();
t2_ln.getData().print();

输出 {{0, 0.6931…, 1.0986…}, {2.3979…, 2.4849…,2.5649…}}

Tensor3D t3_ln = (Tensor3D) t3_A.ln();
t3_ln.getData().print();

输出 {{{0, 0.6931…, 1.0986…}, {2.3979…, 2.4849…,2.5649…}},{{3.0445…, 3.0910…, 3.1355… }, {3.4340…,3.4657…,3.4965…}}}

张量的sigmoid运算

计算每个元素对应的sigmoid函数值

       Res = sigmoid(A)

      S(x)=1/(1+e^(-x))

Tensor1D t1_sigmoid = (Tensor1D)(t1_A).sigmoid();
t1_sigmoid.getData().print();

输出{0.7311…, 0.8808…,0.9526…}

Tensor2D t2_sigmoid = (Tensor2D)t2_A.sigmoid();
t2_sigmoid.getData().print();

输出 {{0.7311…, 0.8808…,0.9526…}, {1.0000…, 1.0000…, 1.0000…}}

Tensor3D t3_sigmoid = (Tensor3D) t3_A.sigmoid();
t3_sigmoid.getData().print();

输出{{{0.7311…, 0.8808…,0.9526…}, {1.0000…, 1.0000…, 1.0000…}}, {{1.0000…, 1.0000…, 1.0000…}, {1.0000…, 1.0000…, 1.0000…}}}

张量的tanh运算

计算每个元素对应的双曲正交函数值：

       Res = tanh(A)

      tanh(x)=(e^x-e^(-x))/(e^x+e^(-x))

Tensor1D t1_tanh = (Tensor1D)(t1_A).tanh();
t1_tanh.getData().print();

输出{0.7616…, 0.9640…, 0.9951…}

Tensor2D t2_tanh = (Tensor2D)t2_A.tanh();
t2_tanh.getData().print();

输出 {{0.7616…, 0.9640…, 0.9951…}, {1.0000…, 1.0000…, 1.0000…}}

Tensor3D t3_tanh = (Tensor3D) t3_A.tanh();
t3_tanh.getData().print();

输出{{{0.7616…, 0.9640…, 0.9951…}, {1.0000…, 1.0000…, 1.0000…}}, {{1.0000…, 1.0000…, 1.0000…}, {1.0000…, 1.0000…, 1.0000…}}}

张量的Relu运算

计算每个元素对应的Relu函数值：

       Res = Relu(A)

      Relu(x,t)=x*t(x>0)

      Relu(x,t)=0(x≤0)

Tensor1D t1_relu = (Tensor1D)(t1_A).Relu(2);
t1_relu.getData().print();

输出{2, 4, 6}

Tensor2D t2_relu = (Tensor2D)t2_A.Relu(2);
t2_relu.getData().print();

输出 {{2, 4, 6}, {22, 24, 26}}

Tensor3D t3_relu = (Tensor3D) t3_A.Relu(2);
t3_relu.getData().print();

输出{{{2, 4, 6}, {22, 24, 26}}, {{42, 44, 46}, {62, 64, 66}}}

张量的softmax运算

计算每个元素对应的Softmax函数值

       Res = softmax()

       Softmax(A_i)=e^i/Σ_je^j

Tensor1D t1_softmax = (Tensor1D)(t1_A).softmax();
t1_softmax.getData().print();

输出{0.0900…, 0.2447…, 0.6652…}

Tensor2D t2_softmax = (Tensor2D)t2_A.softmax();
t2_softmax.getData().print();

输出 {{0.0004…, 0.00001…, 0.00003…}, {0.0900…, 0.2447…, 0.6652…}}

Tensor3D t3_softmax = (Tensor3D) t3_A.softmax();
t3_softmax.getData().print();

输出{{{0.0004…, 0.00001…, 0.00003…}, {0.0900…, 0.2447…, 0.6652…}}, {{0.0004…, 0.00001…, 0.00003…}, {0.0900…, 0.2447…, 0.6652…}}}