transform the original response array by padding 0 at the tail

@param y
original response array
@return response array with padding 0 at tail
332346
private double[] getAugmentedResponse(double[] y) {
        double[] ret = new double[y.length + p];
        System.arraycopy(y, 0, ret, 0, y.length);
        return ret;
    }
1141396
@Override
    public double d(T[] x, T[] y) {
        if (x.length != y.length)
            throw new IllegalArgumentException(String.format("Arrays have different length: x[%d], y[%d]", x.length, y.length));

        int dist = 0;
        for (int i = 0; i < x.length; i++) {
            if (!x[i].equals(y[i]))
                dist++;
        }

        return dist;
    }
413726
function createRow(boardSizeX, y) {
    return _ramda2.default.range(0, boardSizeX).map(function (x) {
        return createCol(x, y);
    });
}
13174
public double get(int x, int y) {
    return (x == y) ? 0 : (x < y) //
        ? matrix[MatrixParadigm.triangleSize(y) + x] //
        : matrix[MatrixParadigm.triangleSize(x) + y];
  }
336173
int getRowByYWithShift(int y, int shiftEveryStep) {
        checkForInit();
        int sum = 0;
        // header offset
        int tempY = y - mHeaderColumnHeight;
        if (tempY <= sum) {
            return 0;
        }
        for (int count = mRowHeights.length, i = 0; i < count; i++) {
            int nextSum = sum + mRowHeights[i] + shiftEveryStep;

            if (tempY > sum && tempY < nextSum) {
                return i;
            } else if (tempY < nextSum) {
                return i - 1;
            }
            sum = nextSum;
        }
        return mRowHeights.length - 1;
    }
817531
public int getRow(float y) {
        int row = 0;
        y += h(padTop);
        int i = 0, n = cells.size();
        if (n == 0)
            return -1;
        if (n == 1)
            return 0;
        if (cells.get(0).widgetY < cells.get(1).widgetY) {
            // Using y-down coordinate system.
            while (i < n) {
                Cell<C, T> c = cells.get(i++);
                if (c.getIgnore())
                    continue;
                if (c.widgetY + c.computedPadTop > y)
                    break;
                if (c.endRow)
                    row++;
            }
            return row - 1;
        }
        // Using y-up coordinate system.
        while (i < n) {
            Cell<C, T> c = cells.get(i++);
            if (c.getIgnore())
                continue;
            if (c.widgetY + c.computedPadTop < y)
                break;
            if (c.endRow)
                row++;
        }
        return row;
    }
340116
public NumberExpression<Double> y() {
        if (y == null) {
            y = Expressions.numberOperation(Double.class, SpatialOps.Y, mixin);
        }
        return y;
    }
405425
@Pure
	public IntegerProperty yProperty() {
		if (this.y == null) {
			this.y = new SimpleIntegerProperty(this, MathFXAttributeNames.Y);
		}
		return this.y;
	}
930260
public static INDArray rsub(INDArray x, INDArray y, INDArray z, int... dimensions) {
        if(dimensions == null || dimensions.length == 0) {
            validateShapesNoDimCase(x,y,z);
            return Nd4j.getExecutioner().exec(new OldSubOp(x,y,z));
        }

        return Nd4j.getExecutioner().exec(new BroadcastRSubOp(x,y,z,dimensions));
    }
90662
public static BigDecimal yuan2fen(BigDecimal y) {
		if (y != null) {
			return yuan2fen(y.toString());
		} else {
			return new BigDecimal(0);
		}
	}
675246
def lessgreater(x, y):
    
    x = BigFloat._implicit_convert(x)
    y = BigFloat._implicit_convert(y)
    return mpfr.mpfr_lessgreater_p(x, y)
1320389
@Override
    public double[] transform(double[] x) {
        if (x.length != scale.length) {
            throw new IllegalArgumentException(String.format("Invalid vector size %d, expected %d", x.length, scale.length));
        }

        double[] y = copy ? new double[x.length] : x;
        for (int i = 0; i < x.length; i++) {
            y[i] = x[i] / scale[i];
        }

        return y;
    }
1281003
@Pure
	public DoubleProperty y1Property() {
		if (this.p1.y == null) {
			this.p1.y = new SimpleDoubleProperty(this, MathFXAttributeNames.Y1);
		}
		return this.p1.y;
	}
505919
public double[][] diff_yy(double matyy[][]) {
        mat3 = new double[width][height];
        double mat1, mat2;
        for (int i = 0; i < width; i++) {
            for (int j = 0; j < height; j++) {
                if (i == 0) {
                    mat1 = matyy[i][j];
                    mat2 = matyy[i + 1][j];
                } else if (i == width - 1) {
                    mat1 = matyy[i - 1][j];
                    mat2 = matyy[i][j];
                } else {
                    mat1 = matyy[i - 1][j];
                    mat2 = matyy[i + 1][j];
                }
                mat3[i][j] = (mat1 + mat2 - 2 * matyy[i][j]);
            }
        }
        return mat3;

    }
909275
def y0(self):
        
        try:
            return self._y0
        except AttributeError:
            self._y0 = Quantity(0, self.yunit)
            return self._y0
1070345
public static IntegerBinding subtractExact(final int x, final ObservableIntegerValue y) {
        return createIntegerBinding(() -> Math.subtractExact(x, y.get()), y);
    }
834463
public void set(int i, int y) {
        if (response == null) {
            throw new IllegalArgumentException("The dataset has no response values.");            
        }
        
        if (response.getType() != Attribute.Type.NOMINAL) {
            throw new IllegalArgumentException("The response variable is not nominal.");
        }
        
        if (i < 0) {
            throw new IllegalArgumentException("Invalid index: i = " + i);
        }

        int nrows = size();
        if (i >= nrows) {
            for (int k = nrows; k <= i; k++) {
                data.add(new Datum<>(new SparseArray()));
            }
        }

        get(i).y = y;
    }