J编程语言是APL的继承者（http://www.jsoftware.com）。这些语言是用于处理数据阵列，并且能够隐含地表达复杂的迭代概念。以下是借用的一些概念，由J.思考多维阵列可能都是思想弯曲和思想扩张。它可能需要一些努力掌握这些例子中发生的事情。 iota填充一个阵列，带有计数器z = array.iota（2,3,3）; z.rank; // 3 dimentsz.shape; //给出尺寸的尺寸z = z.reshape（3,2,3）; //重塑更改arrayz.rank的尺寸; // 3 dimentsz.shape;
填充多维数组// 2 dimitionsarray.fill（[3,3]，{1.0.rand.round（0.01）}）; array.fill（[2,3]，{| i，j | i @ j}） ; // 3维度array.fill（[2,2,2]，{1.0.rand.round（0.01）}）; array.fill（[2,3,4]，{| i，j，k | [i ，j，k] .join}）; //更短的变体如上所述：{| i，j，k | [i，j，k] .join}！ [2,3,4]; //更多的维度array.fill（[2,2,4,2]，{| ... args | args.join}）;
使用DUP创建数组（1..4）DUP：3; 100.RAND DUP：10; {100.rand} DUP：10; {100.rand} DUP：3 DUP：4; {{100.rand} DUP ：3} DUP：4; {| I | I.Squared} DUP：10; {| I | | I.Nthprime} DUP：10; {| I，J，K |我* j} dup：[5,5]; //多维dup.
！！是DUP的缩写（1..4）！ 3; 100.rand！ 10; {100.rand}！ 10; {100.rand}！ 3！ 4; {{100.rand}！ 3}！ 4; {| I | I.Squared}！ 10; {| I | I.Nthprime}！ 10; {| I，J |我* j}！ [5,5];
其他方法可以做同样的事情：副词是传递给二进制运算符的第三个参数，该参数修改它们如何迭代序列释放或流。有关更多信息，请参阅二进制运算符的副词帮助文件。 [10,20,30,40,50] + [1,2,3]; //正常[10,20,30,40,50] + .f [1,2,3]; //折叠[10,20,30,40,50] + .s [1,2,3]; //更短[10,20,30,40,50] + .x [1,2,3]; //十字[10,20,30,40,50] + .t [1,2,3]; // 桌子
j有一个名为动词排名的概念，这可能太复杂，无法在sc中理解和实现，但操作员深度是相似和更简单的。二元操作员可以给出一个操作的深度。负面深度迭代相反的操作数。例如，这些更好地理解。目前尚未将副词和深度组合起来。 z = array.iota（3,3）; y = [100,200,300]; z + y; z + .0 y; //与上面相同。 y添加到每行zz +.1 y; // y添加到zz +2 y的每列; // y添加到zz + .-1 y的每个元素; // z添加到y的每个元素
DeepCollect在阵列中以不同的尺寸或深度运行功能。 z = Array.Iotia（3,2,3）; f = {|物品| Item.reverse}; z.deepcollect（0，f）; z.deepcollect（1，f）; z.deepcollect（2，f）; f = {|物品| item.stutter}; z.deepcollect（0，f）; z.deepcollect（1，f）; z.deepcollect（2，f）;
切片可以获得多维阵列的部分。 nil获取维度的所有指数。 z = array.iota（4,5）; z.slice（nil，（1..3））; z.slice（2，（1..3））; z.slice（（2..3）， （0..2））; z.slice（（1..3），3）; z.slice（2,3）; z = array.iota（3,3,3）; z.slice（[0 ，1]，[1,2]，[0,2]）; Z.Slice（nil，Nil，[0,2]）; Z.Slice（1）; Z.Slice（NIL，1）; Z。切片（NIL，NIL，1）; Z.SLICE（NIL，2,1）; Z.SLICE（nil，1，（1..2））; z.slice（1，[0,1]）; z .flop;
生成一个随机数组：订单返回一个索引数组，表示阵列的排序顺序：o = z.Order; y = z [o]; //使用命令作为索引返回排序阵列
订单上的调用订单返回一系列索引，返回原始扰乱顺序的排序阵列：冒泡在一个元素的数组中包装一个项目。它将深度和级别作为参数。类似地，如果它包含单个元素，则解释unlwaps unlwaps。 +++运算符从第二个列表中获取每个项目，并将其追加到第一个列表中的相应项目。如果第二个列表较短，则会包装。 z = array.iota（5,2）; z +++ [77,88,99]; z +++ [[77,88,99]]; z +++ [[77,88,99] ]; z +++ [[77]]，[[88]]，[[99]]]; //相同的是：z +++ [77,88,99] .bbble; z +++ [77,88,99] .bbbble（0,2）; z +++ [77,88,99] .bbbble（1,2）; z +++ [11,22,33]。七r; z + ++ [11,22,33] .Pylamidg.Bubble; Z +++ [[11,22,33]。z +++ [[11,22,33]。七瓦拉米];（z =（1..4）; 10.Do {| i | Z.Pyramid（I + 1）.postln; z.pyramidg（i + 1）.postln;＆＃34;＆＃34; .postln;}; ）
Reshapelike允许您以与另一个相同的方式重构一个嵌套阵列。 a = [[10,20]，[30,40,50]，60,70，[80,90]]; b = [[1,2，[3,4]，[[5]，6]， 7]，8，[[9]]]; A.Reshapelike（B）; B.Reshapelike（A）;
如果长度不同，默认行为是包装：a = [[10,20]，[30,40,50]]; b = [[1,2，[3,4]，[[5]， 6]，7]，8，[[9]]]; A.Reshapelike（B）;
但您可以指定其他索引运算符：MaxSizeAtDepth允许您在给定深度尺寸[[1,2,3]，[[41,52]，5,6]，1,2,3]处检查最大阵列大小。 maxsizeatdepth（2）; [[1,2,3]，[[41,52]，5,6]，1,2,3] .maxsizeatdepth（1）; [[1,2,3]，[[41 ，52]，5,6]，1,2,3] .maxsizeatdepth（0）;（0..3）.collect（[[1,2,3]，[[41,52]，5,6] ，1,2,3] .maxsizeatdepth（_））//每个维度的最大尺寸
FLOPDEEP允许您以任何深度倒置最外层的尺寸。这类似于拖动，这对于二维阵列相同。 [[1,2,3]，[[41,52]，5,6]]。FLOPDEEP（2）; [[1,2,3]，[[41,52]，5,6]]。FLOPDEEP （1）; [[1,2,3]，[[41,52]，5,6]]。FLOPDEEP（0）; [[1,2,3]，[[41,52]，5,6 ]。浮潜; //没有参数，从最深的水平开始[[[10,100,1000]，2,3]，[[41,52]，5,6]]。FLOPDEEP（2）; //缩短阵列包裹[]。FLOPDEEP（1）; //结果始终较高。[[]]。FLOPDEEP（4）;