C# 实现GM(1,1)灰色系统模型算法

编程撞南墙

于 2023-06-08 12:05:04 发布

阅读量245

点赞数 2

分类专栏： C# 文章标签：算法 c# java

本文链接：https://blog.csdn.net/u011419512/article/details/131104849

版权

C# 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

代码如下：

public class GM_1_1
    {

        private static double[] CumulativeArray(double[] originalArray)
        {
            double[] cumulativeArray = new double[originalArray.Length];
            double sum = 0.0D;
            for (int i = 0; i < cumulativeArray.Length; i++)
            {
                sum += originalArray[i];
                cumulativeArray[i] = sum;
            }
            return cumulativeArray;
        }

        private static double[] AverageArray(double[] cumulativeArray)
        {
            double[] averageArray = new double[cumulativeArray.Length - 1];
            for (int i = 0; i < averageArray.Length; i++)
            {
                averageArray[i] = (cumulativeArray[i] + cumulativeArray[i + 1]) / 2.0D;
            }
            return averageArray;
        }

        private static double[,] MatrixB(double[] averageArray)
        {
            int n = averageArray.Length;
            double[,] matrixB = new double[n, 2];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < 2; j++)
                {
                    if (j == 1)
                        matrixB[i, j] = 1.0D;
                    else
                    {
                        matrixB[i, j] = -averageArray[i];
                    }
                }
            }
            return matrixB;
        }

        private static double[,] MatrixBT(double[,] matrixB)
        {
            int m = matrixB.GetLength(0);
            double[,] matrixBT = new double[2, m];
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    matrixBT[i, j] = matrixB[j, i];
                }
            }
            return matrixBT;
        }

        private static double[,] MatrixYn(double[] originalArray)
        {
            int n = originalArray.Length - 1;
            double[,] matrixYn = new double[n, 1];
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < 1; j++)
                {
                    matrixYn[i, j] = originalArray[i + 1];
                }
            }
            return matrixYn;
        }

        private static double[,] MatrixBxBT(double[,] matrixB, double[,] matrixBT)
        {
            int matrixBLength = matrixB.GetLength(0);
            double[,] matrixBxBT = new double[2, 2];
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 2; j++)
                {
                    for (int k = 0; k < matrixBLength; k++)
                    {
                        matrixBxBT[i, j] += matrixBT[i, k] * matrixB[k, j];
                    }
                }
            }
            return matrixBxBT;
        }

        private static double[,] InverseMatrixBxBT(double[,] matrixBxBT)
        {
            if (matrixBxBT == null)
                return null;
            double[,] inverseMatrixBxBT = new double[2, 2];
            inverseMatrixBxBT[0, 0] = 1.0D / (matrixBxBT[0, 0] * matrixBxBT[1, 1] - matrixBxBT[0, 1]
                    * matrixBxBT[1, 0]) * matrixBxBT[1, 1];
            inverseMatrixBxBT[0, 1] = 1.0D / (matrixBxBT[0, 0] * matrixBxBT[1, 1] - matrixBxBT[0, 1]
                    * matrixBxBT[1, 0]) * -matrixBxBT[0, 1];
            inverseMatrixBxBT[1, 0] = 1.0D / (matrixBxBT[0, 0] * matrixBxBT[1, 1] - matrixBxBT[0, 1]
                    * matrixBxBT[1, 0]) * -matrixBxBT[1, 0];
            inverseMatrixBxBT[1, 1] = 1.0D / (matrixBxBT[0, 0] * matrixBxBT[1, 1] - matrixBxBT[0, 1]
                    * matrixBxBT[1, 0]) * matrixBxBT[0, 0];
            return inverseMatrixBxBT;
        }

        private static double[,] InverseMatrixBxBT_xBT(
                double[,] inverseMatrixBxBT, double[,] matrixBT)
        {
            if (inverseMatrixBxBT == null || matrixBT == null)
                return null;
            double[,] inverseMatrixBxBT_xBT = new double[2, matrixBT.GetLength(1)];
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < matrixBT.GetLength(1); j++)
                {
                    for (int k = 0; k < 2; k++)
                    {
                        inverseMatrixBxBT_xBT[i, j] += inverseMatrixBxBT[i, k]
                                * matrixBT[k, j];
                    }
                }
            }
            return inverseMatrixBxBT_xBT;
        }

        private static double[,] InverseMatrixBxBT_xBTxYN(
                double[,] inverseMatrixBxBT_xBT, double[,] matrixYN)
        {
            if (inverseMatrixBxBT_xBT == null || matrixYN == null)
                return null;
            double[,] inverseMatrixBxBT_xBTxYN = new double[2, 1];
            for (int i = 0; i < 2; i++)
            {
                for (int j = 0; j < 1; j++)
                {
                    for (int k = 0; k < matrixYN.GetLength(0); k++)
                    {
                        inverseMatrixBxBT_xBTxYN[i, j] += inverseMatrixBxBT_xBT[i, k]
                                * matrixYN[k, j];
                    }
                }
            }
            return inverseMatrixBxBT_xBTxYN;
        }

        private static double[,] InverseMatrixBxBT_xBTxYN(double[] originalArray)
        {
            double[,] matrixYn = MatrixYn(originalArray);
            double[] cumulativeArray = CumulativeArray(originalArray);
            double[] averageArray = AverageArray(cumulativeArray);
            double[,] matrixB = MatrixB(averageArray);
            double[,] matrixBT = MatrixBT(matrixB);
            double[,] matrixBxBT = MatrixBxBT(matrixB, matrixBT);
            double[,] inverseMatrixBxBT = InverseMatrixBxBT(matrixBxBT);
            double[,] inverseMatrixBxBT_xBT = InverseMatrixBxBT_xBT(
                    inverseMatrixBxBT, matrixBT);
            double[,] inverseMatrixBxBT_xBTxYN = InverseMatrixBxBT_xBTxYN(
                    inverseMatrixBxBT_xBT, matrixYn);
            return inverseMatrixBxBT_xBTxYN;
        }

        public static double GetPredictiveValue(double[] originalArray, int num)
        {
            if (originalArray == null || originalArray.Length < 3)
                return 0.0D;
            double[,] inverseMatrixBxBT_xBTxYN = InverseMatrixBxBT_xBTxYN(originalArray);
            double a = inverseMatrixBxBT_xBTxYN[0, 0];
            double u = inverseMatrixBxBT_xBTxYN[1, 0];
            double au = 0.0D;
            if (a != 0.0D)
            {
                au = u / a;
            }
            return (originalArray[0] - au)
                    * (Math.Exp(-a * (num - 1)) - Math.Exp(-a * (num - 2)));
        }
    }

引自 zwbonline1112

Java实现GM(1,1)灰色系统模型算法