checkArrays(x,y); int n = y.length;
checkArrays(x,y); int n = y.length;
checkArrays(x,y); int n = y.length;
checkArrays(x,y); int n = y.length;
/** * Applies this filter in 1st dimension in the reverse direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply1Reverse(float[][] x, float[][] y) { checkArrays(x,y); int n2 = y.length; for (int i2=0; i2<n2; ++i2) { applyReverse(x[i2],y[i2]); } }
/** * Applies this filter in 1st dimension in the forward direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply1Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { apply1Forward(x[i3],y[i3]); } }
/** * Applies this filter in 1st dimension in the forward direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply1Forward(float[][] x, float[][] y) { checkArrays(x,y); int n2 = y.length; for (int i2=0; i2<n2; ++i2) { applyForward(x[i2],y[i2]); } }
/** * Applies this filter in 2nd dimension in the forward direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply2Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { apply2Forward(x[i3],y[i3]); } }
/** * Applies this filter in 1st dimension in the reverse direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply1Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { apply1Reverse(x[i3],y[i3]); } }
/** * Applies this filter in 2nd dimension in the reverse direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply2Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { apply2Reverse(x[i3],y[i3]); } }
/** * Accumulates output in 1st dimension in the reverse direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate1Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { accumulate1Reverse(x[i3],y[i3]); } }
/** * Accumulates output in 2nd dimension in the reverse direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate2Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { accumulate2Reverse(x[i3],y[i3]); } }
/** * Accumulates output in 1st dimension in the forward direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate1Forward(float[][] x, float[][] y) { checkArrays(x,y); int n2 = y.length; for (int i2=0; i2<n2; ++i2) { accumulateForward(x[i2],y[i2]); } }
/** * Accumulates output in 1st dimension in the forward direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate1Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { accumulate1Forward(x[i3],y[i3]); } }
/** * Accumulates output in 2nd dimension in the forward direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate2Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; for (int i3=0; i3<n3; ++i3) { accumulate2Forward(x[i3],y[i3]); } }
/** * Accumulates output in 1st dimension in the reverse direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate1Reverse(float[][] x, float[][] y) { checkArrays(x,y); int n2 = y.length; for (int i2=0; i2<n2; ++i2) { accumulateReverse(x[i2],y[i2]); } }
/** * Applies this filter in 3rd dimension in the forward direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply3Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; int n2 = y[0].length; int n1 = y[0][0].length; float[][] xy = new float[n3][n1]; for (int i2=0; i2<n2; ++i2) { get2(i2,x,xy); apply2Forward(xy,xy); set2(i2,xy,y); } }
/** * Accumulates output in 3rd dimension in the forward direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate3Forward(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; int n2 = y[0].length; int n1 = y[0][0].length; float[][] xy = new float[n3][n1]; for (int i2=0; i2<n2; ++i2) { get2(i2,x,xy); apply2Forward(xy,xy); acc2(i2,xy,y); } }
/** * Applies this filter in 3rd dimension in the reverse direction. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void apply3Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; int n2 = y[0].length; int n1 = y[0][0].length; float[][] xy = new float[n3][n1]; for (int i2=0; i2<n2; ++i2) { get2(i2,x,xy); apply2Reverse(xy,xy); set2(i2,xy,y); } }
/** /** * Accumulates output in 3rd dimension in the reverse direction. * This method filters the input, and adds the result to the output; it * is most useful when implementing parallel forms of recursive filters. * <p> * Input and output arrays may be the same array, but must be * regular and have equal lengths. * @param x the input array. * @param y the output array. */ public void accumulate3Reverse(float[][][] x, float[][][] y) { checkArrays(x,y); int n3 = y.length; int n2 = y[0].length; int n1 = y[0][0].length; float[][] xy = new float[n3][n1]; for (int i2=0; i2<n2; ++i2) { get2(i2,x,xy); apply2Reverse(xy,xy); acc2(i2,xy,y); } }