Subtracts the values in the two arrays of integers element-wise. - Java Collection Framework

Description

Subtracts the values in the two arrays of integers element-wise.

Demo Code

//package com.java2s;

public class Main {
    public static void main(String[] argv) throws Exception {
        int[] a = new int[] { 34, 35, 36, 37, 37, 37, 67, 68, 69 };
        int[] b = new int[] { 34, 35, 36, 37, 37, 37, 67, 68, 69 };
        System.out.println(java.util.Arrays.toString(subtractElementwise(a,
                b)));//from  w ww .  j  a va 2s . c  om
    }

    /**
     * Subtracts the values in the two arrays of integers element-wise.
     *
     * @param a   Array of integers.
     * @param b   Array of integers.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static int[] subtractElementwise(int[] a, int[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            int[] result = new int[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two arrays of doubles element-wise.
     *
     * @param a   Array of doubles.
     * @param b   Array of doubles.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static double[] subtractElementwise(double[] a, double[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            double[] result = new double[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two arrays of longs element-wise.
     *
     * @param a   Array of longs.
     * @param b   Array of longs.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static long[] subtractElementwise(long[] a, long[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            long[] result = new long[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two arrays of floats element-wise.
     *
     * @param a   Array of floats.
     * @param b   Array of floats.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static float[] subtractElementwise(float[] a, float[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            float[] result = new float[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two arrays of bytes element-wise.
     *
     * @param a   Array of bytes.
     * @param b   Array of bytes.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static byte[] subtractElementwise(byte[] a, byte[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            byte[] result = new byte[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = (byte) (a[i] - b[i]);
            }
            return result;
        }

    }

    /**
     * Subtracts the values in an array of doubles and and array of integers
     * element-wise.
     *
     * @param a   Array of doubles.
     * @param b   Array of integers.
     * @return   Result of element-wise subtraction of arrays.
     * @throws ArithmeticException   Throws exception when the arrays differ in
     * length.
     */
    public static double[] subtractElementwise(double[] a, int[] b)
            throws ArithmeticException {

        if (a.length != b.length) {
            throw new ArithmeticException();
        } else {
            double[] result = new double[a.length];
            for (int i = 0; i < a.length; i++) {
                result[i] = a[i] - b[i];
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of doubles.
     * @param b   Matrix of doubles.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static double[][] subtractElementwise(double[][] a, double[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            double[][] result = new double[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = a[i][j] - b[i][j];
                }
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of integers.
     * @param b   Matrix of integers.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static int[][] subtractElementwise(int[][] a, int[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            int[][] result = new int[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = a[i][j] - b[i][j];
                }
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of doubles.
     * @param b   Matrix of doubles.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static float[][] subtractElementwise(float[][] a, float[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            float[][] result = new float[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = a[i][j] - b[i][j];
                }
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of doubles.
     * @param b   Matrix of doubles.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static long[][] subtractElementwise(long[][] a, long[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            long[][] result = new long[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = a[i][j] - b[i][j];
                }
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of doubles.
     * @param b   Matrix of doubles.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static byte[][] subtractElementwise(byte[][] a, byte[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            byte[][] result = new byte[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = (byte) (a[i][j] - b[i][j]);
                }
            }
            return result;
        }

    }

    /**
     * Subtracts the values in the two matrices element-wise.
     *
     * @param a   Matrix of doubles.
     * @param b   Matrix of doubles.
     * @return   Element-wise sum of the two matrices.
     * @throws ArithmeticException   Throws an exception when the two matrices are
     * not of the same size.
     */
    public static double[][] subtractElementwise(double[][] a, int[][] b)
            throws ArithmeticException {

        if (a.length != b.length || a[0].length != b[0].length) {
            throw new ArithmeticException();
        } else {
            double[][] result = new double[a.length][a[0].length];
            for (int i = 0; i < a.length; i++) {
                for (int j = 0; j < a[0].length; j++) {
                    result[i][j] = a[i][j] - b[i][j];
                }
            }
            return result;
        }

    }
}

• Previous
• Next

Related Tutorials

• Divides the values in the two arrays of integers element-wise.
• Calculate Exponentiation for all values in an array of doubles by a given exponent.
• Multiplies an array of doubles and an array of integers element-wise.
• Computes the sum of an array of doubles.
• Perform a linear search for an integer in a given array.