Пример #1
0
        public static double[] PolynomialFit(Point[] points, int degree)
        {
            int maxPower = degree * 2 + 2;

            double[] b = new double[degree + 1];
            double[,] A        = new double[degree + 1, degree + 1];
            double[,] tiPowerk = new double[points.Length, maxPower];
            double[] tPowerSum = new double[maxPower];

            double sum, xi;
            int    i, j;

            for (i = 0; i < points.Length; i++)
            {
                xi             = points[i].X;
                tiPowerk[i, 0] = sum = 1d;
                for (j = 1; j < maxPower; j++)
                {
                    tiPowerk[i, j] = sum *= xi;
                }
            }

            for (i = 0; i < maxPower; i++)
            {
                sum = 0;
                for (j = 0; j < points.Length; j++)
                {
                    sum += tiPowerk[j, i];
                }
                tPowerSum[i] = sum;
            }

            for (i = 0; i <= degree; i++)
            {
                sum = 0;
                for (j = 0; j < points.Length; j++)
                {
                    sum += points[j].Y * tiPowerk[j, i];
                }
                b[i] = sum;

                for (j = 0; j <= degree; j++)
                {
                    A[i, j] = tPowerSum[i + j];
                }
            }
            int[] indicies;
            LinearEquations.LUDecomposition(A, out indicies);
            return(LinearEquations.LUSolve(A, b, indicies));
        }
Пример #2
0
        public static double[] PolynomialClosedFit(Point[] points, int degree, int joinDegree)
        {
            int maxPower = degree * 2 + 2;

            double[] b = new double[degree + 1];
            double[,] A        = new double[degree + 1, degree + 1];
            double[,] xiPowerj = new double[points.Length, maxPower];
            double[] xPowerSum = new double[maxPower];

            double temp, xi;
            int    i, j;

            for (i = 0; i < points.Length; i++)
            {
                xi             = points[i].X;
                xiPowerj[i, 0] = temp = 1d;
                for (j = 1; j < maxPower; j++)
                {
                    xiPowerj[i, j] = temp *= xi;
                }
            }

            for (i = 0; i < maxPower; i++)
            {
                temp = 0;
                for (j = 0; j < points.Length; j++)
                {
                    temp += xiPowerj[j, i];
                }
                xPowerSum[i] = temp;
            }

            for (i = joinDegree; i <= degree; i++)
            {
                temp = 0;
                for (j = 0; j < points.Length; j++)
                {
                    temp += points[j].Y * xiPowerj[j, i];
                }
                b[i] = temp;

                for (j = 0; j <= degree; j++)
                {
                    A[i, j] = xPowerSum[i + j];
                }
            }


            int last = points.Length - 1;
            int k;

            for (i = 0; i < joinDegree; i++)
            {
                for (j = 0; j < i; j++)
                {
                    A[i, j] = 0;
                }

                for (j = i; j <= degree; j++)
                {
                    temp = 1;
                    for (k = 0; k < i; k++)
                    {
                        temp *= (j - k);
                    }
                    A[i, j] = temp * (xiPowerj[0, j - i] - xiPowerj[last, j - i]);
                }

                b[i] = 0;
            }
            int[] indicies;
            LinearEquations.LUDecomposition(A, out indicies);
            return(LinearEquations.LUSolve(A, b, indicies));
        }