Adds to an array w, a times v where a is a scalar.

Description

Demo Code


//package com.java2s;

public class Main {
    public static void main(String[] argv) throws Exception {
        double[] w = new double[] { 34.45, 35.45, 36.67, 37.78, 37.0000,
                37.1234, 67.2344, 68.34534, 69.87700 };
        double a = 2.45678;
        System.out.println(java.util.Arrays.toString(add(w, a)));
    }//from   w w w  . ja  v a 2s .c  o m

    /**
     * Adds to an array w, a times v where a is a scalar.
     * Since v can be smaller then w, we must specified the position at which v will be added.
     *
     * @param a scalar.
     * @param p position.
     */
    public static double[] add(double[] w, double a, double[] v, int p) {
        if (v.length > w.length) {
            throw new IllegalArgumentException(
                    "Second array must be shorter or equal to the first one : "
                            + w.length + ", " + v.length);
        }
        double[] ans = copy(w);
        for (int k = p; k < p + v.length; k++) {
            ans[k] += a * v[k - p];
        }
        return (ans);
    }

    /**
     * Adds a scalar to every element in the array.
     */
    public static double[] add(double[] w, double a) {
        double[] ans = copy(w);
        for (int k = 0; k < ans.length; k++) {
            ans[k] += a;
        }
        return (ans);
    }

    /**
     * Adds the two arrays together (componentwise).
     *
     * @throws IllegalArgumentException if the
     *                                  two arrays don't have the same length.
     */
    public static double[] add(double[] a, double[] b) {
        if (a.length != b.length) {
            throw new IllegalArgumentException(
                    "To add two arrays, they must have the same length : "
                            + a.length + ", " + b.length);
        }
        double[] ans = copy(a);
        for (int i = 0; i < a.length; i++) {
            ans[i] += b[i];
        }
        return (ans);
    }

    /**
     * Adds to an array w, a times v where a is a scalar.
     * Since v can be smaller then w, we must specified the position at which v will be added.
     *
     * @param a scalar.
     * @param p position.
     * @param w longer array.
     * @param v shorter array.
     * @throws IllegalArgumentException if the second array
     *                                  is not shorter than the first one.
     */
    public static int[] add(int[] w, double a, int[] v, int p) {
        if (v.length > w.length) {
            throw new IllegalArgumentException(
                    "Second array must be shorter or equal to the first one : "
                            + w.length + ", " + v.length);
        }
        int[] ans = copy(w);
        for (int k = p; k < p + v.length; k++) {
            ans[k] += a * v[k - p];
        }
        return (ans);
    }

    /**
     * Adds a scalar to every element in the array.
     */
    public static int[] add(int[] w, int a) {
        int[] ans = copy(w);
        for (int k = 0; k < ans.length; k++) {
            ans[k] += a;
        }
        return (ans);
    }

    /**
     * Adds the two arrays together (componentwise).
     *
     * @throws IllegalArgumentException if the
     *                                  two arrays don't have the same length.
     */
    public static int[] add(int[] a, int[] b) {
        if (a.length != b.length) {
            throw new IllegalArgumentException(
                    "To add two arrays, they must have the same length : "
                            + a.length + ", " + b.length);
        }
        int[] ans = copy(a);
        for (int i = 0; i < a.length; i++) {
            ans[i] += b[i];
        }
        return (ans);
    }

    /**
     * Returns a comma delimited string representing the value of the array.
     */
    public static String toString(double[] array) {

        StringBuffer buf = new StringBuffer(array.length);
        int i;
        for (i = 0; i < array.length - 1; i++) {
            buf.append(array[i]);
            buf.append(',');
        }
        buf.append(array[i]);
        return buf.toString();
    }

    /**
     * Returns a comma delimited string representing the value of the array.
     */
    public static String toString(double[][] array) {
        StringBuffer buf = new StringBuffer();
        for (int k = 0; k < array.length; k++) {
            buf.append(toString(array[k]));
            buf.append(System.getProperty("line.separator"));
        }
        return buf.toString();
    }

    /**
     * Returns a comma delimited string representing the value of the array.
     */
    public static String toString(int[] array) {
        StringBuffer buf = new StringBuffer(array.length);
        int i;
        for (i = 0; i < array.length - 1; i++) {
            buf.append(array[i]);
            buf.append(',');
        }
        buf.append(array[i]);
        return buf.toString();
    }

    /**
     * Returns a comma delimited string representing the value of the array.
     */
    public static String toString(int[][] array) {
        StringBuffer buf = new StringBuffer();
        for (int k = 0; k < array.length; k++) {
            buf.append(toString(array[k]));
            buf.append(System.getProperty("line.separator"));
        }
        return buf.toString();
    }

    /**
     * Returns a copy of the array.
     */
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
    //it even may be faster
    public static int[] copy(int[] array) {
        int[] result;
        result = new int[array.length];
        System.arraycopy(array, 0, result, 0, array.length);
        return result;
    }

    /**
     * Returns a copy of the array.
     */
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
    //it even may be faster
    public static long[] copy(long[] array) {
        long[] result;
        result = new long[array.length];
        System.arraycopy(array, 0, result, 0, array.length);
        return result;
    }

    /**
     * Returns a copy of the array.
     */
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
    //it even may be faster
    public static float[] copy(float[] array) {
        float[] result;
        result = new float[array.length];
        System.arraycopy(array, 0, result, 0, array.length);
        return result;
    }

    /**
     * Returns a copy of the array.
     */
    //a call to array.clone() may also work although this is a primitive type. I haven't checked
    //it even may be faster
    public static double[] copy(double[] array) {
        double[] result;
        result = new double[array.length];
        System.arraycopy(array, 0, result, 0, array.length);
        return result;
    }

    /**
     * Returns a copy of the array.
     */
    public static double[][] copy(double[][] v) {
        double[][] ans = new double[v.length][];
        for (int k = 0; k < v.length; k++)
            ans[k] = copy(v[k]);
        return (ans);
    }

    /**
     * Returns a copy of the array.
     */
    public static int[][] copy(int[][] v) {
        int[][] ans = new int[v.length][];
        for (int k = 0; k < v.length; k++)
            ans[k] = copy(v[k]);
        return (ans);
    }
}
Adds to an array w, a times v where a is a scalar. - Java Collection Framework

Description

Demo Code

Related Tutorials
