よく使う算術関数用クラス

メモ

```java:Calc

import java.util.Arrays;

/**
 * 計算ツール.
 * @author asahina_dev
 *
 */
public final class Calc {

	/**
	 * 配列で渡された数値の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int sum(int... array) {
		int ret = 0;
		for (int i : array) {
			ret += i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long sum(long... array) {
		long ret = 0;
		for (long i : array) {
			ret += i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float sum(float... array) {
		float ret = 0f;
		for (float i : array) {
			ret += i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double sum(double... array) {
		double ret = 0d;
		for (double i : array) {
			ret += i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の減算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int subtraction(int... array) {
		int ret = array[0];
		for (int i : Arrays.copyOfRange(array, 1, array.length)) {
			ret -= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の減算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long subtraction(long... array) {
		long ret = array[0];
		for (long i : Arrays.copyOfRange(array, 1, array.length)) {
			ret -= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の減算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float subtraction(float... array) {
		float ret = array[0];
		for (float i : Arrays.copyOfRange(array, 1, array.length)) {
			ret -= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の減算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double subtraction(double... array) {
		double ret = array[0];
		for (double i : Arrays.copyOfRange(array, 1, array.length)) {
			ret -= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の除算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int division(int... array) {
		int ret = array[0];
		for (int i : Arrays.copyOfRange(array, 1, array.length)) {
			ret /= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の除算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long division(long... array) {
		long ret = array[0];
		for (long i : Arrays.copyOfRange(array, 1, array.length)) {
			ret /= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の除算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float division(float... array) {
		float ret = array[0];
		for (float i : Arrays.copyOfRange(array, 1, array.length)) {
			ret /= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の除算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double division(double... array) {
		double ret = array[0];
		for (double i : Arrays.copyOfRange(array, 1, array.length)) {
			ret /= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の乗算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int multiplication(int... array) {
		int ret = array[0];
		for (int i : Arrays.copyOfRange(array, 1, array.length)) {
			ret *= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の乗算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long multiplication(long... array) {
		long ret = array[0];
		for (long i : Arrays.copyOfRange(array, 1, array.length)) {
			ret *= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の乗算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float multiplication(float... array) {
		float ret = array[0];
		for (float i : Arrays.copyOfRange(array, 1, array.length)) {
			ret *= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の乗算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double multiplication(double... array) {
		double ret = array[0];
		for (double i : Arrays.copyOfRange(array, 1, array.length)) {
			ret *= i;
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の平均の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double average(int... array) {
		double ret = (double) sum(array) / (double) array.length;
		return ret;
	}

	/**
	 * 配列で渡された数値の平均の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double average(long... array) {
		double ret = (double) sum(array) / (double) array.length;
		return ret;
	}

	/**
	 * 配列で渡された数値の平均の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double average(float... array) {
		double ret = (double) sum(array) / (double) array.length;
		return ret;
	}

	/**
	 * 配列で渡された数値の平均の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double average(double... array) {
		double ret = sum(array) / array.length;
		return ret;
	}

	/**
	 * 配列で渡された数値の最大値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int max(int... array) {
		int[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[array.length - 1];
	}

	/**
	 * 配列で渡された数値の最大値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long max(long... array) {
		long[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[array.length - 1];
	}

	/**
	 * 配列で渡された数値の最大値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float max(float... array) {
		float[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[array.length - 1];
	}

	/**
	 * 配列で渡された数値の最大値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double max(double... array) {
		double[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[array.length - 1];
	}

	/**
	 * 配列で渡された数値の最小値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static int min(int... array) {
		int[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[0];
	}

	/**
	 * 配列で渡された数値の最小値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static long min(long... array) {
		long[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[0];
	}

	/**
	 * 配列で渡された数値の最小値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static float min(float... array) {
		float[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[0];
	}

	/**
	 * 配列で渡された数値の最小値の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double min(double... array) {
		double[] _array = Arrays.copyOf(array, array.length);
		Arrays.sort(_array);
		return _array[0];
	}

	/**
	 * 配列で渡された数値の分散の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double variance(int... array) {
		double ret = 0;
		for (int i : array) {
			ret += Math.pow(i - average(array), 2);
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の分散の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double variance(long... array) {
		double ret = 0;
		for (long i : array) {
			ret += Math.pow(i - average(array), 2);
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の分散の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double variance(float... array) {
		double ret = 0;
		for (float i : array) {
			ret += Math.pow(i - average(array), 2);
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の分散の加算結果の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double variance(double... array) {
		double ret = 0d;
		for (double i : array) {
			ret += Math.pow(i - average(array), 2);
		}
		return ret;
	}

	/**
	 * 配列で渡された数値の標準偏差の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double standardDeviation(int... array) {
		double ret = Math.pow(variance(array), 0.5);
		return ret;
	}

	/**
	 * 配列で渡された数値の標準偏差の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double standardDeviation(long... array) {
		double ret = Math.pow(variance(array), 0.5);
		return ret;
	}

	/**
	 * 配列で渡された数値の標準偏差の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double standardDeviation(float... array) {
		double ret = Math.pow(variance(array), 0.5);
		return ret;
	}

	/**
	 * 配列で渡された数値の標準偏差の算出を行う。
	 * @param array 数値配列
	 * @return 計算結果
	 */
	public static double standardDeviation(double... array) {
		double ret = Math.pow(variance(array), 0.5);
		return ret;
	}

	/**
	 * 不可視のコンストラクタ
	 */
	Calc() {
		// nop
	}

}
```