matlab部分函數，java實現

matlab是一個強大的數學軟件，其中實現了好多的數學函數，我們使用時直接調用即可。但java中有些方法需要自己去實現。
首先來看一下matlab中一些函數。
1.sign函數

A = [1,-2,6,0];
B = sign(A);

運行結果是
sign函數

2.兩個數組相加

A = [1,2,3,4];
B= [4,5,6,7];
C = A+B;

運行結果是
數組相加

3.獲取一個數組當中一段區(qū)間元素

A = [1,2,3,4,5,6,7];
C = A(2:5);

運行結果：
截取數組區(qū)間元素

4.數組元素和

A = [1,2,3,4];
B = [2,3,4,5];
C = A+B;

運行結果：
數組元素和

5.兩個數組相減

A = [1,2,3,4];
B = [2,3,4,5];
C = B-A;

運行結果：
數組元素差

6.一個數減一個數組，生成新的數組

A = [1,2,3,4];
C = 5-A;

運行結果：
一個數減數組

7.一個數組每個元素乘以一個數

A = [1,2,3,4];
C = 5.*A;

運行結果：
一個數乘以數組

8.一個數除以一個數組

A = [1,2,3,4];
C = 5./A;

運行結果：
一個數除以數組

9.數組平方和

A = [1,2,3,4];
C = sum(A.^2);

運行結果：
數組平方和

10.獲取一個數組中最小值

A = [1,2,3,4];
C = min(A);

運行結果：
數組最小值

11.獲取一個數組中最小值下標

A = [1,-1,3,4];
[C,index] = min(A);

運行結果：
最小值下標

12.生成一個數組

t = 0:0.2:1;

運行結果：
生成一個數組

13.初始化數組

A = zeros(1,5);

運行結果：
初始化數組

14.數組平均值

A=[2,3,5,6];
b= mean(A);

運行結果：
數組平均值

15.產生一個正態(tài)分布的隨機數

A = randn(5);

運行結果：
正態(tài)分布隨機數

16.連接數組，生成一個新的數組

A = [1,2,3,4,5];
B = zeros(1,5);
C = [B,A,B];

運行結果：
數組連接

java實現工具類


/**
 * matlab中有些函數的工具類
 */
public class MathUtils {

    /**
     * 對應matlab中sign
     * @param num
     * @return
     */
    public static int sign(float num){
        return num == 0?0:(num > 0?1:-1);
    }

    /**
     * 對應matlab中sign
     * @param num
     * @return
     */
    public static int sign(double num){
        return num == 0?0:(num > 0?1:-1);
    }

    /**
     * 對應matlab中sign
     * @param num
     * @return
     */
    public static int sign(int num){
        return num == 0?0:(num > 0?1:-1);
    }

    /**
     * 對應matlab中sign
     * @param array
     * @return
     */
    public static int[] sign(int[] array){
        int[] result = new int[array.length];

        for (int i = 0;i < array.length;i++) {
            result[i] = array[i] == 0?0:(array[i] > 0?1:-1);
        }

        return result;
    }

    /**
     * 對應matlab中sign
     * @param array
     * @return
     */
    public static double[] sign(double[] array){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++) {
            result[i] = array[i] == 0?0:(array[i] > 0?1:-1);
        }

        return result;
    }

    /**
     * 兩個數組相加
     * @param array1
     * @param array2
     * @return
     */
    public static int[] arraySum(int[] array1,int[] array2){
        int[] result = new int[array1.length > array2.length?array1.length:array2.length];

        for (int i = 0;i < result.length;i++){
            if (i < array1.length && i < array2.length){
                result[i] = array1[i] + array2[i];
            }else {
                result[i] = i < array1.length?array1[i]:array2[i];
            }
        }
        return result;
    }

    /**
     * 兩個數組相加
     * @param array1
     * @param array2
     * @return
     */
    public static double[] arraySum(double[] array1,double[] array2){
        double[] result = new double[array1.length > array2.length?array1.length:array2.length];

        for (int i = 0;i < result.length;i++){
            if (i < array1.length && i < array2.length){
                result[i] = array1[i] + array2[i];
            }else {
                result[i] = i < array1.length?array1[i]:array2[i];
            }
        }
        return result;
    }

    /**
     * 兩個數組相加
     * @param array1
     * @param array2
     * @return
     */
    public static float[] arraySum(float[] array1,float[] array2){
        float[] result = new float[array1.length > array2.length?array1.length:array2.length];

        for (int i = 0;i < result.length;i++){
            if (i < array1.length && i < array2.length){
                result[i] = array1[i] + array2[i];
            }else {
                result[i] = i < array1.length?array1[i]:array2[i];
            }
        }
        return result;
    }

    /**
     * 數組一定區(qū)間元素和
     * @param array 目標數組
     * @param start 開始位置
     * @param end   結束位置
     * @return
     */
    public static double arraySingleSumRange(double[] array,int start,int end){
        double result = 0;
        for (int i = start;i < end;i++){
            result += array[i];
        }
        return result;
    }

    /**
     * 數組元素和
     * @param array
     * @return
     */
    public static double arraySingleSum(double[] array){
        double result = 0;
        for (int i = 0;i < array.length;i++){
            result += array[i];
        }
        return result;
    }

    /**
     * 數組元素和
     * @param array
     * @return
     */
    public static int arraySingleSum(int[] array){
        int result = 0;
        for (int i = 0;i < array.length;i++){
            result += array[i];
        }
        return result;
    }

    /**
     * 兩個數組相減
     * @param array1
     * @param array2
     * @return array1-array2
     */
    public static int[] arraySub(int[] array1,int[] array2){
        int[] result = new int[array1.length > array2.length?array1.length:array2.length];

        for (int i = 0;i < result.length;i++){
            if (i < array1.length && i < array2.length){
                result[i] = array1[i] - array2[i];
            }else {
                result[i] = i < array1.length?array1[i]:-array2[i];
            }
        }
        return result;
    }

    /**
     * 兩個數組相減
     * @param array1
     * @param array2
     * @return array1-array2
     */
    public static double[] arraySub(double[] array1,double[] array2){
        double[] result = new double[array1.length > array2.length?array1.length:array2.length];

        for (int i = 0;i < result.length;i++){
            if (i < array1.length && i < array2.length){
                result[i] = array1[i] - array2[i];
            }else {
                result[i] = i < array1.length?array1[i]:-array2[i];
            }
        }
        return result;
    }

    /**
     * 兩個數組相減
     * @param num
     * @param array
     * @return num-array2
     */
    public static double[] arraySub(int num,double[] array){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = num-array[i];
        }
        return result;
    }

    /**
     * 兩個數組相減
     * @param num
     * @param array
     * @return num-array2
     */
    public static double[] arraySubAbs(double num,double[] array){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = Math.abs(num-array[i]);
        }
        return result;
    }

    /**
     * 單個數組絕對值
     * @param array
     * @return array
     */
    public static double[] arraySingleAbs(double[] array){
        double[] result = new double[array.length];
        for (int i = 0;i < array.length;i++){
            result[i] = Math.abs(array[i]);
        }
        return result;
    }

    /**
     * 數組乘法后求和
     * @param array1
     * @param array2
     * @return
     */
    public static double arrayMultipleSum(double[] array1,double[] array2){
        double result = 0;
        if (array1.length != array2.length){
            return result;
        }
        for (int i = 0;i < array1.length;i++){
            result += array1[i]*array2[i];
        }
        return result;
    }

    /**
     * 數組乘法
     * @param num
     * @param array
     * @return
     */
    public static float[] arrayMultiple(float[] array,int num){
        float[] result = new float[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = array[i]*num;
        }

        return result;
    }

    /**
     * 數組乘法
     * @param num
     * @param array
     * @return
     */
    public static double[] arrayMultiple(double[] array,double num){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = array[i]*num;
        }

        return result;
    }

    /**
     * 數組乘法
     * @param num
     * @param array
     * @return
     */
    public static float[] arrayMultiple(float[] array,double num){
        float[] result = new float[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = (float) (array[i]*num);
        }

        return result;
    }


    /**
     * 數組乘法
     * @param num
     * @param array
     * @return
     */
    public static int[] arrayMultiple(int[] array,int num){
        int[] result = new int[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = array[i]*num;
        }

        return result;
    }

    /**
     * 數組除法
     * @param num
     * @param array
     * @return
     */
    public static double[] arrayDivide(int num,int[] array){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = num*1.0/array[i];
        }

        return result;
    }
    /**
     * 數組除法
     * 這個方法是如果array中存儲的是別的數組下標，matlab中數組是以1為起始點的，而java中是以0開始
     * @param num
     * @param array
     * @return
     */
    public static double[] arrayDividePos(int num,int[] array){
        double[] result = new double[array.length];

        for (int i = 0;i < array.length;i++){
            result[i] = num*1.0/(array[i]+1);
        }

        return result;
    }


    /**
     * 一個數組平方和
     * @param array
     * @return array1-array2
     */
    public static double arraySquareSum(double[] array){
        double result = 0;
        for (int i = 0;i < array.length;i++){
            result+=array[i]*array[i];
        }
        return result;
    }


    /**
     * 一個數組中的最小值
     * @param array
     * @return
     */
    public static int arrayMin(int[] array){
        int result = array[0];
        for (int num:array) {
            if (num < result){
                result = num;
            }
        }
        return result;
    }

    /**
     * 一個數組中的最小值
     * @param array
     * @return
     */
    public static double arrayMin(double[] array){
        double result = array[0];
        for (double num:array) {
            if (num < result){
                result = num;
            }
        }
        return result;
    }

    /**
     * 一個數組中的最小值的位置
     * @param array
     * @return
     */
    public static int arrayIndexMin(int[] array){
        int index = 0;
        int result = array[0];
        for (int i= 0;i <array.length;i++) {
            if (array[i] < result){
                result = array[i];
                index = i;
            }
        }
        return index;
    }

    /**
     * 一個數組中的最小值的位置
     * @param array
     * @return
     */
    public static int arrayIndexMin(double[] array){
        int index = 0;
        double result = array[0];
        for (int i= 0;i <array.length;i++) {
            if (array[i] < result){
                result = array[i];
                index = i;
            }
        }
        return index;
    }

    /**
     * 生成一個數組
     * @param start
     * @param step
     * @param end
     * @return
     */
    public static double[] createArray(double start,double step,double end){
        int length = (int) ((end-start)/step);
        if (length*step != end-start){
            length += 1;
        }
        double[] result = new double[length];

        for (int i = 0;i < result.length;i++){
            result[i] = start+step*i;
        }
        return result;
    }

    /**
     * 獲取一定范圍內的數組
     * @param start
     * @param end
     * @return
     */
    public static double[] rangeArray(double[] array,int start,int end){
        double[] newArray = new double[end-start];
        for (int i = start;i < end;i++){
            newArray[i-start] = array[i];
        }
        return newArray;
    }

    /**
     * 初始化數組
     * @return
     */
    public static void initArray(int[] array){
        for (int i = 0;i < array.length;i++){
            array[i] = 0;
        }
    }

    /**
     * 初始化數組
     * @return
     */
    public static void initArray(double[] array){
        for (int i = 0;i < array.length;i++){
            array[i] = 0;
        }
    }

    /**
     * 初始化數組
     * @return
     */
    public static void initArray(float[] array){
        for (int i = 0;i < array.length;i++){
            array[i] = 0;
        }
    }

    /**
     * 初始化數組
     * @return
     */
    public static void initArray(double[] array,int start,int end){
        for (int i = start;i < end;i++){
            array[i] = 0;
        }
    }

    /**
     * 初始化數組
     * @return
     */
    public static void initArray(double[] array,int start,int end,double defaultValue){
        for (int i = start;i < end;i++){
            array[i] = defaultValue;
        }
    }

    /**
     * 求數組平均值
     * @return
     */
    public static double arrayAverage(double[] array){
        double total = 0;
        for (int i = 0;i < array.length;i++){
            total += array[i];
        }

        return total/array.length;
    }

    /**
     * 求數組平均值
     * @return
     */
    public static float arrayAverage(float[] array){
        double total = 0;
        for (int i = 0;i < array.length;i++){
            total += array[i];
        }

        return (float) (total/array.length);
    }

    /**
     * 根據起始位置，并且步長生成一個數組
     * @param start
     * @param step
     * @param end
     * @return
     */
    public static float[] initArrayByStep(float start,float step,float end){
        int length = (int) Math.floor(MathUtils.divide((float) (end-start),step))+1;
        float[] result = new float[length];
        for (int i = 0;i < result.length;i++){
            result[i] = start+i*step;
        }
        return result;
    }

    /**
     * 根據起始位置，并且步長生成一個數組
     * @param start
     * @param step
     * @param end
     * @return
     */
    public static float[] initArrayByStepF(float start,float step,float end){
        int length = (int) Math.floor((end-start)/step)+1;
        float[] result = new float[length];
        for (int i = 0;i < result.length;i++){
            result[i] = start+i*step;
        }
        return result;
    }

    /**
     * 產生一個正態(tài)分布的隨機數
     * @return
     */
    public static float randomGauss(Random random){
        return (float) random.nextGaussian();
    }

    /**
     * 兩個float數相除
     * @param num1
     * @param num2
     * @return
     */
    public static float divide(float num1,float num2){
        BigDecimal decimal1 = new BigDecimal(String.valueOf(num1));
        BigDecimal decimal2 = new BigDecimal(String.valueOf(num2));
        return decimal1.divide(decimal2,BigDecimal.ROUND_HALF_UP).floatValue();
    }

    /**
     * 連接數組，生成一個新的數組
     * @param arrays
     * @return
     */
    public static float[] concatArray(float[]... arrays){
        int length = 0;
        for (int i = 0;i < arrays.length;i++){
            length += arrays[i].length;
        }

        float[] array = new float[length];
        int start = 0;
        for (int i = 0;i < arrays.length;i++){
            float[] tempArr = arrays[i];
            for (int j = 0;j < tempArr.length;j++){
                array[start+j] = tempArr[j];
            }
            start += tempArr.length;
        }

        return array;
    }

}
最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
【社區(qū)內容提示】社區(qū)部分內容疑似由AI輔助生成，瀏覽時請結合常識與多方信息審慎甄別。
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發(fā)布，文章內容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務。

相關閱讀更多精彩內容

友情鏈接更多精彩內容