@Beta
public final class f
extends java.lang.Object
| Modifier and Type | Method and Description |
|---|---|
static byte[][][] |
add(byte[][][] a,
byte[][][] b) |
static byte[][][] |
add(byte[][][] a,
byte[][][] b,
byte[][][] c) |
static byte[][][] |
add(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][][] |
add(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[][] |
add(byte[][] a,
byte[][] b) |
static byte[][] |
add(byte[][] a,
byte[][] b,
byte[][] c) |
static byte[][] |
add(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][] |
add(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[] |
add(byte[] a,
byte[] b) |
static byte[] |
add(byte[] a,
byte[] b,
byte[] c) |
static byte[] |
add(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[] |
add(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB) |
static double[][][] |
add(double[][][] a,
double[][][] b) |
static double[][][] |
add(double[][][] a,
double[][][] b,
double[][][] c) |
static double[][][] |
add(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][][] |
add(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB) |
static double[][] |
add(double[][] a,
double[][] b) |
static double[][] |
add(double[][] a,
double[][] b,
double[][] c) |
static double[][] |
add(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][] |
add(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB) |
static double[] |
add(double[] a,
double[] b) |
static double[] |
add(double[] a,
double[] b,
double[] c) |
static double[] |
add(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[] |
add(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB) |
static float[][][] |
add(float[][][] a,
float[][][] b) |
static float[][][] |
add(float[][][] a,
float[][][] b,
float[][][] c) |
static float[][][] |
add(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][][] |
add(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB) |
static float[][] |
add(float[][] a,
float[][] b) |
static float[][] |
add(float[][] a,
float[][] b,
float[][] c) |
static float[][] |
add(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][] |
add(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB) |
static float[] |
add(float[] a,
float[] b) |
static float[] |
add(float[] a,
float[] b,
float[] c) |
static float[] |
add(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[] |
add(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB) |
static int[][][] |
add(int[][][] a,
int[][][] b) |
static int[][][] |
add(int[][][] a,
int[][][] b,
int[][][] c) |
static int[][][] |
add(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][][] |
add(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB) |
static int[][] |
add(int[][] a,
int[][] b) |
static int[][] |
add(int[][] a,
int[][] b,
int[][] c) |
static int[][] |
add(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][] |
add(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB) |
static int[] |
add(int[] a,
int[] b) |
static int[] |
add(int[] a,
int[] b,
int[] c) |
static int[] |
add(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[] |
add(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB) |
static long[][][] |
add(long[][][] a,
long[][][] b) |
static long[][][] |
add(long[][][] a,
long[][][] b,
long[][][] c) |
static long[][][] |
add(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][][] |
add(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB) |
static long[][] |
add(long[][] a,
long[][] b) |
static long[][] |
add(long[][] a,
long[][] b,
long[][] c) |
static long[][] |
add(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][] |
add(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB) |
static long[] |
add(long[] a,
long[] b) |
static long[] |
add(long[] a,
long[] b,
long[] c) |
static long[] |
add(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[] |
add(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB) |
static short[][][] |
add(short[][][] a,
short[][][] b) |
static short[][][] |
add(short[][][] a,
short[][][] b,
short[][][] c) |
static short[][][] |
add(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][][] |
add(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB) |
static short[][] |
add(short[][] a,
short[][] b) |
static short[][] |
add(short[][] a,
short[][] b,
short[][] c) |
static short[][] |
add(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][] |
add(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB) |
static short[] |
add(short[] a,
short[] b) |
static short[] |
add(short[] a,
short[] b,
short[] c) |
static short[] |
add(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[] |
add(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB) |
static java.lang.Boolean[] |
box(boolean[] a) |
static java.lang.Boolean[][] |
box(boolean[][] a) |
static java.lang.Boolean[][][] |
box(boolean[][][] a) |
static java.lang.Byte[] |
box(byte[] a) |
static java.lang.Byte[][] |
box(byte[][] a) |
static java.lang.Byte[][][] |
box(byte[][][] a) |
static java.lang.Character[] |
box(char[] a) |
static java.lang.Character[][] |
box(char[][] a) |
static java.lang.Character[][][] |
box(char[][][] a) |
static java.lang.Double[] |
box(double[] a) |
static java.lang.Double[][] |
box(double[][] a) |
static java.lang.Double[][][] |
box(double[][][] a) |
static java.lang.Float[] |
box(float[] a) |
static java.lang.Float[][] |
box(float[][] a) |
static java.lang.Float[][][] |
box(float[][][] a) |
static java.lang.Integer[] |
box(int[] a) |
static java.lang.Integer[][] |
box(int[][] a) |
static java.lang.Integer[][][] |
box(int[][][] a) |
static java.lang.Long[] |
box(long[] a) |
static java.lang.Long[][] |
box(long[][] a) |
static java.lang.Long[][][] |
box(long[][][] a) |
static java.lang.Short[] |
box(short[] a) |
static java.lang.Short[][] |
box(short[][] a) |
static java.lang.Short[][][] |
box(short[][][] a) |
static <T> T[][][] |
copy(java.lang.Class<T[][][]> newType,
java.lang.Object[][][] a) |
static <T> T[][] |
copy(java.lang.Class<T[][]> newType,
java.lang.Object[][] a) |
static <T> T[] |
copy(java.lang.Class<T[]> newType,
java.lang.Object[] a) |
static void |
dividedBy(byte[][][] a,
byte param) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte defaultValueForZero) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte defaultValueForZero) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[][][] |
dividedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero) |
static void |
dividedBy(byte[][] a,
byte param) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte defaultValueForZero) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte[][] c) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte defaultValueForZero) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[][] |
dividedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero) |
static void |
dividedBy(byte[] a,
byte param) |
static byte[] |
dividedBy(byte[] a,
byte[] b) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte defaultValueForZero) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte[] c) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte[] c,
byte defaultValueForZero) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[] |
dividedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero) |
static void |
dividedBy(char[][][] a,
int param) |
static void |
dividedBy(char[][] a,
int param) |
static void |
dividedBy(char[] a,
int param) |
static void |
dividedBy(double[][][] a,
double param) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double defaultValueForZero) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double[][][] c) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double defaultValueForZero) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB) |
static double[][][] |
dividedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero) |
static void |
dividedBy(double[][] a,
double param) |
static double[][] |
dividedBy(double[][] a,
double[][] b) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double defaultValueForZero) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double[][] c) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double[][] c,
double defaultValueForZero) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB) |
static double[][] |
dividedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero) |
static void |
dividedBy(double[] a,
double param) |
static double[] |
dividedBy(double[] a,
double[] b) |
static double[] |
dividedBy(double[] a,
double[] b,
double defaultValueForZero) |
static double[] |
dividedBy(double[] a,
double[] b,
double[] c) |
static double[] |
dividedBy(double[] a,
double[] b,
double[] c,
double defaultValueForZero) |
static double[] |
dividedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[] |
dividedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero) |
static double[] |
dividedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB) |
static double[] |
dividedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero) |
static void |
dividedBy(float[][][] a,
float param) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float defaultValueForZero) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float[][][] c) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float defaultValueForZero) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB) |
static float[][][] |
dividedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero) |
static void |
dividedBy(float[][] a,
float param) |
static float[][] |
dividedBy(float[][] a,
float[][] b) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float defaultValueForZero) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float[][] c) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float[][] c,
float defaultValueForZero) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB) |
static float[][] |
dividedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero) |
static void |
dividedBy(float[] a,
float param) |
static float[] |
dividedBy(float[] a,
float[] b) |
static float[] |
dividedBy(float[] a,
float[] b,
float defaultValueForZero) |
static float[] |
dividedBy(float[] a,
float[] b,
float[] c) |
static float[] |
dividedBy(float[] a,
float[] b,
float[] c,
float defaultValueForZero) |
static float[] |
dividedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[] |
dividedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero) |
static float[] |
dividedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB) |
static float[] |
dividedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero) |
static void |
dividedBy(int[][][] a,
int param) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int defaultValueForZero) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int[][][] c) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int defaultValueForZero) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB) |
static int[][][] |
dividedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero) |
static void |
dividedBy(int[][] a,
int param) |
static int[][] |
dividedBy(int[][] a,
int[][] b) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int defaultValueForZero) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int[][] c) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int[][] c,
int defaultValueForZero) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB) |
static int[][] |
dividedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero) |
static void |
dividedBy(int[] a,
int param) |
static int[] |
dividedBy(int[] a,
int[] b) |
static int[] |
dividedBy(int[] a,
int[] b,
int defaultValueForZero) |
static int[] |
dividedBy(int[] a,
int[] b,
int[] c) |
static int[] |
dividedBy(int[] a,
int[] b,
int[] c,
int defaultValueForZero) |
static int[] |
dividedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[] |
dividedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero) |
static int[] |
dividedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB) |
static int[] |
dividedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero) |
static void |
dividedBy(long[][][] a,
long param) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long defaultValueForZero) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long[][][] c) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long defaultValueForZero) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB) |
static long[][][] |
dividedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero) |
static void |
dividedBy(long[][] a,
long param) |
static long[][] |
dividedBy(long[][] a,
long[][] b) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long defaultValueForZero) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long[][] c) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long[][] c,
long defaultValueForZero) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB) |
static long[][] |
dividedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero) |
static void |
dividedBy(long[] a,
long param) |
static long[] |
dividedBy(long[] a,
long[] b) |
static long[] |
dividedBy(long[] a,
long[] b,
long defaultValueForZero) |
static long[] |
dividedBy(long[] a,
long[] b,
long[] c) |
static long[] |
dividedBy(long[] a,
long[] b,
long[] c,
long defaultValueForZero) |
static long[] |
dividedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[] |
dividedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero) |
static long[] |
dividedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB) |
static long[] |
dividedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero) |
static void |
dividedBy(short[][][] a,
short param) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short defaultValueForZero) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short[][][] c) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short defaultValueForZero) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB) |
static short[][][] |
dividedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero) |
static void |
dividedBy(short[][] a,
short param) |
static short[][] |
dividedBy(short[][] a,
short[][] b) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short defaultValueForZero) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short[][] c) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short[][] c,
short defaultValueForZero) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB) |
static short[][] |
dividedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero) |
static void |
dividedBy(short[] a,
short param) |
static short[] |
dividedBy(short[] a,
short[] b) |
static short[] |
dividedBy(short[] a,
short[] b,
short defaultValueForZero) |
static short[] |
dividedBy(short[] a,
short[] b,
short[] c) |
static short[] |
dividedBy(short[] a,
short[] b,
short[] c,
short defaultValueForZero) |
static short[] |
dividedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[] |
dividedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero) |
static short[] |
dividedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB) |
static short[] |
dividedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero) |
static boolean[] |
flatten(boolean[][] a) |
static boolean[] |
flatten(boolean[][][] a) |
static byte[] |
flatten(byte[][] a) |
static byte[] |
flatten(byte[][][] a) |
static char[] |
flatten(char[][] a) |
static char[] |
flatten(char[][][] a) |
static double[] |
flatten(double[][] a) |
static double[] |
flatten(double[][][] a) |
static float[] |
flatten(float[][] a) |
static float[] |
flatten(float[][][] a) |
static int[] |
flatten(int[][] a) |
static int[] |
flatten(int[][][] a) |
static long[] |
flatten(long[][] a) |
static long[] |
flatten(long[][][] a) |
static short[] |
flatten(short[][] a) |
static short[] |
flatten(short[][][] a) |
static <T> T[] |
flatten2(T[][] a) |
static <T> T[] |
flatten2(T[][][] a) |
static <T,R> R[][][] |
map(java.lang.Class<R> cls,
T[][][] a,
Function<? super T,R> func) |
static <T,R> R[][] |
map(java.lang.Class<R> cls,
T[][] a,
Function<? super T,R> func) |
static <T,R> R[] |
map(java.lang.Class<R> cls,
T[] a,
Function<? super T,R> func) |
static <T> T[][][] |
map2(T[][][] a,
Function<? super T,T> func) |
static <T> T[][] |
map2(T[][] a,
Function<? super T,T> func) |
static <T> T[] |
map2(T[] a,
Function<? super T,T> func) |
static <T> boolean[][][] |
mapToBoolean(T[][][] a,
ToBooleanFunction<? super T> func) |
static <T> boolean[][] |
mapToBoolean(T[][] a,
ToBooleanFunction<? super T> func) |
static <T> boolean[] |
mapToBoolean(T[] a,
ToBooleanFunction<? super T> func) |
static <T> byte[][][] |
mapToByte(T[][][] a,
ToByteFunction<? super T> func) |
static <T> byte[][] |
mapToByte(T[][] a,
ToByteFunction<? super T> func) |
static <T> byte[] |
mapToByte(T[] a,
ToByteFunction<? super T> func) |
static <T> char[][][] |
mapToChar(T[][][] a,
ToCharFunction<? super T> func) |
static <T> char[][] |
mapToChar(T[][] a,
ToCharFunction<? super T> func) |
static <T> char[] |
mapToChar(T[] a,
ToCharFunction<? super T> func) |
static <T> double[][][] |
mapToDouble(T[][][] a,
ToDoubleFunction<? super T> func) |
static <T> double[][] |
mapToDouble(T[][] a,
ToDoubleFunction<? super T> func) |
static <T> double[] |
mapToDouble(T[] a,
ToDoubleFunction<? super T> func) |
static <T> float[][][] |
mapToFloat(T[][][] a,
ToFloatFunction<? super T> func) |
static <T> float[][] |
mapToFloat(T[][] a,
ToFloatFunction<? super T> func) |
static <T> float[] |
mapToFloat(T[] a,
ToFloatFunction<? super T> func) |
static <T> int[][][] |
mapToInt(T[][][] a,
ToIntFunction<? super T> func) |
static <T> int[][] |
mapToInt(T[][] a,
ToIntFunction<? super T> func) |
static <T> int[] |
mapToInt(T[] a,
ToIntFunction<? super T> func) |
static <T> long[][][] |
mapToLong(T[][][] a,
ToLongFunction<? super T> func) |
static <T> long[][] |
mapToLong(T[][] a,
ToLongFunction<? super T> func) |
static <T> long[] |
mapToLong(T[] a,
ToLongFunction<? super T> func) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
boolean[][][] a,
BooleanFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
boolean[][] a,
BooleanFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
boolean[] a,
BooleanFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
byte[][][] a,
ByteFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
byte[][] a,
ByteFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
byte[] a,
ByteFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
char[][][] a,
CharFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
char[][] a,
CharFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
char[] a,
CharFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
double[][][] a,
DoubleFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
double[][] a,
DoubleFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
double[] a,
DoubleFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
float[][][] a,
FloatFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
float[][] a,
FloatFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
float[] a,
FloatFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
int[][][] a,
IntFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
int[][] a,
IntFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
int[] a,
IntFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
long[][][] a,
LongFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
long[][] a,
LongFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
long[] a,
LongFunction<? extends T> mapper) |
static <T> T[][][] |
mapToObj(java.lang.Class<T> cls,
short[][][] a,
ShortFunction<? extends T> mapper) |
static <T> T[][] |
mapToObj(java.lang.Class<T> cls,
short[][] a,
ShortFunction<? extends T> mapper) |
static <T> T[] |
mapToObj(java.lang.Class<T> cls,
short[] a,
ShortFunction<? extends T> mapper) |
static <T> short[][][] |
mapToShort(T[][][] a,
ToShortFunction<? super T> func) |
static <T> short[][] |
mapToShort(T[][] a,
ToShortFunction<? super T> func) |
static <T> short[] |
mapToShort(T[] a,
ToShortFunction<? super T> func) |
static BooleanMatrix |
matrix(boolean[][] a) |
static BooleanMatrix |
matrix(boolean[][] a,
int m) |
static BooleanMatrix |
matrix(boolean[][] a,
int n,
int m) |
static BooleanMatrix |
matrix(boolean[][] a,
int n,
int m,
boolean valueForDefault) |
static ByteMatrix |
matrix(byte[][] a) |
static ByteMatrix |
matrix(byte[][] a,
int m) |
static ByteMatrix |
matrix(byte[][] a,
int n,
int m) |
static ByteMatrix |
matrix(byte[][] a,
int n,
int m,
byte valueForDefault) |
static CharMatrix |
matrix(char[][] a) |
static CharMatrix |
matrix(char[][] a,
int m) |
static CharMatrix |
matrix(char[][] a,
int n,
int m) |
static CharMatrix |
matrix(char[][] a,
int n,
int m,
char valueForDefault) |
static DoubleMatrix |
matrix(double[][] a) |
static DoubleMatrix |
matrix(double[][] a,
int m) |
static DoubleMatrix |
matrix(double[][] a,
int n,
int m) |
static DoubleMatrix |
matrix(double[][] a,
int n,
int m,
double valueForDefault) |
static FloatMatrix |
matrix(float[][] a) |
static FloatMatrix |
matrix(float[][] a,
int m) |
static FloatMatrix |
matrix(float[][] a,
int n,
int m) |
static FloatMatrix |
matrix(float[][] a,
int n,
int m,
float valueForDefault) |
static IntMatrix |
matrix(int[][] a) |
static IntMatrix |
matrix(int[][] a,
int m) |
static IntMatrix |
matrix(int[][] a,
int n,
int m) |
static IntMatrix |
matrix(int[][] a,
int n,
int m,
int valueForDefault) |
static LongMatrix |
matrix(long[][] a) |
static LongMatrix |
matrix(long[][] a,
int m) |
static LongMatrix |
matrix(long[][] a,
int n,
int m) |
static LongMatrix |
matrix(long[][] a,
int n,
int m,
long valueForDefault) |
static ShortMatrix |
matrix(short[][] a) |
static ShortMatrix |
matrix(short[][] a,
int m) |
static ShortMatrix |
matrix(short[][] a,
int n,
int m) |
static ShortMatrix |
matrix(short[][] a,
int n,
int m,
short valueForDefault) |
static <T> Matrix<T> |
matrix(T[][] a) |
static <T> Matrix<T> |
matrix(T[][] a,
int m) |
static <T> Matrix<T> |
matrix(T[][] a,
int n,
int m) |
static <T> Matrix<T> |
matrix(T[][] a,
int n,
int m,
T valueForDefault) |
static void |
minus(byte[][][] a,
byte param) |
static void |
minus(byte[][] a,
byte param) |
static void |
minus(byte[] a,
byte param) |
static void |
minus(char[][][] a,
int param) |
static void |
minus(char[][] a,
int param) |
static void |
minus(char[] a,
int param) |
static void |
minus(double[][][] a,
double param) |
static void |
minus(double[][] a,
double param) |
static void |
minus(double[] a,
double param) |
static void |
minus(float[][][] a,
float param) |
static void |
minus(float[][] a,
float param) |
static void |
minus(float[] a,
float param) |
static void |
minus(int[][][] a,
int param) |
static void |
minus(int[][] a,
int param) |
static void |
minus(int[] a,
int param) |
static void |
minus(long[][][] a,
long param) |
static void |
minus(long[][] a,
long param) |
static void |
minus(long[] a,
long param) |
static void |
minus(short[][][] a,
short param) |
static void |
minus(short[][] a,
short param) |
static void |
minus(short[] a,
short param) |
static void |
multipliedBy(byte[][][] a,
byte param) |
static byte[][][] |
multipliedBy(byte[][][] a,
byte[][][] b) |
static byte[][][] |
multipliedBy(byte[][][] a,
byte[][][] b,
byte[][][] c) |
static byte[][][] |
multipliedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][][] |
multipliedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB) |
static void |
multipliedBy(byte[][] a,
byte param) |
static byte[][] |
multipliedBy(byte[][] a,
byte[][] b) |
static byte[][] |
multipliedBy(byte[][] a,
byte[][] b,
byte[][] c) |
static byte[][] |
multipliedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][] |
multipliedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB) |
static void |
multipliedBy(byte[] a,
byte param) |
static byte[] |
multipliedBy(byte[] a,
byte[] b) |
static byte[] |
multipliedBy(byte[] a,
byte[] b,
byte[] c) |
static byte[] |
multipliedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[] |
multipliedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB) |
static void |
multipliedBy(char[][][] a,
int param) |
static void |
multipliedBy(char[][] a,
int param) |
static void |
multipliedBy(char[] a,
int param) |
static void |
multipliedBy(double[][][] a,
double param) |
static double[][][] |
multipliedBy(double[][][] a,
double[][][] b) |
static double[][][] |
multipliedBy(double[][][] a,
double[][][] b,
double[][][] c) |
static double[][][] |
multipliedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][][] |
multipliedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB) |
static void |
multipliedBy(double[][] a,
double param) |
static double[][] |
multipliedBy(double[][] a,
double[][] b) |
static double[][] |
multipliedBy(double[][] a,
double[][] b,
double[][] c) |
static double[][] |
multipliedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][] |
multipliedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB) |
static void |
multipliedBy(double[] a,
double param) |
static double[] |
multipliedBy(double[] a,
double[] b) |
static double[] |
multipliedBy(double[] a,
double[] b,
double[] c) |
static double[] |
multipliedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[] |
multipliedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB) |
static void |
multipliedBy(float[][][] a,
float param) |
static float[][][] |
multipliedBy(float[][][] a,
float[][][] b) |
static float[][][] |
multipliedBy(float[][][] a,
float[][][] b,
float[][][] c) |
static float[][][] |
multipliedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][][] |
multipliedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB) |
static void |
multipliedBy(float[][] a,
float param) |
static float[][] |
multipliedBy(float[][] a,
float[][] b) |
static float[][] |
multipliedBy(float[][] a,
float[][] b,
float[][] c) |
static float[][] |
multipliedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][] |
multipliedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB) |
static void |
multipliedBy(float[] a,
float param) |
static float[] |
multipliedBy(float[] a,
float[] b) |
static float[] |
multipliedBy(float[] a,
float[] b,
float[] c) |
static float[] |
multipliedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[] |
multipliedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB) |
static void |
multipliedBy(int[][][] a,
int param) |
static int[][][] |
multipliedBy(int[][][] a,
int[][][] b) |
static int[][][] |
multipliedBy(int[][][] a,
int[][][] b,
int[][][] c) |
static int[][][] |
multipliedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][][] |
multipliedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB) |
static void |
multipliedBy(int[][] a,
int param) |
static int[][] |
multipliedBy(int[][] a,
int[][] b) |
static int[][] |
multipliedBy(int[][] a,
int[][] b,
int[][] c) |
static int[][] |
multipliedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][] |
multipliedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB) |
static void |
multipliedBy(int[] a,
int param) |
static int[] |
multipliedBy(int[] a,
int[] b) |
static int[] |
multipliedBy(int[] a,
int[] b,
int[] c) |
static int[] |
multipliedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[] |
multipliedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB) |
static void |
multipliedBy(long[][][] a,
long param) |
static long[][][] |
multipliedBy(long[][][] a,
long[][][] b) |
static long[][][] |
multipliedBy(long[][][] a,
long[][][] b,
long[][][] c) |
static long[][][] |
multipliedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][][] |
multipliedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB) |
static void |
multipliedBy(long[][] a,
long param) |
static long[][] |
multipliedBy(long[][] a,
long[][] b) |
static long[][] |
multipliedBy(long[][] a,
long[][] b,
long[][] c) |
static long[][] |
multipliedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][] |
multipliedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB) |
static void |
multipliedBy(long[] a,
long param) |
static long[] |
multipliedBy(long[] a,
long[] b) |
static long[] |
multipliedBy(long[] a,
long[] b,
long[] c) |
static long[] |
multipliedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[] |
multipliedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB) |
static void |
multipliedBy(short[][][] a,
short param) |
static short[][][] |
multipliedBy(short[][][] a,
short[][][] b) |
static short[][][] |
multipliedBy(short[][][] a,
short[][][] b,
short[][][] c) |
static short[][][] |
multipliedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][][] |
multipliedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB) |
static void |
multipliedBy(short[][] a,
short param) |
static short[][] |
multipliedBy(short[][] a,
short[][] b) |
static short[][] |
multipliedBy(short[][] a,
short[][] b,
short[][] c) |
static short[][] |
multipliedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][] |
multipliedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB) |
static void |
multipliedBy(short[] a,
short param) |
static short[] |
multipliedBy(short[] a,
short[] b) |
static short[] |
multipliedBy(short[] a,
short[] b,
short[] c) |
static short[] |
multipliedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[] |
multipliedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB) |
static void |
plus(byte[][][] a,
byte param) |
static void |
plus(byte[][] a,
byte param) |
static void |
plus(byte[] a,
byte param) |
static void |
plus(char[][][] a,
int param) |
static void |
plus(char[][] a,
int param) |
static void |
plus(char[] a,
int param) |
static void |
plus(double[][][] a,
double param) |
static void |
plus(double[][] a,
double param) |
static void |
plus(double[] a,
double param) |
static void |
plus(float[][][] a,
float param) |
static void |
plus(float[][] a,
float param) |
static void |
plus(float[] a,
float param) |
static void |
plus(int[][][] a,
int param) |
static void |
plus(int[][] a,
int param) |
static void |
plus(int[] a,
int param) |
static void |
plus(long[][][] a,
long param) |
static void |
plus(long[][] a,
long param) |
static void |
plus(long[] a,
long param) |
static void |
plus(short[][][] a,
short param) |
static void |
plus(short[][] a,
short param) |
static void |
plus(short[] a,
short param) |
static void |
println(boolean[] a) |
static void |
println(boolean[][] a) |
static void |
println(boolean[][][] a) |
static void |
println(byte[] a) |
static void |
println(byte[][] a) |
static void |
println(byte[][][] a) |
static void |
println(char[] a) |
static void |
println(char[][] a) |
static void |
println(char[][][] a) |
static void |
println(double[] a) |
static void |
println(double[][] a) |
static void |
println(double[][][] a) |
static void |
println(float[] a) |
static void |
println(float[][] a) |
static void |
println(float[][][] a) |
static void |
println(int[] a) |
static void |
println(int[][] a) |
static void |
println(int[][][] a) |
static void |
println(long[] a) |
static void |
println(long[][] a) |
static void |
println(long[][][] a) |
static void |
println(short[] a) |
static void |
println(short[][] a) |
static void |
println(short[][][] a) |
static <T> void |
println(T[] a) |
static <T> void |
println(T[][] a) |
static <T> void |
println(T[][][] a) |
static void |
replaceAll(boolean[][][] a,
BooleanUnaryOperator operator) |
static void |
replaceAll(boolean[][] a,
BooleanUnaryOperator operator) |
static void |
replaceAll(boolean[] a,
BooleanUnaryOperator operator) |
static void |
replaceAll(byte[][][] a,
ByteUnaryOperator operator) |
static void |
replaceAll(byte[][] a,
ByteUnaryOperator operator) |
static void |
replaceAll(byte[] a,
ByteUnaryOperator operator) |
static void |
replaceAll(char[][][] a,
CharUnaryOperator operator) |
static void |
replaceAll(char[][] a,
CharUnaryOperator operator) |
static void |
replaceAll(char[] a,
CharUnaryOperator operator) |
static void |
replaceAll(double[][][] a,
DoubleUnaryOperator operator) |
static void |
replaceAll(double[][] a,
DoubleUnaryOperator operator) |
static void |
replaceAll(double[] a,
DoubleUnaryOperator operator) |
static void |
replaceAll(float[][][] a,
FloatUnaryOperator operator) |
static void |
replaceAll(float[][] a,
FloatUnaryOperator operator) |
static void |
replaceAll(float[] a,
FloatUnaryOperator operator) |
static void |
replaceAll(int[][][] a,
IntUnaryOperator operator) |
static void |
replaceAll(int[][] a,
IntUnaryOperator operator) |
static void |
replaceAll(int[] a,
IntUnaryOperator operator) |
static void |
replaceAll(long[][][] a,
LongUnaryOperator operator) |
static void |
replaceAll(long[][] a,
LongUnaryOperator operator) |
static void |
replaceAll(long[] a,
LongUnaryOperator operator) |
static void |
replaceAll(short[][][] a,
ShortUnaryOperator operator) |
static void |
replaceAll(short[][] a,
ShortUnaryOperator operator) |
static void |
replaceAll(short[] a,
ShortUnaryOperator operator) |
static <T> void |
replaceAll2(T[][][] a,
UnaryOperator<T> operator) |
static <T> void |
replaceAll2(T[][] a,
UnaryOperator<T> operator) |
static <T> void |
replaceAll2(T[] a,
UnaryOperator<T> operator) |
static void |
replaceIf(boolean[][][] a,
BooleanPredicate predicate,
boolean newValue) |
static void |
replaceIf(boolean[][] a,
BooleanPredicate predicate,
boolean newValue) |
static void |
replaceIf(boolean[] a,
BooleanPredicate predicate,
boolean newValue) |
static void |
replaceIf(byte[][][] a,
BytePredicate predicate,
byte newValue) |
static void |
replaceIf(byte[][] a,
BytePredicate predicate,
byte newValue) |
static void |
replaceIf(byte[] a,
BytePredicate predicate,
byte newValue) |
static void |
replaceIf(char[][][] a,
CharPredicate predicate,
char newValue) |
static void |
replaceIf(char[][] a,
CharPredicate predicate,
char newValue) |
static void |
replaceIf(char[] a,
CharPredicate predicate,
char newValue) |
static void |
replaceIf(double[][][] a,
DoublePredicate predicate,
double newValue) |
static void |
replaceIf(double[][] a,
DoublePredicate predicate,
double newValue) |
static void |
replaceIf(double[] a,
DoublePredicate predicate,
double newValue) |
static void |
replaceIf(float[][][] a,
FloatPredicate predicate,
float newValue) |
static void |
replaceIf(float[][] a,
FloatPredicate predicate,
float newValue) |
static void |
replaceIf(float[] a,
FloatPredicate predicate,
float newValue) |
static void |
replaceIf(int[][][] a,
IntPredicate predicate,
int newValue) |
static void |
replaceIf(int[][] a,
IntPredicate predicate,
int newValue) |
static void |
replaceIf(int[] a,
IntPredicate predicate,
int newValue) |
static void |
replaceIf(long[][][] a,
LongPredicate predicate,
long newValue) |
static void |
replaceIf(long[][] a,
LongPredicate predicate,
long newValue) |
static void |
replaceIf(long[] a,
LongPredicate predicate,
long newValue) |
static void |
replaceIf(short[][][] a,
ShortPredicate predicate,
short newValue) |
static void |
replaceIf(short[][] a,
ShortPredicate predicate,
short newValue) |
static void |
replaceIf(short[] a,
ShortPredicate predicate,
short newValue) |
static <T> void |
replaceIf2(T[][][] a,
Predicate<? super T> predicate,
T newValue) |
static <T> void |
replaceIf2(T[][] a,
Predicate<? super T> predicate,
T newValue) |
static <T> void |
replaceIf2(T[] a,
Predicate<? super T> predicate,
T newValue) |
static boolean[][] |
reshape(boolean[] a,
int m) |
static boolean[][][] |
reshape(boolean[] a,
int m,
int l) |
static byte[][] |
reshape(byte[] a,
int m) |
static byte[][][] |
reshape(byte[] a,
int m,
int l) |
static char[][] |
reshape(char[] a,
int m) |
static char[][][] |
reshape(char[] a,
int m,
int l) |
static double[][] |
reshape(double[] a,
int m) |
static double[][][] |
reshape(double[] a,
int m,
int l) |
static float[][] |
reshape(float[] a,
int m) |
static float[][][] |
reshape(float[] a,
int m,
int l) |
static int[][] |
reshape(int[] a,
int m) |
static int[][][] |
reshape(int[] a,
int m,
int l) |
static long[][] |
reshape(long[] a,
int m) |
static long[][][] |
reshape(long[] a,
int m,
int l) |
static short[][] |
reshape(short[] a,
int m) |
static short[][][] |
reshape(short[] a,
int m,
int l) |
static <T> T[][] |
reshape2(T[] a,
int m) |
static <T> T[][][] |
reshape2(T[] a,
int m,
int l) |
static byte[][][] |
subtract(byte[][][] a,
byte[][][] b) |
static byte[][][] |
subtract(byte[][][] a,
byte[][][] b,
byte[][][] c) |
static byte[][][] |
subtract(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][][] |
subtract(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[][] |
subtract(byte[][] a,
byte[][] b) |
static byte[][] |
subtract(byte[][] a,
byte[][] b,
byte[][] c) |
static byte[][] |
subtract(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[][] |
subtract(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB) |
static byte[] |
subtract(byte[] a,
byte[] b) |
static byte[] |
subtract(byte[] a,
byte[] b,
byte[] c) |
static byte[] |
subtract(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC) |
static byte[] |
subtract(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB) |
static double[][][] |
subtract(double[][][] a,
double[][][] b) |
static double[][][] |
subtract(double[][][] a,
double[][][] b,
double[][][] c) |
static double[][][] |
subtract(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][][] |
subtract(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB) |
static double[][] |
subtract(double[][] a,
double[][] b) |
static double[][] |
subtract(double[][] a,
double[][] b,
double[][] c) |
static double[][] |
subtract(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[][] |
subtract(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB) |
static double[] |
subtract(double[] a,
double[] b) |
static double[] |
subtract(double[] a,
double[] b,
double[] c) |
static double[] |
subtract(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC) |
static double[] |
subtract(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB) |
static float[][][] |
subtract(float[][][] a,
float[][][] b) |
static float[][][] |
subtract(float[][][] a,
float[][][] b,
float[][][] c) |
static float[][][] |
subtract(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][][] |
subtract(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB) |
static float[][] |
subtract(float[][] a,
float[][] b) |
static float[][] |
subtract(float[][] a,
float[][] b,
float[][] c) |
static float[][] |
subtract(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[][] |
subtract(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB) |
static float[] |
subtract(float[] a,
float[] b) |
static float[] |
subtract(float[] a,
float[] b,
float[] c) |
static float[] |
subtract(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC) |
static float[] |
subtract(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB) |
static int[][][] |
subtract(int[][][] a,
int[][][] b) |
static int[][][] |
subtract(int[][][] a,
int[][][] b,
int[][][] c) |
static int[][][] |
subtract(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][][] |
subtract(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB) |
static int[][] |
subtract(int[][] a,
int[][] b) |
static int[][] |
subtract(int[][] a,
int[][] b,
int[][] c) |
static int[][] |
subtract(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[][] |
subtract(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB) |
static int[] |
subtract(int[] a,
int[] b) |
static int[] |
subtract(int[] a,
int[] b,
int[] c) |
static int[] |
subtract(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC) |
static int[] |
subtract(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB) |
static long[][][] |
subtract(long[][][] a,
long[][][] b) |
static long[][][] |
subtract(long[][][] a,
long[][][] b,
long[][][] c) |
static long[][][] |
subtract(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][][] |
subtract(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB) |
static long[][] |
subtract(long[][] a,
long[][] b) |
static long[][] |
subtract(long[][] a,
long[][] b,
long[][] c) |
static long[][] |
subtract(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[][] |
subtract(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB) |
static long[] |
subtract(long[] a,
long[] b) |
static long[] |
subtract(long[] a,
long[] b,
long[] c) |
static long[] |
subtract(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC) |
static long[] |
subtract(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB) |
static short[][][] |
subtract(short[][][] a,
short[][][] b) |
static short[][][] |
subtract(short[][][] a,
short[][][] b,
short[][][] c) |
static short[][][] |
subtract(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][][] |
subtract(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB) |
static short[][] |
subtract(short[][] a,
short[][] b) |
static short[][] |
subtract(short[][] a,
short[][] b,
short[][] c) |
static short[][] |
subtract(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[][] |
subtract(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB) |
static short[] |
subtract(short[] a,
short[] b) |
static short[] |
subtract(short[] a,
short[] b,
short[] c) |
static short[] |
subtract(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC) |
static short[] |
subtract(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB) |
static boolean[] |
toBoolean(byte[] a) |
static boolean[][] |
toBoolean(byte[][] a) |
static boolean[][][] |
toBoolean(byte[][][] a) |
static boolean[] |
toBoolean(int[] a) |
static boolean[][] |
toBoolean(int[][] a) |
static boolean[][][] |
toBoolean(int[][][] a) |
static byte[] |
toByte(boolean[] a) |
static byte[][] |
toByte(boolean[][] a) |
static byte[][][] |
toByte(boolean[][][] a) |
static double[] |
toDouble(byte[] a) |
static double[][] |
toDouble(byte[][] a) |
static double[][][] |
toDouble(byte[][][] a) |
static double[] |
toDouble(char[] a) |
static double[][] |
toDouble(char[][] a) |
static double[][][] |
toDouble(char[][][] a) |
static double[] |
toDouble(float[] a) |
static double[][] |
toDouble(float[][] a) |
static double[][][] |
toDouble(float[][][] a) |
static double[] |
toDouble(int[] a) |
static double[][] |
toDouble(int[][] a) |
static double[][][] |
toDouble(int[][][] a) |
static double[] |
toDouble(long[] a) |
static double[][] |
toDouble(long[][] a) |
static double[][][] |
toDouble(long[][][] a) |
static double[] |
toDouble(short[] a) |
static double[][] |
toDouble(short[][] a) |
static double[][][] |
toDouble(short[][][] a) |
static float[] |
toFloat(byte[] a) |
static float[][] |
toFloat(byte[][] a) |
static float[][][] |
toFloat(byte[][][] a) |
static float[] |
toFloat(char[] a) |
static float[][] |
toFloat(char[][] a) |
static float[][][] |
toFloat(char[][][] a) |
static float[] |
toFloat(int[] a) |
static float[][] |
toFloat(int[][] a) |
static float[][][] |
toFloat(int[][][] a) |
static float[] |
toFloat(long[] a) |
static float[][] |
toFloat(long[][] a) |
static float[][][] |
toFloat(long[][][] a) |
static float[] |
toFloat(short[] a) |
static float[][] |
toFloat(short[][] a) |
static float[][][] |
toFloat(short[][][] a) |
static int[] |
toInt(boolean[] a) |
static int[][] |
toInt(boolean[][] a) |
static int[][][] |
toInt(boolean[][][] a) |
static int[] |
toInt(byte[] a) |
static int[][] |
toInt(byte[][] a) |
static int[][][] |
toInt(byte[][][] a) |
static int[] |
toInt(char[] a) |
static int[][] |
toInt(char[][] a) |
static int[][][] |
toInt(char[][][] a) |
static int[] |
toInt(short[] a) |
static int[][] |
toInt(short[][] a) |
static int[][][] |
toInt(short[][][] a) |
static long[] |
toLong(boolean[] a) |
static long[][] |
toLong(boolean[][] a) |
static long[][][] |
toLong(boolean[][][] a) |
static long[] |
toLong(byte[] a) |
static long[][] |
toLong(byte[][] a) |
static long[][][] |
toLong(byte[][][] a) |
static long[] |
toLong(char[] a) |
static long[][] |
toLong(char[][] a) |
static long[][][] |
toLong(char[][][] a) |
static long[] |
toLong(int[] a) |
static long[][] |
toLong(int[][] a) |
static long[][][] |
toLong(int[][][] a) |
static long[] |
toLong(short[] a) |
static long[][] |
toLong(short[][] a) |
static long[][][] |
toLong(short[][][] a) |
static boolean[] |
unbox(java.lang.Boolean[] a) |
static boolean[][] |
unbox(java.lang.Boolean[][] a) |
static boolean[][][] |
unbox(java.lang.Boolean[][][] a) |
static boolean[][][] |
unbox(java.lang.Boolean[][][] a,
boolean valueForNul) |
static boolean[][] |
unbox(java.lang.Boolean[][] a,
boolean valueForNul) |
static boolean[] |
unbox(java.lang.Boolean[] a,
boolean valueForNul) |
static byte[] |
unbox(java.lang.Byte[] a) |
static byte[][] |
unbox(java.lang.Byte[][] a) |
static byte[][][] |
unbox(java.lang.Byte[][][] a) |
static byte[][][] |
unbox(java.lang.Byte[][][] a,
byte valueForNul) |
static byte[][] |
unbox(java.lang.Byte[][] a,
byte valueForNul) |
static byte[] |
unbox(java.lang.Byte[] a,
byte valueForNul) |
static char[] |
unbox(java.lang.Character[] a) |
static char[][] |
unbox(java.lang.Character[][] a) |
static char[][][] |
unbox(java.lang.Character[][][] a) |
static char[][][] |
unbox(java.lang.Character[][][] a,
char valueForNul) |
static char[][] |
unbox(java.lang.Character[][] a,
char valueForNul) |
static char[] |
unbox(java.lang.Character[] a,
char valueForNul) |
static double[] |
unbox(java.lang.Double[] a) |
static double[][] |
unbox(java.lang.Double[][] a) |
static double[][][] |
unbox(java.lang.Double[][][] a) |
static double[][][] |
unbox(java.lang.Double[][][] a,
double valueForNul) |
static double[][] |
unbox(java.lang.Double[][] a,
double valueForNul) |
static double[] |
unbox(java.lang.Double[] a,
double valueForNul) |
static float[] |
unbox(java.lang.Float[] a) |
static float[][] |
unbox(java.lang.Float[][] a) |
static float[][][] |
unbox(java.lang.Float[][][] a) |
static float[][][] |
unbox(java.lang.Float[][][] a,
float valueForNul) |
static float[][] |
unbox(java.lang.Float[][] a,
float valueForNul) |
static float[] |
unbox(java.lang.Float[] a,
float valueForNul) |
static int[] |
unbox(java.lang.Integer[] a) |
static int[][] |
unbox(java.lang.Integer[][] a) |
static int[][][] |
unbox(java.lang.Integer[][][] a) |
static int[][][] |
unbox(java.lang.Integer[][][] a,
int valueForNul) |
static int[][] |
unbox(java.lang.Integer[][] a,
int valueForNul) |
static int[] |
unbox(java.lang.Integer[] a,
int valueForNul) |
static long[] |
unbox(java.lang.Long[] a) |
static long[][] |
unbox(java.lang.Long[][] a) |
static long[][][] |
unbox(java.lang.Long[][][] a) |
static long[][][] |
unbox(java.lang.Long[][][] a,
long valueForNul) |
static long[][] |
unbox(java.lang.Long[][] a,
long valueForNul) |
static long[] |
unbox(java.lang.Long[] a,
long valueForNul) |
static short[] |
unbox(java.lang.Short[] a) |
static short[][] |
unbox(java.lang.Short[][] a) |
static short[][][] |
unbox(java.lang.Short[][][] a) |
static short[][][] |
unbox(java.lang.Short[][][] a,
short valueForNul) |
static short[][] |
unbox(java.lang.Short[][] a,
short valueForNul) |
static short[] |
unbox(java.lang.Short[] a,
short valueForNul) |
static boolean[][][] |
zip(boolean[][][] a,
boolean[][][] b,
boolean[][][] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[][][] |
zip(boolean[][][] a,
boolean[][][] b,
boolean[][][] c,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[][][] |
zip(boolean[][][] a,
boolean[][][] b,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static boolean[][][] |
zip(boolean[][][] a,
boolean[][][] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static boolean[][] |
zip(boolean[][] a,
boolean[][] b,
boolean[][] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[][] |
zip(boolean[][] a,
boolean[][] b,
boolean[][] c,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[][] |
zip(boolean[][] a,
boolean[][] b,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static boolean[][] |
zip(boolean[][] a,
boolean[][] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static boolean[] |
zip(boolean[] a,
boolean[] b,
boolean[] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[] |
zip(boolean[] a,
boolean[] b,
boolean[] c,
BooleanTriFunction<java.lang.Boolean> zipFunction) |
static boolean[] |
zip(boolean[] a,
boolean[] b,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static boolean[] |
zip(boolean[] a,
boolean[] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction) |
static byte[][][] |
zip(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[][][] |
zip(byte[][][] a,
byte[][][] b,
byte[][][] c,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[][][] |
zip(byte[][][] a,
byte[][][] b,
ByteBiFunction<java.lang.Byte> zipFunction) |
static byte[][][] |
zip(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction) |
static byte[][] |
zip(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[][] |
zip(byte[][] a,
byte[][] b,
byte[][] c,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[][] |
zip(byte[][] a,
byte[][] b,
ByteBiFunction<java.lang.Byte> zipFunction) |
static byte[][] |
zip(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction) |
static byte[] |
zip(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[] |
zip(byte[] a,
byte[] b,
byte[] c,
ByteTriFunction<java.lang.Byte> zipFunction) |
static byte[] |
zip(byte[] a,
byte[] b,
ByteBiFunction<java.lang.Byte> zipFunction) |
static byte[] |
zip(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction) |
static char[][][] |
zip(char[][][] a,
char[][][] b,
char[][][] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction) |
static char[][][] |
zip(char[][][] a,
char[][][] b,
char[][][] c,
CharTriFunction<java.lang.Character> zipFunction) |
static char[][][] |
zip(char[][][] a,
char[][][] b,
CharBiFunction<java.lang.Character> zipFunction) |
static char[][][] |
zip(char[][][] a,
char[][][] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction) |
static char[][] |
zip(char[][] a,
char[][] b,
char[][] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction) |
static char[][] |
zip(char[][] a,
char[][] b,
char[][] c,
CharTriFunction<java.lang.Character> zipFunction) |
static char[][] |
zip(char[][] a,
char[][] b,
CharBiFunction<java.lang.Character> zipFunction) |
static char[][] |
zip(char[][] a,
char[][] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction) |
static char[] |
zip(char[] a,
char[] b,
char[] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction) |
static char[] |
zip(char[] a,
char[] b,
char[] c,
CharTriFunction<java.lang.Character> zipFunction) |
static char[] |
zip(char[] a,
char[] b,
CharBiFunction<java.lang.Character> zipFunction) |
static char[] |
zip(char[] a,
char[] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction) |
static <A,B,R> R[][][] |
zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][][] |
zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,C,R> R[][][] |
zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
C[][][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static <A,B,C,R> R[][][] |
zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
C[][][] c,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static <A,B,R> R[][] |
zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[][] |
zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,C,R> R[][] |
zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
C[][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static <A,B,C,R> R[][] |
zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
C[][] c,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static <A,B,R> R[] |
zip(java.lang.Class<R> cls,
A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,R> R[] |
zip(java.lang.Class<R> cls,
A[] a,
B[] b,
BiFunction<? super A,? super B,R> zipFunction) |
static <A,B,C,R> R[] |
zip(java.lang.Class<R> cls,
A[] a,
B[] b,
C[] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static <A,B,C,R> R[] |
zip(java.lang.Class<R> cls,
A[] a,
B[] b,
C[] c,
TriFunction<? super A,? super B,? super C,R> zipFunction) |
static double[][][] |
zip(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[][][] |
zip(double[][][] a,
double[][][] b,
double[][][] c,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[][][] |
zip(double[][][] a,
double[][][] b,
DoubleBiFunction<java.lang.Double> zipFunction) |
static double[][][] |
zip(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction) |
static double[][] |
zip(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[][] |
zip(double[][] a,
double[][] b,
double[][] c,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[][] |
zip(double[][] a,
double[][] b,
DoubleBiFunction<java.lang.Double> zipFunction) |
static double[][] |
zip(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction) |
static double[] |
zip(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[] |
zip(double[] a,
double[] b,
double[] c,
DoubleTriFunction<java.lang.Double> zipFunction) |
static double[] |
zip(double[] a,
double[] b,
DoubleBiFunction<java.lang.Double> zipFunction) |
static double[] |
zip(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction) |
static float[][][] |
zip(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[][][] |
zip(float[][][] a,
float[][][] b,
float[][][] c,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[][][] |
zip(float[][][] a,
float[][][] b,
FloatBiFunction<java.lang.Float> zipFunction) |
static float[][][] |
zip(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction) |
static float[][] |
zip(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[][] |
zip(float[][] a,
float[][] b,
float[][] c,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[][] |
zip(float[][] a,
float[][] b,
FloatBiFunction<java.lang.Float> zipFunction) |
static float[][] |
zip(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction) |
static float[] |
zip(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[] |
zip(float[] a,
float[] b,
float[] c,
FloatTriFunction<java.lang.Float> zipFunction) |
static float[] |
zip(float[] a,
float[] b,
FloatBiFunction<java.lang.Float> zipFunction) |
static float[] |
zip(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction) |
static int[][][] |
zip(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[][][] |
zip(int[][][] a,
int[][][] b,
int[][][] c,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[][][] |
zip(int[][][] a,
int[][][] b,
IntBiFunction<java.lang.Integer> zipFunction) |
static int[][][] |
zip(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction) |
static int[][] |
zip(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[][] |
zip(int[][] a,
int[][] b,
int[][] c,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[][] |
zip(int[][] a,
int[][] b,
IntBiFunction<java.lang.Integer> zipFunction) |
static int[][] |
zip(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction) |
static int[] |
zip(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[] |
zip(int[] a,
int[] b,
int[] c,
IntTriFunction<java.lang.Integer> zipFunction) |
static int[] |
zip(int[] a,
int[] b,
IntBiFunction<java.lang.Integer> zipFunction) |
static int[] |
zip(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction) |
static long[][][] |
zip(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction) |
static long[][][] |
zip(long[][][] a,
long[][][] b,
long[][][] c,
LongTriFunction<java.lang.Long> zipFunction) |
static long[][][] |
zip(long[][][] a,
long[][][] b,
LongBiFunction<java.lang.Long> zipFunction) |
static long[][][] |
zip(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction) |
static long[][] |
zip(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction) |
static long[][] |
zip(long[][] a,
long[][] b,
long[][] c,
LongTriFunction<java.lang.Long> zipFunction) |
static long[][] |
zip(long[][] a,
long[][] b,
LongBiFunction<java.lang.Long> zipFunction) |
static long[][] |
zip(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction) |
static long[] |
zip(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction) |
static long[] |
zip(long[] a,
long[] b,
long[] c,
LongTriFunction<java.lang.Long> zipFunction) |
static long[] |
zip(long[] a,
long[] b,
LongBiFunction<java.lang.Long> zipFunction) |
static long[] |
zip(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction) |
static short[][][] |
zip(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[][][] |
zip(short[][][] a,
short[][][] b,
short[][][] c,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[][][] |
zip(short[][][] a,
short[][][] b,
ShortBiFunction<java.lang.Short> zipFunction) |
static short[][][] |
zip(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction) |
static short[][] |
zip(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[][] |
zip(short[][] a,
short[][] b,
short[][] c,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[][] |
zip(short[][] a,
short[][] b,
ShortBiFunction<java.lang.Short> zipFunction) |
static short[][] |
zip(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction) |
static short[] |
zip(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[] |
zip(short[] a,
short[] b,
short[] c,
ShortTriFunction<java.lang.Short> zipFunction) |
static short[] |
zip(short[] a,
short[] b,
ShortBiFunction<java.lang.Short> zipFunction) |
static short[] |
zip(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction) |
static <A,B> A[][][] |
zip2(A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[][][] |
zip2(A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B,C> A[][][] |
zip2(A[][][] a,
B[][][] b,
C[][][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
static <A,B,C> A[][][] |
zip2(A[][][] a,
B[][][] b,
C[][][] c,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
static <A,B> A[][] |
zip2(A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[][] |
zip2(A[][] a,
B[][] b,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B,C> A[][] |
zip2(A[][] a,
B[][] b,
C[][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
static <A,B,C> A[][] |
zip2(A[][] a,
B[][] b,
C[][] c,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
static <A,B> A[] |
zip2(A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B> A[] |
zip2(A[] a,
B[] b,
BiFunction<? super A,? super B,A> zipFunction) |
static <A,B,C> A[] |
zip2(A[] a,
B[] b,
C[] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
static <A,B,C> A[] |
zip2(A[] a,
B[] b,
C[] c,
TriFunction<? super A,? super B,? super C,A> zipFunction) |
public static <T> void replaceAll2(T[] a,
UnaryOperator<T> operator)
public static <T> void replaceAll2(T[][] a,
UnaryOperator<T> operator)
public static <T> void replaceAll2(T[][][] a,
UnaryOperator<T> operator)
public static <T> void replaceIf2(T[] a,
Predicate<? super T> predicate,
T newValue)
public static <T> void replaceIf2(T[][] a,
Predicate<? super T> predicate,
T newValue)
public static <T> void replaceIf2(T[][][] a,
Predicate<? super T> predicate,
T newValue)
public static <T> T[] flatten2(T[][] a)
public static <T> T[] flatten2(T[][][] a)
public static <T> T[][] reshape2(T[] a,
int m)
public static <T> T[][][] reshape2(T[] a,
int m,
int l)
public static <T> T[] map2(T[] a,
Function<? super T,T> func)
public static <T,R> R[] map(java.lang.Class<R> cls,
T[] a,
Function<? super T,R> func)
public static <T> T[][] map2(T[][] a,
Function<? super T,T> func)
public static <T,R> R[][] map(java.lang.Class<R> cls,
T[][] a,
Function<? super T,R> func)
public static <T> T[][][] map2(T[][][] a,
Function<? super T,T> func)
public static <T,R> R[][][] map(java.lang.Class<R> cls,
T[][][] a,
Function<? super T,R> func)
public static <T> boolean[] mapToBoolean(T[] a,
ToBooleanFunction<? super T> func)
public static <T> boolean[][] mapToBoolean(T[][] a,
ToBooleanFunction<? super T> func)
public static <T> boolean[][][] mapToBoolean(T[][][] a,
ToBooleanFunction<? super T> func)
public static <T> char[] mapToChar(T[] a,
ToCharFunction<? super T> func)
public static <T> char[][] mapToChar(T[][] a,
ToCharFunction<? super T> func)
public static <T> char[][][] mapToChar(T[][][] a,
ToCharFunction<? super T> func)
public static <T> byte[] mapToByte(T[] a,
ToByteFunction<? super T> func)
public static <T> byte[][] mapToByte(T[][] a,
ToByteFunction<? super T> func)
public static <T> byte[][][] mapToByte(T[][][] a,
ToByteFunction<? super T> func)
public static <T> short[] mapToShort(T[] a,
ToShortFunction<? super T> func)
public static <T> short[][] mapToShort(T[][] a,
ToShortFunction<? super T> func)
public static <T> short[][][] mapToShort(T[][][] a,
ToShortFunction<? super T> func)
public static <T> int[] mapToInt(T[] a,
ToIntFunction<? super T> func)
public static <T> int[][] mapToInt(T[][] a,
ToIntFunction<? super T> func)
public static <T> int[][][] mapToInt(T[][][] a,
ToIntFunction<? super T> func)
public static <T> long[] mapToLong(T[] a,
ToLongFunction<? super T> func)
public static <T> long[][] mapToLong(T[][] a,
ToLongFunction<? super T> func)
public static <T> long[][][] mapToLong(T[][][] a,
ToLongFunction<? super T> func)
public static <T> float[] mapToFloat(T[] a,
ToFloatFunction<? super T> func)
public static <T> float[][] mapToFloat(T[][] a,
ToFloatFunction<? super T> func)
public static <T> float[][][] mapToFloat(T[][][] a,
ToFloatFunction<? super T> func)
public static <T> double[] mapToDouble(T[] a,
ToDoubleFunction<? super T> func)
public static <T> double[][] mapToDouble(T[][] a,
ToDoubleFunction<? super T> func)
public static <T> double[][][] mapToDouble(T[][][] a,
ToDoubleFunction<? super T> func)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
boolean[] a,
BooleanFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
boolean[][] a,
BooleanFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
boolean[][][] a,
BooleanFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
char[] a,
CharFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
char[][] a,
CharFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
char[][][] a,
CharFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
byte[] a,
ByteFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
byte[][] a,
ByteFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
byte[][][] a,
ByteFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
short[] a,
ShortFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
short[][] a,
ShortFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
short[][][] a,
ShortFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
int[] a,
IntFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
int[][] a,
IntFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
int[][][] a,
IntFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
long[] a,
LongFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
long[][] a,
LongFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
long[][][] a,
LongFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
float[] a,
FloatFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
float[][] a,
FloatFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
float[][][] a,
FloatFunction<? extends T> mapper)
public static <T> T[] mapToObj(java.lang.Class<T> cls,
double[] a,
DoubleFunction<? extends T> mapper)
public static <T> T[][] mapToObj(java.lang.Class<T> cls,
double[][] a,
DoubleFunction<? extends T> mapper)
public static <T> T[][][] mapToObj(java.lang.Class<T> cls,
double[][][] a,
DoubleFunction<? extends T> mapper)
public static <A,B> A[] zip2(A[] a,
B[] b,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[] zip(java.lang.Class<R> cls,
A[] a,
B[] b,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B> A[] zip2(A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[] zip(java.lang.Class<R> cls,
A[] a,
B[] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B,C> A[] zip2(A[] a,
B[] b,
C[] c,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[] zip(java.lang.Class<R> cls,
A[] a,
B[] b,
C[] c,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <A,B,C> A[] zip2(A[] a,
B[] b,
C[] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[] zip(java.lang.Class<R> cls,
A[] a,
B[] b,
C[] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <A,B> A[][] zip2(A[][] a,
B[][] b,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[][] zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B> A[][] zip2(A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[][] zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B,C> A[][] zip2(A[][] a,
B[][] b,
C[][] c,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[][] zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
C[][] c,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <A,B,C> A[][] zip2(A[][] a,
B[][] b,
C[][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[][] zip(java.lang.Class<R> cls,
A[][] a,
B[][] b,
C[][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <A,B> A[][][] zip2(A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[][][] zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B> A[][][] zip2(A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,A> zipFunction)
public static <A,B,R> R[][][] zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
A valueForNoneA,
B valueForNoneB,
BiFunction<? super A,? super B,R> zipFunction)
public static <A,B,C> A[][][] zip2(A[][][] a,
B[][][] b,
C[][][] c,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[][][] zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
C[][][] c,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <A,B,C> A[][][] zip2(A[][][] a,
B[][][] b,
C[][][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,A> zipFunction)
public static <A,B,C,R> R[][][] zip(java.lang.Class<R> cls,
A[][][] a,
B[][][] b,
C[][][] c,
A valueForNoneA,
B valueForNoneB,
C valueForNoneC,
TriFunction<? super A,? super B,? super C,R> zipFunction)
public static <T> Matrix<T> matrix(T[][] a)
public static <T> Matrix<T> matrix(T[][] a, int m)
public static <T> Matrix<T> matrix(T[][] a, int n, int m)
public static <T> Matrix<T> matrix(T[][] a, int n, int m, T valueForDefault)
public static <T> T[] copy(java.lang.Class<T[]> newType,
java.lang.Object[] a)
public static <T> T[][] copy(java.lang.Class<T[][]> newType,
java.lang.Object[][] a)
public static <T> T[][][] copy(java.lang.Class<T[][][]> newType,
java.lang.Object[][][] a)
public static <T> void println(T[] a)
public static <T> void println(T[][] a)
public static <T> void println(T[][][] a)
public static void replaceAll(boolean[] a,
BooleanUnaryOperator operator)
public static void replaceAll(boolean[][] a,
BooleanUnaryOperator operator)
public static void replaceAll(boolean[][][] a,
BooleanUnaryOperator operator)
public static void replaceIf(boolean[] a,
BooleanPredicate predicate,
boolean newValue)
public static void replaceIf(boolean[][] a,
BooleanPredicate predicate,
boolean newValue)
public static void replaceIf(boolean[][][] a,
BooleanPredicate predicate,
boolean newValue)
public static boolean[] flatten(boolean[][] a)
public static boolean[] flatten(boolean[][][] a)
public static boolean[][] reshape(boolean[] a,
int m)
public static boolean[][][] reshape(boolean[] a,
int m,
int l)
public static boolean[] zip(boolean[] a,
boolean[] b,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[] zip(boolean[] a,
boolean[] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[] zip(boolean[] a,
boolean[] b,
boolean[] c,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static boolean[] zip(boolean[] a,
boolean[] b,
boolean[] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static boolean[][] zip(boolean[][] a,
boolean[][] b,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[][] zip(boolean[][] a,
boolean[][] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[][] zip(boolean[][] a,
boolean[][] b,
boolean[][] c,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static boolean[][] zip(boolean[][] a,
boolean[][] b,
boolean[][] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static boolean[][][] zip(boolean[][][] a,
boolean[][][] b,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[][][] zip(boolean[][][] a,
boolean[][][] b,
boolean valueForNoneA,
boolean valueForNoneB,
BooleanBiFunction<java.lang.Boolean> zipFunction)
public static boolean[][][] zip(boolean[][][] a,
boolean[][][] b,
boolean[][][] c,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static boolean[][][] zip(boolean[][][] a,
boolean[][][] b,
boolean[][][] c,
boolean valueForNoneA,
boolean valueForNoneB,
boolean valueForNoneC,
BooleanTriFunction<java.lang.Boolean> zipFunction)
public static BooleanMatrix matrix(boolean[][] a)
public static BooleanMatrix matrix(boolean[][] a, int m)
public static BooleanMatrix matrix(boolean[][] a, int n, int m)
public static BooleanMatrix matrix(boolean[][] a, int n, int m, boolean valueForDefault)
public static java.lang.Boolean[] box(boolean[] a)
public static java.lang.Boolean[][] box(boolean[][] a)
public static java.lang.Boolean[][][] box(boolean[][][] a)
public static boolean[] unbox(java.lang.Boolean[] a)
public static boolean[] unbox(java.lang.Boolean[] a,
boolean valueForNul)
public static boolean[][] unbox(java.lang.Boolean[][] a)
public static boolean[][] unbox(java.lang.Boolean[][] a,
boolean valueForNul)
public static boolean[][][] unbox(java.lang.Boolean[][][] a)
public static boolean[][][] unbox(java.lang.Boolean[][][] a,
boolean valueForNul)
public static void println(boolean[] a)
public static void println(boolean[][] a)
public static void println(boolean[][][] a)
public static void plus(char[] a,
int param)
public static void plus(char[][] a,
int param)
public static void plus(char[][][] a,
int param)
public static void minus(char[] a,
int param)
public static void minus(char[][] a,
int param)
public static void minus(char[][][] a,
int param)
public static void multipliedBy(char[] a,
int param)
public static void multipliedBy(char[][] a,
int param)
public static void multipliedBy(char[][][] a,
int param)
public static void dividedBy(char[] a,
int param)
public static void dividedBy(char[][] a,
int param)
public static void dividedBy(char[][][] a,
int param)
public static void replaceAll(char[] a,
CharUnaryOperator operator)
public static void replaceAll(char[][] a,
CharUnaryOperator operator)
public static void replaceAll(char[][][] a,
CharUnaryOperator operator)
public static void replaceIf(char[] a,
CharPredicate predicate,
char newValue)
public static void replaceIf(char[][] a,
CharPredicate predicate,
char newValue)
public static void replaceIf(char[][][] a,
CharPredicate predicate,
char newValue)
public static char[] flatten(char[][] a)
public static char[] flatten(char[][][] a)
public static char[][] reshape(char[] a,
int m)
public static char[][][] reshape(char[] a,
int m,
int l)
public static char[] zip(char[] a,
char[] b,
CharBiFunction<java.lang.Character> zipFunction)
public static char[] zip(char[] a,
char[] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction)
public static char[] zip(char[] a,
char[] b,
char[] c,
CharTriFunction<java.lang.Character> zipFunction)
public static char[] zip(char[] a,
char[] b,
char[] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction)
public static char[][] zip(char[][] a,
char[][] b,
CharBiFunction<java.lang.Character> zipFunction)
public static char[][] zip(char[][] a,
char[][] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction)
public static char[][] zip(char[][] a,
char[][] b,
char[][] c,
CharTriFunction<java.lang.Character> zipFunction)
public static char[][] zip(char[][] a,
char[][] b,
char[][] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction)
public static char[][][] zip(char[][][] a,
char[][][] b,
CharBiFunction<java.lang.Character> zipFunction)
public static char[][][] zip(char[][][] a,
char[][][] b,
char valueForNoneA,
char valueForNoneB,
CharBiFunction<java.lang.Character> zipFunction)
public static char[][][] zip(char[][][] a,
char[][][] b,
char[][][] c,
CharTriFunction<java.lang.Character> zipFunction)
public static char[][][] zip(char[][][] a,
char[][][] b,
char[][][] c,
char valueForNoneA,
char valueForNoneB,
char valueForNoneC,
CharTriFunction<java.lang.Character> zipFunction)
public static CharMatrix matrix(char[][] a)
public static CharMatrix matrix(char[][] a, int m)
public static CharMatrix matrix(char[][] a, int n, int m)
public static CharMatrix matrix(char[][] a, int n, int m, char valueForDefault)
public static java.lang.Character[] box(char[] a)
public static java.lang.Character[][] box(char[][] a)
public static java.lang.Character[][][] box(char[][][] a)
public static char[] unbox(java.lang.Character[] a)
public static char[] unbox(java.lang.Character[] a,
char valueForNul)
public static char[][] unbox(java.lang.Character[][] a)
public static char[][] unbox(java.lang.Character[][] a,
char valueForNul)
public static char[][][] unbox(java.lang.Character[][][] a)
public static char[][][] unbox(java.lang.Character[][][] a,
char valueForNul)
public static void println(char[] a)
public static void println(char[][] a)
public static void println(char[][][] a)
public static void plus(byte[] a,
byte param)
public static void plus(byte[][] a,
byte param)
public static void plus(byte[][][] a,
byte param)
public static void minus(byte[] a,
byte param)
public static void minus(byte[][] a,
byte param)
public static void minus(byte[][][] a,
byte param)
public static void multipliedBy(byte[] a,
byte param)
public static void multipliedBy(byte[][] a,
byte param)
public static void multipliedBy(byte[][][] a,
byte param)
public static void dividedBy(byte[] a,
byte param)
public static void dividedBy(byte[][] a,
byte param)
public static void dividedBy(byte[][][] a,
byte param)
public static void replaceAll(byte[] a,
ByteUnaryOperator operator)
public static void replaceAll(byte[][] a,
ByteUnaryOperator operator)
public static void replaceAll(byte[][][] a,
ByteUnaryOperator operator)
public static void replaceIf(byte[] a,
BytePredicate predicate,
byte newValue)
public static void replaceIf(byte[][] a,
BytePredicate predicate,
byte newValue)
public static void replaceIf(byte[][][] a,
BytePredicate predicate,
byte newValue)
public static byte[] flatten(byte[][] a)
public static byte[] flatten(byte[][][] a)
public static byte[][] reshape(byte[] a,
int m)
public static byte[][][] reshape(byte[] a,
int m,
int l)
public static byte[] add(byte[] a,
byte[] b)
public static byte[] add(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[] add(byte[] a,
byte[] b,
byte[] c)
public static byte[] add(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][] add(byte[][] a,
byte[][] b)
public static byte[][] add(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][] add(byte[][] a,
byte[][] b,
byte[][] c)
public static byte[][] add(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][][] add(byte[][][] a,
byte[][][] b)
public static byte[][][] add(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][][] add(byte[][][] a,
byte[][][] b,
byte[][][] c)
public static byte[][][] add(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[] subtract(byte[] a,
byte[] b)
public static byte[] subtract(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[] subtract(byte[] a,
byte[] b,
byte[] c)
public static byte[] subtract(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][] subtract(byte[][] a,
byte[][] b)
public static byte[][] subtract(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][] subtract(byte[][] a,
byte[][] b,
byte[][] c)
public static byte[][] subtract(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][][] subtract(byte[][][] a,
byte[][][] b)
public static byte[][][] subtract(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][][] subtract(byte[][][] a,
byte[][][] b,
byte[][][] c)
public static byte[][][] subtract(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[] multipliedBy(byte[] a,
byte[] b)
public static byte[] multipliedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[] multipliedBy(byte[] a,
byte[] b,
byte[] c)
public static byte[] multipliedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][] multipliedBy(byte[][] a,
byte[][] b)
public static byte[][] multipliedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][] multipliedBy(byte[][] a,
byte[][] b,
byte[][] c)
public static byte[][] multipliedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][][] multipliedBy(byte[][][] a,
byte[][][] b)
public static byte[][][] multipliedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][][] multipliedBy(byte[][][] a,
byte[][][] b,
byte[][][] c)
public static byte[][][] multipliedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[] dividedBy(byte[] a,
byte[] b)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte[] c)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][] dividedBy(byte[][] a,
byte[][] b)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte[][] c)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte defaultValueForZero)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte[] c,
byte defaultValueForZero)
public static byte[] dividedBy(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte defaultValueForZero)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte defaultValueForZero)
public static byte[][] dividedBy(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte defaultValueForZero)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB,
byte defaultValueForZero)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte defaultValueForZero)
public static byte[][][] dividedBy(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
byte defaultValueForZero)
public static byte[] zip(byte[] a,
byte[] b,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[] zip(byte[] a,
byte[] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[] zip(byte[] a,
byte[] b,
byte[] c,
ByteTriFunction<java.lang.Byte> zipFunction)
public static byte[] zip(byte[] a,
byte[] b,
byte[] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction)
public static byte[][] zip(byte[][] a,
byte[][] b,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[][] zip(byte[][] a,
byte[][] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[][] zip(byte[][] a,
byte[][] b,
byte[][] c,
ByteTriFunction<java.lang.Byte> zipFunction)
public static byte[][] zip(byte[][] a,
byte[][] b,
byte[][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction)
public static byte[][][] zip(byte[][][] a,
byte[][][] b,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[][][] zip(byte[][][] a,
byte[][][] b,
byte valueForNoneA,
byte valueForNoneB,
ByteBiFunction<java.lang.Byte> zipFunction)
public static byte[][][] zip(byte[][][] a,
byte[][][] b,
byte[][][] c,
ByteTriFunction<java.lang.Byte> zipFunction)
public static byte[][][] zip(byte[][][] a,
byte[][][] b,
byte[][][] c,
byte valueForNoneA,
byte valueForNoneB,
byte valueForNoneC,
ByteTriFunction<java.lang.Byte> zipFunction)
public static ByteMatrix matrix(byte[][] a)
public static ByteMatrix matrix(byte[][] a, int m)
public static ByteMatrix matrix(byte[][] a, int n, int m)
public static ByteMatrix matrix(byte[][] a, int n, int m, byte valueForDefault)
public static java.lang.Byte[] box(byte[] a)
public static java.lang.Byte[][] box(byte[][] a)
public static java.lang.Byte[][][] box(byte[][][] a)
public static byte[] unbox(java.lang.Byte[] a)
public static byte[] unbox(java.lang.Byte[] a,
byte valueForNul)
public static byte[][] unbox(java.lang.Byte[][] a)
public static byte[][] unbox(java.lang.Byte[][] a,
byte valueForNul)
public static byte[][][] unbox(java.lang.Byte[][][] a)
public static byte[][][] unbox(java.lang.Byte[][][] a,
byte valueForNul)
public static void println(byte[] a)
public static void println(byte[][] a)
public static void println(byte[][][] a)
public static void plus(short[] a,
short param)
public static void plus(short[][] a,
short param)
public static void plus(short[][][] a,
short param)
public static void minus(short[] a,
short param)
public static void minus(short[][] a,
short param)
public static void minus(short[][][] a,
short param)
public static void multipliedBy(short[] a,
short param)
public static void multipliedBy(short[][] a,
short param)
public static void multipliedBy(short[][][] a,
short param)
public static void dividedBy(short[] a,
short param)
public static void dividedBy(short[][] a,
short param)
public static void dividedBy(short[][][] a,
short param)
public static void replaceAll(short[] a,
ShortUnaryOperator operator)
public static void replaceAll(short[][] a,
ShortUnaryOperator operator)
public static void replaceAll(short[][][] a,
ShortUnaryOperator operator)
public static void replaceIf(short[] a,
ShortPredicate predicate,
short newValue)
public static void replaceIf(short[][] a,
ShortPredicate predicate,
short newValue)
public static void replaceIf(short[][][] a,
ShortPredicate predicate,
short newValue)
public static short[] flatten(short[][] a)
public static short[] flatten(short[][][] a)
public static short[][] reshape(short[] a,
int m)
public static short[][][] reshape(short[] a,
int m,
int l)
public static short[] add(short[] a,
short[] b)
public static short[] add(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB)
public static short[] add(short[] a,
short[] b,
short[] c)
public static short[] add(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][] add(short[][] a,
short[][] b)
public static short[][] add(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][] add(short[][] a,
short[][] b,
short[][] c)
public static short[][] add(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][][] add(short[][][] a,
short[][][] b)
public static short[][][] add(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][][] add(short[][][] a,
short[][][] b,
short[][][] c)
public static short[][][] add(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[] subtract(short[] a,
short[] b)
public static short[] subtract(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB)
public static short[] subtract(short[] a,
short[] b,
short[] c)
public static short[] subtract(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][] subtract(short[][] a,
short[][] b)
public static short[][] subtract(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][] subtract(short[][] a,
short[][] b,
short[][] c)
public static short[][] subtract(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][][] subtract(short[][][] a,
short[][][] b)
public static short[][][] subtract(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][][] subtract(short[][][] a,
short[][][] b,
short[][][] c)
public static short[][][] subtract(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[] multipliedBy(short[] a,
short[] b)
public static short[] multipliedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB)
public static short[] multipliedBy(short[] a,
short[] b,
short[] c)
public static short[] multipliedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][] multipliedBy(short[][] a,
short[][] b)
public static short[][] multipliedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][] multipliedBy(short[][] a,
short[][] b,
short[][] c)
public static short[][] multipliedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][][] multipliedBy(short[][][] a,
short[][][] b)
public static short[][][] multipliedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][][] multipliedBy(short[][][] a,
short[][][] b,
short[][][] c)
public static short[][][] multipliedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[] dividedBy(short[] a,
short[] b)
public static short[] dividedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB)
public static short[] dividedBy(short[] a,
short[] b,
short[] c)
public static short[] dividedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][] dividedBy(short[][] a,
short[][] b)
public static short[][] dividedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][] dividedBy(short[][] a,
short[][] b,
short[][] c)
public static short[][] dividedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[][][] dividedBy(short[][][] a,
short[][][] b)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short[][][] c)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC)
public static short[] dividedBy(short[] a,
short[] b,
short defaultValueForZero)
public static short[] dividedBy(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero)
public static short[] dividedBy(short[] a,
short[] b,
short[] c,
short defaultValueForZero)
public static short[] dividedBy(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero)
public static short[][] dividedBy(short[][] a,
short[][] b,
short defaultValueForZero)
public static short[][] dividedBy(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero)
public static short[][] dividedBy(short[][] a,
short[][] b,
short[][] c,
short defaultValueForZero)
public static short[][] dividedBy(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short defaultValueForZero)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB,
short defaultValueForZero)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short defaultValueForZero)
public static short[][][] dividedBy(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
short defaultValueForZero)
public static short[] zip(short[] a,
short[] b,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[] zip(short[] a,
short[] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[] zip(short[] a,
short[] b,
short[] c,
ShortTriFunction<java.lang.Short> zipFunction)
public static short[] zip(short[] a,
short[] b,
short[] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction)
public static short[][] zip(short[][] a,
short[][] b,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[][] zip(short[][] a,
short[][] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[][] zip(short[][] a,
short[][] b,
short[][] c,
ShortTriFunction<java.lang.Short> zipFunction)
public static short[][] zip(short[][] a,
short[][] b,
short[][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction)
public static short[][][] zip(short[][][] a,
short[][][] b,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[][][] zip(short[][][] a,
short[][][] b,
short valueForNoneA,
short valueForNoneB,
ShortBiFunction<java.lang.Short> zipFunction)
public static short[][][] zip(short[][][] a,
short[][][] b,
short[][][] c,
ShortTriFunction<java.lang.Short> zipFunction)
public static short[][][] zip(short[][][] a,
short[][][] b,
short[][][] c,
short valueForNoneA,
short valueForNoneB,
short valueForNoneC,
ShortTriFunction<java.lang.Short> zipFunction)
public static ShortMatrix matrix(short[][] a)
public static ShortMatrix matrix(short[][] a, int m)
public static ShortMatrix matrix(short[][] a, int n, int m)
public static ShortMatrix matrix(short[][] a, int n, int m, short valueForDefault)
public static java.lang.Short[] box(short[] a)
public static java.lang.Short[][] box(short[][] a)
public static java.lang.Short[][][] box(short[][][] a)
public static short[] unbox(java.lang.Short[] a)
public static short[] unbox(java.lang.Short[] a,
short valueForNul)
public static short[][] unbox(java.lang.Short[][] a)
public static short[][] unbox(java.lang.Short[][] a,
short valueForNul)
public static short[][][] unbox(java.lang.Short[][][] a)
public static short[][][] unbox(java.lang.Short[][][] a,
short valueForNul)
public static void println(short[] a)
public static void println(short[][] a)
public static void println(short[][][] a)
public static void plus(int[] a,
int param)
public static void plus(int[][] a,
int param)
public static void plus(int[][][] a,
int param)
public static void minus(int[] a,
int param)
public static void minus(int[][] a,
int param)
public static void minus(int[][][] a,
int param)
public static void multipliedBy(int[] a,
int param)
public static void multipliedBy(int[][] a,
int param)
public static void multipliedBy(int[][][] a,
int param)
public static void dividedBy(int[] a,
int param)
public static void dividedBy(int[][] a,
int param)
public static void dividedBy(int[][][] a,
int param)
public static void replaceAll(int[] a,
IntUnaryOperator operator)
public static void replaceAll(int[][] a,
IntUnaryOperator operator)
public static void replaceAll(int[][][] a,
IntUnaryOperator operator)
public static void replaceIf(int[] a,
IntPredicate predicate,
int newValue)
public static void replaceIf(int[][] a,
IntPredicate predicate,
int newValue)
public static void replaceIf(int[][][] a,
IntPredicate predicate,
int newValue)
public static int[] flatten(int[][] a)
public static int[] flatten(int[][][] a)
public static int[][] reshape(int[] a,
int m)
public static int[][][] reshape(int[] a,
int m,
int l)
public static int[] add(int[] a,
int[] b)
public static int[] add(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB)
public static int[] add(int[] a,
int[] b,
int[] c)
public static int[] add(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][] add(int[][] a,
int[][] b)
public static int[][] add(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][] add(int[][] a,
int[][] b,
int[][] c)
public static int[][] add(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][][] add(int[][][] a,
int[][][] b)
public static int[][][] add(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][][] add(int[][][] a,
int[][][] b,
int[][][] c)
public static int[][][] add(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[] subtract(int[] a,
int[] b)
public static int[] subtract(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB)
public static int[] subtract(int[] a,
int[] b,
int[] c)
public static int[] subtract(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][] subtract(int[][] a,
int[][] b)
public static int[][] subtract(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][] subtract(int[][] a,
int[][] b,
int[][] c)
public static int[][] subtract(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][][] subtract(int[][][] a,
int[][][] b)
public static int[][][] subtract(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][][] subtract(int[][][] a,
int[][][] b,
int[][][] c)
public static int[][][] subtract(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[] multipliedBy(int[] a,
int[] b)
public static int[] multipliedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB)
public static int[] multipliedBy(int[] a,
int[] b,
int[] c)
public static int[] multipliedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][] multipliedBy(int[][] a,
int[][] b)
public static int[][] multipliedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][] multipliedBy(int[][] a,
int[][] b,
int[][] c)
public static int[][] multipliedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][][] multipliedBy(int[][][] a,
int[][][] b)
public static int[][][] multipliedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][][] multipliedBy(int[][][] a,
int[][][] b,
int[][][] c)
public static int[][][] multipliedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[] dividedBy(int[] a,
int[] b)
public static int[] dividedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB)
public static int[] dividedBy(int[] a,
int[] b,
int[] c)
public static int[] dividedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][] dividedBy(int[][] a,
int[][] b)
public static int[][] dividedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][] dividedBy(int[][] a,
int[][] b,
int[][] c)
public static int[][] dividedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[][][] dividedBy(int[][][] a,
int[][][] b)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int[][][] c)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC)
public static int[] dividedBy(int[] a,
int[] b,
int defaultValueForZero)
public static int[] dividedBy(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero)
public static int[] dividedBy(int[] a,
int[] b,
int[] c,
int defaultValueForZero)
public static int[] dividedBy(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero)
public static int[][] dividedBy(int[][] a,
int[][] b,
int defaultValueForZero)
public static int[][] dividedBy(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero)
public static int[][] dividedBy(int[][] a,
int[][] b,
int[][] c,
int defaultValueForZero)
public static int[][] dividedBy(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int defaultValueForZero)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB,
int defaultValueForZero)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int defaultValueForZero)
public static int[][][] dividedBy(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
int defaultValueForZero)
public static int[] zip(int[] a,
int[] b,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[] zip(int[] a,
int[] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[] zip(int[] a,
int[] b,
int[] c,
IntTriFunction<java.lang.Integer> zipFunction)
public static int[] zip(int[] a,
int[] b,
int[] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction)
public static int[][] zip(int[][] a,
int[][] b,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[][] zip(int[][] a,
int[][] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[][] zip(int[][] a,
int[][] b,
int[][] c,
IntTriFunction<java.lang.Integer> zipFunction)
public static int[][] zip(int[][] a,
int[][] b,
int[][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction)
public static int[][][] zip(int[][][] a,
int[][][] b,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[][][] zip(int[][][] a,
int[][][] b,
int valueForNoneA,
int valueForNoneB,
IntBiFunction<java.lang.Integer> zipFunction)
public static int[][][] zip(int[][][] a,
int[][][] b,
int[][][] c,
IntTriFunction<java.lang.Integer> zipFunction)
public static int[][][] zip(int[][][] a,
int[][][] b,
int[][][] c,
int valueForNoneA,
int valueForNoneB,
int valueForNoneC,
IntTriFunction<java.lang.Integer> zipFunction)
public static IntMatrix matrix(int[][] a)
public static IntMatrix matrix(int[][] a, int m)
public static IntMatrix matrix(int[][] a, int n, int m)
public static IntMatrix matrix(int[][] a, int n, int m, int valueForDefault)
public static java.lang.Integer[] box(int[] a)
public static java.lang.Integer[][] box(int[][] a)
public static java.lang.Integer[][][] box(int[][][] a)
public static int[] unbox(java.lang.Integer[] a)
public static int[] unbox(java.lang.Integer[] a,
int valueForNul)
public static int[][] unbox(java.lang.Integer[][] a)
public static int[][] unbox(java.lang.Integer[][] a,
int valueForNul)
public static int[][][] unbox(java.lang.Integer[][][] a)
public static int[][][] unbox(java.lang.Integer[][][] a,
int valueForNul)
public static void println(int[] a)
public static void println(int[][] a)
public static void println(int[][][] a)
public static void plus(long[] a,
long param)
public static void plus(long[][] a,
long param)
public static void plus(long[][][] a,
long param)
public static void minus(long[] a,
long param)
public static void minus(long[][] a,
long param)
public static void minus(long[][][] a,
long param)
public static void multipliedBy(long[] a,
long param)
public static void multipliedBy(long[][] a,
long param)
public static void multipliedBy(long[][][] a,
long param)
public static void dividedBy(long[] a,
long param)
public static void dividedBy(long[][] a,
long param)
public static void dividedBy(long[][][] a,
long param)
public static void replaceAll(long[] a,
LongUnaryOperator operator)
public static void replaceAll(long[][] a,
LongUnaryOperator operator)
public static void replaceAll(long[][][] a,
LongUnaryOperator operator)
public static void replaceIf(long[] a,
LongPredicate predicate,
long newValue)
public static void replaceIf(long[][] a,
LongPredicate predicate,
long newValue)
public static void replaceIf(long[][][] a,
LongPredicate predicate,
long newValue)
public static long[] flatten(long[][] a)
public static long[] flatten(long[][][] a)
public static long[][] reshape(long[] a,
int m)
public static long[][][] reshape(long[] a,
int m,
int l)
public static long[] add(long[] a,
long[] b)
public static long[] add(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB)
public static long[] add(long[] a,
long[] b,
long[] c)
public static long[] add(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][] add(long[][] a,
long[][] b)
public static long[][] add(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][] add(long[][] a,
long[][] b,
long[][] c)
public static long[][] add(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][][] add(long[][][] a,
long[][][] b)
public static long[][][] add(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][][] add(long[][][] a,
long[][][] b,
long[][][] c)
public static long[][][] add(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[] subtract(long[] a,
long[] b)
public static long[] subtract(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB)
public static long[] subtract(long[] a,
long[] b,
long[] c)
public static long[] subtract(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][] subtract(long[][] a,
long[][] b)
public static long[][] subtract(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][] subtract(long[][] a,
long[][] b,
long[][] c)
public static long[][] subtract(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][][] subtract(long[][][] a,
long[][][] b)
public static long[][][] subtract(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][][] subtract(long[][][] a,
long[][][] b,
long[][][] c)
public static long[][][] subtract(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[] multipliedBy(long[] a,
long[] b)
public static long[] multipliedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB)
public static long[] multipliedBy(long[] a,
long[] b,
long[] c)
public static long[] multipliedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][] multipliedBy(long[][] a,
long[][] b)
public static long[][] multipliedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][] multipliedBy(long[][] a,
long[][] b,
long[][] c)
public static long[][] multipliedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][][] multipliedBy(long[][][] a,
long[][][] b)
public static long[][][] multipliedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][][] multipliedBy(long[][][] a,
long[][][] b,
long[][][] c)
public static long[][][] multipliedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[] dividedBy(long[] a,
long[] b)
public static long[] dividedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB)
public static long[] dividedBy(long[] a,
long[] b,
long[] c)
public static long[] dividedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][] dividedBy(long[][] a,
long[][] b)
public static long[][] dividedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][] dividedBy(long[][] a,
long[][] b,
long[][] c)
public static long[][] dividedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[][][] dividedBy(long[][][] a,
long[][][] b)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long[][][] c)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC)
public static long[] dividedBy(long[] a,
long[] b,
long defaultValueForZero)
public static long[] dividedBy(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero)
public static long[] dividedBy(long[] a,
long[] b,
long[] c,
long defaultValueForZero)
public static long[] dividedBy(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero)
public static long[][] dividedBy(long[][] a,
long[][] b,
long defaultValueForZero)
public static long[][] dividedBy(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero)
public static long[][] dividedBy(long[][] a,
long[][] b,
long[][] c,
long defaultValueForZero)
public static long[][] dividedBy(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long defaultValueForZero)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB,
long defaultValueForZero)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long defaultValueForZero)
public static long[][][] dividedBy(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
long defaultValueForZero)
public static long[] zip(long[] a,
long[] b,
LongBiFunction<java.lang.Long> zipFunction)
public static long[] zip(long[] a,
long[] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction)
public static long[] zip(long[] a,
long[] b,
long[] c,
LongTriFunction<java.lang.Long> zipFunction)
public static long[] zip(long[] a,
long[] b,
long[] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction)
public static long[][] zip(long[][] a,
long[][] b,
LongBiFunction<java.lang.Long> zipFunction)
public static long[][] zip(long[][] a,
long[][] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction)
public static long[][] zip(long[][] a,
long[][] b,
long[][] c,
LongTriFunction<java.lang.Long> zipFunction)
public static long[][] zip(long[][] a,
long[][] b,
long[][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction)
public static long[][][] zip(long[][][] a,
long[][][] b,
LongBiFunction<java.lang.Long> zipFunction)
public static long[][][] zip(long[][][] a,
long[][][] b,
long valueForNoneA,
long valueForNoneB,
LongBiFunction<java.lang.Long> zipFunction)
public static long[][][] zip(long[][][] a,
long[][][] b,
long[][][] c,
LongTriFunction<java.lang.Long> zipFunction)
public static long[][][] zip(long[][][] a,
long[][][] b,
long[][][] c,
long valueForNoneA,
long valueForNoneB,
long valueForNoneC,
LongTriFunction<java.lang.Long> zipFunction)
public static LongMatrix matrix(long[][] a)
public static LongMatrix matrix(long[][] a, int m)
public static LongMatrix matrix(long[][] a, int n, int m)
public static LongMatrix matrix(long[][] a, int n, int m, long valueForDefault)
public static java.lang.Long[] box(long[] a)
public static java.lang.Long[][] box(long[][] a)
public static java.lang.Long[][][] box(long[][][] a)
public static long[] unbox(java.lang.Long[] a)
public static long[] unbox(java.lang.Long[] a,
long valueForNul)
public static long[][] unbox(java.lang.Long[][] a)
public static long[][] unbox(java.lang.Long[][] a,
long valueForNul)
public static long[][][] unbox(java.lang.Long[][][] a)
public static long[][][] unbox(java.lang.Long[][][] a,
long valueForNul)
public static void println(long[] a)
public static void println(long[][] a)
public static void println(long[][][] a)
public static void plus(float[] a,
float param)
public static void plus(float[][] a,
float param)
public static void plus(float[][][] a,
float param)
public static void minus(float[] a,
float param)
public static void minus(float[][] a,
float param)
public static void minus(float[][][] a,
float param)
public static void multipliedBy(float[] a,
float param)
public static void multipliedBy(float[][] a,
float param)
public static void multipliedBy(float[][][] a,
float param)
public static void dividedBy(float[] a,
float param)
public static void dividedBy(float[][] a,
float param)
public static void dividedBy(float[][][] a,
float param)
public static void replaceAll(float[] a,
FloatUnaryOperator operator)
public static void replaceAll(float[][] a,
FloatUnaryOperator operator)
public static void replaceAll(float[][][] a,
FloatUnaryOperator operator)
public static void replaceIf(float[] a,
FloatPredicate predicate,
float newValue)
public static void replaceIf(float[][] a,
FloatPredicate predicate,
float newValue)
public static void replaceIf(float[][][] a,
FloatPredicate predicate,
float newValue)
public static float[] flatten(float[][] a)
public static float[] flatten(float[][][] a)
public static float[][] reshape(float[] a,
int m)
public static float[][][] reshape(float[] a,
int m,
int l)
public static float[] add(float[] a,
float[] b)
public static float[] add(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB)
public static float[] add(float[] a,
float[] b,
float[] c)
public static float[] add(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][] add(float[][] a,
float[][] b)
public static float[][] add(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][] add(float[][] a,
float[][] b,
float[][] c)
public static float[][] add(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][][] add(float[][][] a,
float[][][] b)
public static float[][][] add(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][][] add(float[][][] a,
float[][][] b,
float[][][] c)
public static float[][][] add(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[] subtract(float[] a,
float[] b)
public static float[] subtract(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB)
public static float[] subtract(float[] a,
float[] b,
float[] c)
public static float[] subtract(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][] subtract(float[][] a,
float[][] b)
public static float[][] subtract(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][] subtract(float[][] a,
float[][] b,
float[][] c)
public static float[][] subtract(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][][] subtract(float[][][] a,
float[][][] b)
public static float[][][] subtract(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][][] subtract(float[][][] a,
float[][][] b,
float[][][] c)
public static float[][][] subtract(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[] multipliedBy(float[] a,
float[] b)
public static float[] multipliedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB)
public static float[] multipliedBy(float[] a,
float[] b,
float[] c)
public static float[] multipliedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][] multipliedBy(float[][] a,
float[][] b)
public static float[][] multipliedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][] multipliedBy(float[][] a,
float[][] b,
float[][] c)
public static float[][] multipliedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][][] multipliedBy(float[][][] a,
float[][][] b)
public static float[][][] multipliedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][][] multipliedBy(float[][][] a,
float[][][] b,
float[][][] c)
public static float[][][] multipliedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[] dividedBy(float[] a,
float[] b)
public static float[] dividedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB)
public static float[] dividedBy(float[] a,
float[] b,
float[] c)
public static float[] dividedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][] dividedBy(float[][] a,
float[][] b)
public static float[][] dividedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][] dividedBy(float[][] a,
float[][] b,
float[][] c)
public static float[][] dividedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[][][] dividedBy(float[][][] a,
float[][][] b)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float[][][] c)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC)
public static float[] dividedBy(float[] a,
float[] b,
float defaultValueForZero)
public static float[] dividedBy(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero)
public static float[] dividedBy(float[] a,
float[] b,
float[] c,
float defaultValueForZero)
public static float[] dividedBy(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero)
public static float[][] dividedBy(float[][] a,
float[][] b,
float defaultValueForZero)
public static float[][] dividedBy(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero)
public static float[][] dividedBy(float[][] a,
float[][] b,
float[][] c,
float defaultValueForZero)
public static float[][] dividedBy(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float defaultValueForZero)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB,
float defaultValueForZero)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float defaultValueForZero)
public static float[][][] dividedBy(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
float defaultValueForZero)
public static float[] zip(float[] a,
float[] b,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[] zip(float[] a,
float[] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[] zip(float[] a,
float[] b,
float[] c,
FloatTriFunction<java.lang.Float> zipFunction)
public static float[] zip(float[] a,
float[] b,
float[] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction)
public static float[][] zip(float[][] a,
float[][] b,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[][] zip(float[][] a,
float[][] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[][] zip(float[][] a,
float[][] b,
float[][] c,
FloatTriFunction<java.lang.Float> zipFunction)
public static float[][] zip(float[][] a,
float[][] b,
float[][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction)
public static float[][][] zip(float[][][] a,
float[][][] b,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[][][] zip(float[][][] a,
float[][][] b,
float valueForNoneA,
float valueForNoneB,
FloatBiFunction<java.lang.Float> zipFunction)
public static float[][][] zip(float[][][] a,
float[][][] b,
float[][][] c,
FloatTriFunction<java.lang.Float> zipFunction)
public static float[][][] zip(float[][][] a,
float[][][] b,
float[][][] c,
float valueForNoneA,
float valueForNoneB,
float valueForNoneC,
FloatTriFunction<java.lang.Float> zipFunction)
public static FloatMatrix matrix(float[][] a)
public static FloatMatrix matrix(float[][] a, int m)
public static FloatMatrix matrix(float[][] a, int n, int m)
public static FloatMatrix matrix(float[][] a, int n, int m, float valueForDefault)
public static java.lang.Float[] box(float[] a)
public static java.lang.Float[][] box(float[][] a)
public static java.lang.Float[][][] box(float[][][] a)
public static float[] unbox(java.lang.Float[] a)
public static float[] unbox(java.lang.Float[] a,
float valueForNul)
public static float[][] unbox(java.lang.Float[][] a)
public static float[][] unbox(java.lang.Float[][] a,
float valueForNul)
public static float[][][] unbox(java.lang.Float[][][] a)
public static float[][][] unbox(java.lang.Float[][][] a,
float valueForNul)
public static void println(float[] a)
public static void println(float[][] a)
public static void println(float[][][] a)
public static void plus(double[] a,
double param)
public static void plus(double[][] a,
double param)
public static void plus(double[][][] a,
double param)
public static void minus(double[] a,
double param)
public static void minus(double[][] a,
double param)
public static void minus(double[][][] a,
double param)
public static void multipliedBy(double[] a,
double param)
public static void multipliedBy(double[][] a,
double param)
public static void multipliedBy(double[][][] a,
double param)
public static void dividedBy(double[] a,
double param)
public static void dividedBy(double[][] a,
double param)
public static void dividedBy(double[][][] a,
double param)
public static void replaceAll(double[] a,
DoubleUnaryOperator operator)
public static void replaceAll(double[][] a,
DoubleUnaryOperator operator)
public static void replaceAll(double[][][] a,
DoubleUnaryOperator operator)
public static void replaceIf(double[] a,
DoublePredicate predicate,
double newValue)
public static void replaceIf(double[][] a,
DoublePredicate predicate,
double newValue)
public static void replaceIf(double[][][] a,
DoublePredicate predicate,
double newValue)
public static double[] flatten(double[][] a)
public static double[] flatten(double[][][] a)
public static double[][] reshape(double[] a,
int m)
public static double[][][] reshape(double[] a,
int m,
int l)
public static double[] add(double[] a,
double[] b)
public static double[] add(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB)
public static double[] add(double[] a,
double[] b,
double[] c)
public static double[] add(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][] add(double[][] a,
double[][] b)
public static double[][] add(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][] add(double[][] a,
double[][] b,
double[][] c)
public static double[][] add(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][][] add(double[][][] a,
double[][][] b)
public static double[][][] add(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][][] add(double[][][] a,
double[][][] b,
double[][][] c)
public static double[][][] add(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[] subtract(double[] a,
double[] b)
public static double[] subtract(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB)
public static double[] subtract(double[] a,
double[] b,
double[] c)
public static double[] subtract(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][] subtract(double[][] a,
double[][] b)
public static double[][] subtract(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][] subtract(double[][] a,
double[][] b,
double[][] c)
public static double[][] subtract(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][][] subtract(double[][][] a,
double[][][] b)
public static double[][][] subtract(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][][] subtract(double[][][] a,
double[][][] b,
double[][][] c)
public static double[][][] subtract(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[] multipliedBy(double[] a,
double[] b)
public static double[] multipliedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB)
public static double[] multipliedBy(double[] a,
double[] b,
double[] c)
public static double[] multipliedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][] multipliedBy(double[][] a,
double[][] b)
public static double[][] multipliedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][] multipliedBy(double[][] a,
double[][] b,
double[][] c)
public static double[][] multipliedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][][] multipliedBy(double[][][] a,
double[][][] b)
public static double[][][] multipliedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][][] multipliedBy(double[][][] a,
double[][][] b,
double[][][] c)
public static double[][][] multipliedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[] dividedBy(double[] a,
double[] b)
public static double[] dividedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB)
public static double[] dividedBy(double[] a,
double[] b,
double[] c)
public static double[] dividedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][] dividedBy(double[][] a,
double[][] b)
public static double[][] dividedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][] dividedBy(double[][] a,
double[][] b,
double[][] c)
public static double[][] dividedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[][][] dividedBy(double[][][] a,
double[][][] b)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double[][][] c)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC)
public static double[] dividedBy(double[] a,
double[] b,
double defaultValueForZero)
public static double[] dividedBy(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero)
public static double[] dividedBy(double[] a,
double[] b,
double[] c,
double defaultValueForZero)
public static double[] dividedBy(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero)
public static double[][] dividedBy(double[][] a,
double[][] b,
double defaultValueForZero)
public static double[][] dividedBy(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero)
public static double[][] dividedBy(double[][] a,
double[][] b,
double[][] c,
double defaultValueForZero)
public static double[][] dividedBy(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double defaultValueForZero)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB,
double defaultValueForZero)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double defaultValueForZero)
public static double[][][] dividedBy(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
double defaultValueForZero)
public static double[] zip(double[] a,
double[] b,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[] zip(double[] a,
double[] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[] zip(double[] a,
double[] b,
double[] c,
DoubleTriFunction<java.lang.Double> zipFunction)
public static double[] zip(double[] a,
double[] b,
double[] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction)
public static double[][] zip(double[][] a,
double[][] b,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[][] zip(double[][] a,
double[][] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[][] zip(double[][] a,
double[][] b,
double[][] c,
DoubleTriFunction<java.lang.Double> zipFunction)
public static double[][] zip(double[][] a,
double[][] b,
double[][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction)
public static double[][][] zip(double[][][] a,
double[][][] b,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[][][] zip(double[][][] a,
double[][][] b,
double valueForNoneA,
double valueForNoneB,
DoubleBiFunction<java.lang.Double> zipFunction)
public static double[][][] zip(double[][][] a,
double[][][] b,
double[][][] c,
DoubleTriFunction<java.lang.Double> zipFunction)
public static double[][][] zip(double[][][] a,
double[][][] b,
double[][][] c,
double valueForNoneA,
double valueForNoneB,
double valueForNoneC,
DoubleTriFunction<java.lang.Double> zipFunction)
public static DoubleMatrix matrix(double[][] a)
public static DoubleMatrix matrix(double[][] a, int m)
public static DoubleMatrix matrix(double[][] a, int n, int m)
public static DoubleMatrix matrix(double[][] a, int n, int m, double valueForDefault)
public static java.lang.Double[] box(double[] a)
public static java.lang.Double[][] box(double[][] a)
public static java.lang.Double[][][] box(double[][][] a)
public static double[] unbox(java.lang.Double[] a)
public static double[] unbox(java.lang.Double[] a,
double valueForNul)
public static double[][] unbox(java.lang.Double[][] a)
public static double[][] unbox(java.lang.Double[][] a,
double valueForNul)
public static double[][][] unbox(java.lang.Double[][][] a)
public static double[][][] unbox(java.lang.Double[][][] a,
double valueForNul)
public static void println(double[] a)
public static void println(double[][] a)
public static void println(double[][][] a)
public static boolean[] toBoolean(byte[] a)
public static boolean[][] toBoolean(byte[][] a)
public static boolean[][][] toBoolean(byte[][][] a)
public static boolean[] toBoolean(int[] a)
public static boolean[][] toBoolean(int[][] a)
public static boolean[][][] toBoolean(int[][][] a)
public static byte[] toByte(boolean[] a)
public static byte[][] toByte(boolean[][] a)
public static byte[][][] toByte(boolean[][][] a)
public static int[] toInt(boolean[] a)
public static int[][] toInt(boolean[][] a)
public static int[][][] toInt(boolean[][][] a)
public static int[] toInt(char[] a)
public static int[][] toInt(char[][] a)
public static int[][][] toInt(char[][][] a)
public static int[] toInt(byte[] a)
public static int[][] toInt(byte[][] a)
public static int[][][] toInt(byte[][][] a)
public static int[] toInt(short[] a)
public static int[][] toInt(short[][] a)
public static int[][][] toInt(short[][][] a)
public static long[] toLong(boolean[] a)
public static long[][] toLong(boolean[][] a)
public static long[][][] toLong(boolean[][][] a)
public static long[] toLong(char[] a)
public static long[][] toLong(char[][] a)
public static long[][][] toLong(char[][][] a)
public static long[] toLong(byte[] a)
public static long[][] toLong(byte[][] a)
public static long[][][] toLong(byte[][][] a)
public static long[] toLong(short[] a)
public static long[][] toLong(short[][] a)
public static long[][][] toLong(short[][][] a)
public static long[] toLong(int[] a)
public static long[][] toLong(int[][] a)
public static long[][][] toLong(int[][][] a)
public static float[] toFloat(char[] a)
public static float[][] toFloat(char[][] a)
public static float[][][] toFloat(char[][][] a)
public static float[] toFloat(byte[] a)
public static float[][] toFloat(byte[][] a)
public static float[][][] toFloat(byte[][][] a)
public static float[] toFloat(short[] a)
public static float[][] toFloat(short[][] a)
public static float[][][] toFloat(short[][][] a)
public static float[] toFloat(int[] a)
public static float[][] toFloat(int[][] a)
public static float[][][] toFloat(int[][][] a)
public static float[] toFloat(long[] a)
public static float[][] toFloat(long[][] a)
public static float[][][] toFloat(long[][][] a)
public static double[] toDouble(char[] a)
public static double[][] toDouble(char[][] a)
public static double[][][] toDouble(char[][][] a)
public static double[] toDouble(byte[] a)
public static double[][] toDouble(byte[][] a)
public static double[][][] toDouble(byte[][][] a)
public static double[] toDouble(short[] a)
public static double[][] toDouble(short[][] a)
public static double[][][] toDouble(short[][][] a)
public static double[] toDouble(int[] a)
public static double[][] toDouble(int[][] a)
public static double[][][] toDouble(int[][][] a)
public static double[] toDouble(long[] a)
public static double[][] toDouble(long[][] a)
public static double[][][] toDouble(long[][][] a)
public static double[] toDouble(float[] a)
public static double[][] toDouble(float[][] a)
public static double[][][] toDouble(float[][][] a)