gridmodel.java

用于建立黑色系统模型

package com.lee.test.GridModel;
import java.io.*;

import java.util.*;

/**
 * 类的简单介绍：
 * 本类包含了灰色系统模型的构造函数，以及在灰色系统建模过程中常用的一些方法的声明与实现
 */
public class GridModel {
	
	/**
	 * 姓名：李涛
	 * 班级：系统建模与仿真（1）班
	 * 学号：S08102085
	 * 邮箱：[e-mail]
	 */
	
	//模型估计值序列中数据的个数，包含初始序列的估计值在内。
	private static final int PREDICTIONNUMBER = 9 ;
	
	//相对精度界值
	private static final double RELATIVERESIDUAL = 0.01 ;
	
	//灰色关联度界值
	private static final double ABSOLTETCORRELATION = 0.9 ;
	
	private double[] initArray = null ;
	
	/**
	 * 声明一个参数为空的构造函数：
	 */
	public GridModel(){
		
	}
	
	/**
	 * 声明一个参数为初始化数组的构造函数：
	 */
	public GridModel(double[] array){
		initArray = array.clone();
	}
		
	public  void initDeal(double[]  initArray){
		
		/**
		 * 初始值处理：
		 * 输入：初始化数组initArray[0,1,...，n-1]
		 * 输出：数组initArray中每个元素都除以initArray[0]所得到的新数组
		 */
		if (initArray == null) return ;
		double temp = initArray[0];
		
		for (int i = 0 ; i < initArray.length; i++ ){
			if( initArray[0] == 0 ) return ; 
			initArray[i] /= temp;
		}
		
	}

	public  double[] avgDeal(double[] avgArray){
		/**
		 * 均值处理：
		 * 输入：数组avgArray[0,1,...，n-1]
		 * 输出：数组outputArray[0,1,...，n-1]中每个元素都除以avgArray的均值所得到的新数组
		 */
		if (avgArray == null || avgArray.length == 0){
			return null ;
		}
		double temp  = avg(avgArray);
		double[] outputArray = avgArray.clone();
		
		for (int i = 0 ; i < outputArray.length; i++ ){
			if( temp == 0 ) return  null; 
			outputArray[i] /= temp;
		}
		return outputArray;
	}
	
	public  double[] avgCloseDeal(double[] avgArray){
		/**
		 * 紧邻均值处理：
		 * 输入：数组avgArray[0,1,...，n-1]
		 * 输出：数组outputArray[0,1,...，n-1]，它是对avgArray[0,1,...，n-1]中每个元素做紧邻均值生成所得到的数组
		 */
		if (avgArray == null || avgArray.length == 0){
			return null ;
		}
		double[] outputArray = avgArray.clone();
		
		for (int i = 1 ; i < outputArray.length; i++ ){
			outputArray[i] = (avgArray[i] + avgArray[i-1])/2;
		}
		show(outputArray);
		return outputArray;
	}
	
	public  double max(double[] array){
		/**
		 * 求数组元素最大值：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组array[0,1,...，n-1]中元素的最大值
		 */
		
		if (array == null ) return -1;
		double temp = array[0] ;
		for (int i = 0 ; i < array.length ; i ++){
			if (array[i] > temp ) temp = array[i];
		}
		return temp ;
	} 
	
    public  double min(double[] array){
    	/**
		 * 求数组元素最小值：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组array[0,1,...，n-1]中元素的最小值
		 */
		if (array == null) return  -1;
		
		double temp = array[0] ;
		for (int i = 0 ; i < array.length ; i ++){
			if (array[i] < temp ) temp = array[i];
		}
		
		return temp	;
	} 

    public  double avg(double[] array){
    	/**
		 * 求数组元素平均值：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组array[0,1,...，n-1]中元素的平均值
		 */
    	if (array == null) return  0 ;
		double temp = 0 ;
		for( int i = 0  ;i < array.length ; i++){
			temp += array[i];
		}
		temp = (temp / array.length);
		
		return temp ;
    }
    
    public  double sum(double[] array){
    	/**
		 * 求数组元素和：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组array[0,1,...，n-1]中元素的总和
		 */
    	if (array == null) return  0 ;
		double temp = 0 ;
		for( int i = 0  ;i < array.length ; i++){
			temp += array[i];
		}	
		return temp ;
    }
    
    public  double[] leastSquareMethod(double[] firstArray,double[] secondArray){
    	
    	/**
		 * 最小二乘法的简单实现：
		 * 输入：数组firstArray[0,1,...，n-1]，数组secondArray[0,1,...，n-1]
		 * 输出：数组coefficients[1,2],其中coefficients[1]对应a，coefficients[2]对应b
		 */
    	double[] coefficients = new double[2];
    	if (firstArray.length != secondArray.length){
    		return null ;
    	}
    	for(int i = 1 ; i < firstArray.length ; i++){
    		coefficients[0] += ((firstArray[i]-avg(firstArray))*(secondArray[i]-avg(secondArray)));
    		coefficients[1] += ((firstArray[i]-avg(firstArray))*(firstArray[i]-avg(firstArray)));
    	}
    	if (coefficients[1]!= 0){
    		
    		coefficients[0] /= coefficients[1] ;
    		coefficients[0] = -coefficients[0];
    		//根据GM(1,1)动态模型
        	coefficients[1] = avg(secondArray) + coefficients[0]*avg(firstArray);        	
    	}
    	else{
    		System.out.println("除数不可以为0.");
    		return null ;	
    	}
    	show(coefficients);
    	return coefficients ;
    }
    
	public void verticalRangeDeal(double[][] rangeArray){
		
		/**
		 * 垂直区间化处理：
		 * 输入：矩阵rangeArray[0,1,2,...,n-1][0,1,2,...,n-1]
		 * 输出：经过垂直区间化处理的矩阵rangeArray[0,1,2,...,n-1][0,1,2,...,n-1]
		 */
		
		double maxElem = 0 ; 
		double minElem = 0 ;
		if  (rangeArray == null) return ;
		//i表示列数，j表示行数
		for(int i = 0 ; i < rangeArray[0].length ; i++ ){
			maxElem = max(rangeArray[i]);
			minElem = min(rangeArray[i]);
			for(int j = 0 ; j < rangeArray.length ; j++){
				rangeArray[j][i] = (rangeArray[j][i] - minElem )/(maxElem- minElem);
			}
		}
	}
	
	public double[] agoSequence(double[] array){
		
		/**
		 * 累加生成器：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组outputArray[0,1,...，n-1]，outputArray[i]对应累加得到的结果
		 */
		
		if(array == null) return null; 
		double[] outputArray = new double[array.length];
		outputArray[0] = array[0];
		for(int i = 1 ;i <array.length ; i++){
			outputArray[i] = outputArray[ i-1 ] + array[i];
		}
		show(outputArray);
		return outputArray ;
	}
	
	public double[] iagoSequence(double[] array){
		
		/**
		 * 累减生成器：
		 * 输入：数组array[0,1,...，n-1]
		 * 输出：数组outputArray[0,1,...，n-1]，outputArray[i]对应累减得到的结果
		 */
			
			if(array == null) return  null; 
			double[] outputArray = new double[array.length];
			outputArray[0] = array[0];
			for(int i = array.length - 1 ;i > 0 ; i--){
				outputArray[i] = array[i]-array[i-1];
			}	
			show(outputArray);
			return outputArray ;
		}
	
	public double[] getModel(double paramA, double paramB , double[] inputArray){
		
		/**
		 * 原始序列模型计算值：
		 * 输入：最小二乘法得到系数paramA，paramB，以及数组inputArray[]
		 * 输出：数组outputArray[0,1,...，n-1]，outputArray对应原始序列模型计算值
		 */
		
		double[] outputArray = new double[inputArray.length];
		outputArray[0] = inputArray[0];
		for(int i= 1 ; i <  outputArray.length ; i++){
			outputArray[i] = (inputArray[0] - paramB/paramA)*Math.exp(-paramA*i) + paramB/paramA;
			}
		show(outputArray);
		return outputArray;
	}
	
	public  double getCorrelation(double[] firstArray, double[] secondArray){
		
		/**
		 * 拿到灰色关联度：
		 * 输入：数组firstArray[0,1,...，n-1],数组secondArray[0,1,...，n-1]
		 * 输出：数组firstArray[0,1,...，n-1]与数组secondArray[0,1,...，n-1]的灰色关联度
		 */
		
		if (firstArray == null || secondArray == null || (firstArray.length != secondArray.length)) return 0 ;
		
		double correlation = 0 ;
		int maxLength = firstArray.length ;
		//cc代表关联系数
		double[] cc = new double[maxLength] ;
		//dstinguishC代表相关系数
		double dstinguishC = 0.5 ;
		double minVal = 0 ;