Android 算法

1.均方根

	/**
     *  RMS均方根：
     *  所有数值，先将每个数值平方，然后将平方后的所有数值求和，再除以总体大小得到均值，再将均值开平方得到均方根
     */
    public static double meanRoot(double[] in){
        double sum = 0;
        for (double v : in) {
            sum = Math.pow(v, 2) + sum;     // Math.pow 平方
        }
        return Math.sqrt(sum / in.length); // Math.sqrt 开更
    }

2.算术平均数

	/**
     * 均值/算术平均数
     * 数组中所有数相加，总和除以数组长度
     */
    public static double mean(double[] in) {
        double sum = 0;
        for (double v : in) {
            sum = sum + v;
        }
        return sum / in.length;
    }

3.标准差

	/**
     *  标准差
     *  先求数组的均值，然后将数组中的每个值先减去均值，在开平方，然后累加得到总和， 
     *  然后将总和在除以数组长度得到均值，最后将将均值开根
     */
    public static double standardDeviation(double[] in) {
        double t_mean = mean(in);
        double t_sumPerPow = 0;
        for (int i = 0; i < in.length; i++) {
            t_sumPerPow = Math.pow(in[i] - t_mean, 2) + t_sumPerPow;    // Math.pow 平方
        }
        return Math.sqrt(t_sumPerPow / (in.length - 1));
    }

4.偏度值

	/**
     *  计算偏度值
     *  先求数组均值， 然后将数组中的每个值先减去均值，在开3次方，然后累加得到总和，
     *  然后将总和在除以数组长度
     */
    public static double skewness(double[] in) {
        double t_mean = mean(in);   // 得到均值
        double s_mean = 0;
        for (double v : in) {       // 每个数减去均值后的3次方。统计和。
            s_mean = Math.pow((v - t_mean), 3) + s_mean;
        }
        return s_mean/in.length;    // 返回 s_mean 的均值
    }

5.峰度值

	/**
     * 6
     * 计算峰度值
     * 先求数组均值， 然后将数组中的每个值先减去均值，在开4次方，然后累加得到总和，
     * 然后将总和在除以数组长度得平均值，然后平均值减去3
     */
    public static double kurtosis(double[] in) {
        double t_mean = mean(in);   // 得到均值
        double s_mean = 0;
        for (double v : in) {       // 每个数减去均值后的4次方。统计和。
            s_mean = Math.pow((v - t_mean), 4) + s_mean;
        }
        return s_mean/in.length - 3;    // 返回 s_mean 的均值减去 3
    }

6.过零率

	/**
     * 计算过零率
     * 过零率：所有数字，两两相乘后的值是否小于0，小于则累加，即得到过零率值
     */
    public static double zcr(double[] in){
        double zcr = 0;
        for (int i = 1; i < in.length; i++){
            if (in[i - 1] * in[i] < 0) {
                zcr++;
            }
        }
        return zcr;
    }

7.统计斜率符号变化数

	/**
     * 统计斜率符号变化数
     * 将数组中的值两两相减得到新的数组，新的数组中所有数，两两相乘后的值是否小于0，小于则累加，
     */
    public static double slope_sign_change(double[] in){
        double[] out = new double[in.length -1 ];
        for (int i = 1; i < in.length; i++){
            out[i - 1] = in[i] - in[i-1];
        }
        double ssc = 0;
        for (int i = 1; i < out.length; i++){
            if ((out[i - 1] * out[i]) < 0) {
                ssc++;
            }
        }
        return ssc;
    }

8.斜方差

	/**
     *  斜方差（为无偏，即分母为n-1，而不是n）
     *  要求：两数组长度相等
     *  分别求x和y两个数组的均值mx和my,然后将两个数组对应下标的值各自减去各自数组的均值后在相乘，
     *  在累加，最后除以减一后的数组长度
     */
    public static double cov(double[] x, double[] y){
      double x_mean = mean(x);
      double y_mean = mean(y);
      double sum = 0;
      for (int i = 0; i < x.length; i++){
          sum = (x[i] - x_mean) * (y[i] - y_mean) + sum;
      }
      return sum / (x.length - 1);
    }

9.两数组的相关系数

	/**
     * 通过斜方差做相关系数
     * 分别求两个数组的标准差，然后在求两个数据的协方差值，在将协方差除以两个数组标准差的积
     */
    public static double cov2(double[] x, double[] y){
        double x_standardDeviation = standardDeviation(x);
        double y_standardDeviation = standardDeviation(y);
        double cov = cov(x, y);
        return cov / (x_standardDeviation * y_standardDeviation);
    }

10.计算能量

	/**
     * 计算能量
     * 公式：
     * 1. 单个复数的求模，  求模的公式： 实数的平方 加上 虚数的平方 和进行开根，代号ads   
     * 复数a+bi,则它的模为a^2+b^2的算术平方根
     * 2. 求 ads平方的总和
     * @param fft   快速傅里叶变换的数组， 偶数为复数的实数， 奇数为复数的虚数
     */
    public static double energy(double[] fft){
        double sum = 0;
        for (int i = 0; i < fft.length; i++){
            if (i % 2 == 0){
                double ads = Math.sqrt(Math.pow(fft[i], 2) + Math.pow(fft[i + 1], 2));
                sum = Math.pow(ads, 2) + sum;
            }
        }
        return sum;
    }

11.计算谱熵

	/**
     *  计算谱熵
     * @param fft       快速傅里叶变换的值取1~251频点
     * @param sumM      能量值
     */
    public static double getOri(double[] fft, double sumM){
        double[] P_Ori = new double[fft.length / 2];
        double[] P_Ori_log2 = new double[fft.length / 2];
        int qi = 0;
        for (int i = 0; i < fft.length; i++){
            if (i % 2 == 0){
                double ads = Math.sqrt(Math.pow(fft[i], 2) + Math.pow(fft[i + 1], 2));
                double qri = Math.pow(ads, 2) / sumM;
                P_Ori[qi] = qri;
                P_Ori_log2[qi] = log2(qri);
                qi++;
            }
        }
        double sum = 0;
        for (int i = 0; i < P_Ori.length; i++){
            sum = P_Ori[i] * P_Ori_log2[i] + sum;
        }
        return sum * -1;    // 取反
    }

12.快速傅里叶变化和SVM 使用的是jar包，https://download.csdn.net/download/m0_37039192/18474852

	/**
     * 快速傅里叶变化去特征值用法
     * 快速傅里叶变化使用的参数为复数，即我们传入的数组参数需要将其设置为复数格式
     * 数组下标 偶数为复数的实数， 奇数为复数的虚数
     * 偶数下标为放置实际数据，奇数下标为默认为0.0
     */
	  DoubleFFT_1D fft = new DoubleFFT_1D(ax_value.length/2);
	  fft.complexForward(ax_value);

	/**
     * SVM用法
     * 先加载模型
     */
     // 加载模型，Android使用资源文件加载
	  InputStreamReader inputReader = new InputStreamReader(context.getResources().getAssets().open("ClimbModel"));
      BufferedReader bufReader = new BufferedReader(inputReader);
      model = svm.svm_load_model(bufReader);
      //加载模型，Android使用路径加载
//    model = svm.svm_load_model("/storage/emulated/0/Helmet_v31_l/data/ClimbModel");
	 
	 
     // train_data_s_coff数组 为统计算法保存的特征数据
	 // svm_node数组 为SVM参数使用的类型格式
 	  svm_node[] x = new svm_node[train_data_s_coff.length];
        for(int j = 0; j < train_data_s_coff.length; j++) {
            x[j] = new svm_node();
            x[j].index = j + 1;
            x[j].value = train_data_s_coff[j];
        }
        // 导入模型和特征数据，通过SVM得出结论
        double predict_label = svm.svm_predict(model,x);