C#最小二乘法进行曲线拟合及相关系数

最新推荐文章于 2024-09-29 13:43:52 发布
最新推荐文章于 2024-09-29 13:43:52 发布
阅读量1.3w 收藏 47
点赞数 9
分类专栏： C# 文章标签： 曲线拟合 最小二乘法 相关系数

两个类：

类1：


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 高斯消元法
{
    class Program
    {
        static void Main(string[] args)
        {
           /* double[,] xArray = new double[,]
            {
                
                    { 2.000000 ,-1.000000 , 3.000000,  1.000000},
                    { 4.000000 , 2.000000 , 5.000000,  4.000000},
                    { 1.000000 , 2.000000 , 0.000000 , 7.000000}
            };*/

            System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
            double[] y = new double[] { 29152.3, 47025.3, 86852.3, 132450.6, 200302.3, 284688.1, 396988.3 };
            double[] x = new double[] { 1.24, 2.37, 5.12, 8.12, 12.19, 17.97, 24.99 };

           // double[,] xArray;
            double[] ratio;
            double[] yy = new double[y.Length];

            Console.WriteLine("一次拟合：");
            sw.Start();
            ratio = FittingFunct.Linear(y, x);
            sw.Stop();

            foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
            for (int i = 0; i < x.Length; i++)
            {
                yy[i] = ratio[0] + ratio[1] * x[i];
            }
            Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy) + "\r\n");
            //Console.WriteLine("一次拟合计算时间：");
            //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.WriteLine("一次拟合(截距为0，即强制过原点)：");
            sw.Start();
            ratio = FittingFunct.LinearInterceptZero(y, x);
            sw.Stop();

            foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
            for (int i = 0; i < x.Length; i++)
            {
                yy[i] = ratio[0] * x[i];
            }
            Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy) + "\r\n");
            //Console.WriteLine("一次拟合计算时间：");
            //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.WriteLine("二次拟合：");
            sw.Start();
            ratio = FittingFunct.TowTimesCurve(y, x);
            sw.Stop();

            foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
            for (int i = 0; i < x.Length; i++)
            {
                yy[i] = ratio[0] + ratio[1] * x[i] + ratio[2] * x[i] * x[i];
            }
            Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy) + "\r\n");
            //Console.WriteLine("二次拟合计算时间：");
            //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.WriteLine("对数拟合计算时间：");
            sw.Start();
            ratio = FittingFunct.LOGEST(y, x);
            sw.Stop();

            foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
            for (int i = 0; i < x.Length; i++)
            {
                yy[i] = ratio[1]*Math.Log10(x[i]) + ratio[0];
            }
            Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy) + "\r\n");
            //Console.WriteLine("对数拟合计算时间：");
            //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.WriteLine("幂级数拟合：");
            sw.Start();
            ratio=FittingFunct.PowEST(y,x);
            sw.Stop();

             foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
             for (int i = 0; i < x.Length; i++)
             {
                 yy[i] = ratio[0] * Math.Pow(x[i], ratio[1]);
             }
             Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy) + "\r\n");
             //Console.WriteLine("幂级数拟合计算时间：");
             //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.WriteLine("指数函数拟合：");
            sw.Start();
            ratio = FittingFunct.IndexEST(y, x);
            sw.Stop();
            foreach (double num in ratio)
            {
                Console.WriteLine(num);
            }
            for (int i = 0; i < x.Length; i++)
            {
                yy[i] = ratio[0] * Math.Exp(x[i] * ratio[1]);
            }
            Console.WriteLine("R²=: " + FittingFunct.Pearson(y, yy));
            //Console.WriteLine("指数函数拟合计算时间：");
            //Console.WriteLine(sw.ElapsedMilliseconds);

            Console.ReadKey();
       
        }
    }
}

类2：


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 高斯消元法
{
    class FittingFunct
    {
          #region 多项式拟合函数,输出系数是y=a0+a1*x+a2*x*x+.........，按a0,a1,a2输出
        static public double[] Polyfit(double[] y, double[] x, int order)
        {
              double[,] guass = Get_Array(y, x, order);
           
              double[] ratio = Cal_Guass(guass, order + 1);
            
              return ratio;
        }
        #endregion

          #region 一次拟合函数，y=a0+a1*x,输出次序是a0,a1
        static public double[] Linear(double[] y,double[] x)
        {
            double[] ratio = Polyfit(y, x, 1);
            return ratio;
        }
         #endregion

        #region 一次拟合函数，截距为0，y=a0x,输出次序是a0
        static public double[] LinearInterceptZero(double[] y, double[] x)
        {
            double divisor = 0; //除数
            double dividend = 0; //被除数
            for (int i = 0; i < x.Length;i++ )
            {
                divisor += x[i] * x[i];
                dividend += x[i] * y[i];
            }
            if (divisor == 0)
            {
                throw (new Exception("除数不为0！"));
                return null;
            }
            return new double[] { dividend / divisor };

        }
        #endregion

        #region 二次拟合函数，y=a0+a1*x+a2x²,输出次序是a0,a1,a2
        static public double[] TowTimesCurve(double[] y, double[] x)
        {
            double[] ratio = Polyfit(y, x, 2);
            return ratio;
        }
        #endregion

          #region 对数拟合函数,.y= c*(ln x)+b,输出为b,c
        static public double[] LOGEST(double[] y, double[] x)
        {
            double[] lnX = new double[x.Length];

            for (int i = 0; i < x.Length; i++)
            {
                if (x[i] == 0 || x[i] < 0)
                {
                    throw (new Exception("正对非正数取对数！"));
                    return null;
                }
                lnX[i] = Math.Log(x[i]);
            }

            return Linear(y, lnX);
        }
        #endregion

          #region 幂函数拟合模型, y=c*x^b,输出为c,b
        static public double[] PowEST(double[] y, double[] x)
        {
            double[] lnX = new double[x.Length];
            double[] lnY = new double[y.Length];
            double[] dlinestRet;

            for (int i = 0; i < x.Length; i++)
            {
                lnX[i] = Math.Log(x[i]);
                lnY[i] = Math.Log(y[i]);
            }

            dlinestRet = Linear(lnY, lnX);

           dlinestRet[0] = Math.Exp(dlinestRet[0]);
           
            return dlinestRet;
        }
         #endregion

         #region 指数函数拟合函数模型，公式为 y=c*m^x;输出为 c,m
         static  public double[] IndexEST(double[] y, double[] x)
        {
            double[] lnY = new double[y.Length];
            double[] ratio;
            for (int i = 0; i < y.Length; i++)
            {
                lnY[i] = Math.Log(y[i]);
             }

            ratio = Linear(lnY, x);
            for (int i = 0; i < ratio.Length; i++)
            {
                if (i == 0)
                {
                    ratio[i] = Math.Exp(ratio[i]);
                }
             }
            return ratio;
        }
         #endregion

         #region 相关系数R²部分
         public static double Pearson(IEnumerable<double> dataA, IEnumerable<double> dataB)
         {
             int n = 0;
             double r = 0.0;

             double meanA = 0;
             double meanB = 0;
             double varA = 0;
             double varB = 0;
             int ii = 0;
             using (IEnumerator<double> ieA = dataA.GetEnumerator())
             using (IEnumerator<double> ieB = dataB.GetEnumerator())
             {
                 while (ieA.MoveNext())
                 {
                     if (!ieB.MoveNext())
                     {
                         //throw new ArgumentOutOfRangeException("dataB", Resources.ArgumentArraysSameLength);
                     }
                     ii++;
                     //Console.WriteLine("FF00::  " + ii + " --  " + meanA + " -- " + meanB + " -- " + varA + "  ---  " + varB);
                     double currentA = ieA.Current;
                     double currentB = ieB.Current;

                     double deltaA = currentA - meanA;
                     double scaleDeltaA = deltaA / ++n;

                     double deltaB = currentB - meanB;
                     double scaleDeltaB = deltaB / n;

                     meanA += scaleDeltaA;
                     meanB += scaleDeltaB;

                     varA += scaleDeltaA * deltaA * (n - 1);
                     varB += scaleDeltaB * deltaB * (n - 1);
                     r += (deltaA * deltaB * (n - 1)) / n;
                     //Console.WriteLine("FF00::  " + ii + " --  " + meanA + " -- " + meanB + " -- " + varA + "  ---  " + varB);
                 }

                 if (ieB.MoveNext())
                 {
                     //throw new ArgumentOutOfRangeException("dataA", Resources.ArgumentArraysSameLength);
                 }
             }
             return (r / Math.Sqrt(varA * varB)) * (r / Math.Sqrt(varA * varB));
         }
         #endregion

#region 最小二乘法部分

          #region 计算增广矩阵
        static  private double[] Cal_Guass(double[,] guass,int count)
        {
            double temp;
            double[] x_value;

            for (int j = 0; j < count; j++)
            {
                int k = j;
                double min = guass[j,j];

                for (int i = j; i < count; i++)
                {
                    if (Math.Abs(guass[i, j]) < min)
                    {
                        min = guass[i, j];
                        k = i;
                    }
                }

                if (k != j)
                {
                    for (int x = j; x <= count; x++)
                    {
                        temp = guass[k, x];
                        guass[k, x] = guass[j, x];
                        guass[j, x] = temp;
                    }
                }

                for (int m = j + 1; m < count; m++)
                {
                    double div = guass[m, j] / guass[j, j];
                    for (int n = j; n <= count; n++)
                    {
                        guass[m, n] = guass[m, n] - guass[j, n] * div;
                    }
                }

               /* System.Console.WriteLine("初等行变换：");
                for (int i = 0; i < count; i++)
                {
                    for (int m = 0; m < count + 1; m++)
                    {
                        System.Console.Write("{0,10:F6}", guass[i, m]);
                    }
                    Console.WriteLine();
                }*/
            }
            x_value= Get_Value(guass, count);

            return x_value;

            /*if (x_value == null)
                Console.WriteLine("方程组无解或多解！");
            else
            {
                foreach (double x in x_value)
                {
                    Console.WriteLine("{0:F6}", x);
                }
            }*/
        }

        #endregion

          #region 回带计算X值
        static private double[] Get_Value(double[,] guass,int count)
        {
            double[] x = new double[count];
            double[,] X_Array = new double[count, count];
            int rank = guass.Rank;//秩是从0开始的

            for (int i = 0; i < count; i++)
                for (int j = 0; j < count; j++)
                    X_Array[i, j] = guass[i, j];

            if (X_Array.Rank < guass.Rank)//表示无解
            {
                return null;
            }

            if (X_Array.Rank < count-1)//表示有多解
            {
                return null;
            }
            //回带计算x值
            x[count - 1] = guass[count - 1, count] / guass[count-1, count-1];
            for (int i = count - 2; i >= 0; i--)
            {
                double temp=0;
                for (int j = i; j < count; j++)
                {
                    temp += x[j] * guass[i, j];
                }
                x[i] = (guass[i, count] - temp) / guass[i, i];
            }

                return x;
        }
          #endregion

          #region  得到数据的法矩阵,输出为发矩阵的增广矩阵
        static private double[,] Get_Array(double[] y, double[] x, int n)
        {
            double[,] result = new double[n + 1, n + 2];

            if (y.Length != x.Length)
            {
                throw (new Exception("两个输入数组长度不一！"));
                //return null;
            }

            for (int i = 0; i <= n; i++)
            {
                for (int j = 0; j <= n; j++)
                {
                    result[i, j] = Cal_sum(x, i + j);
                }
                result[i, n + 1] = Cal_multi(y, x, i);
            }

            return result;
        }

     #endregion

          #region 累加的计算
        static private double Cal_sum(double[] input,int order)
        {
            double result=0;
            int length = input.Length;          

            for (int i = 0; i < length; i++)
            {
                result += Math.Pow(input[i], order);
            }

           return result;
        }
        #endregion

          #region 计算∑(x^j)*y
        static private double Cal_multi(double[] y,double[] x,int order)
        {
            double result = 0;

            int length = x.Length;

            for (int i = 0; i < length; i++)
            {
                result += Math.Pow(x[i], order) * y[i];
            }

            return result;
        }
         #endregion

#endregion
    }
}



C#利用最小二乘法拟合任意次函数曲线
qq_30725967的博客
08-24 3436
给出一组离散点，确定一个函数逼近原函数，插值是这样的一种手段。在实际中，数据不可避免的会有误差，插值函数会将这些误差也包括在内。因此，我们需要一种新的逼近原函数的手段： ①不要求过所有的点（可以消除误差影响）；②尽可能表现数据的趋势，靠近这些点。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小 [1]，其他一些优化问题也可通过最小化能量或最大化熵用最小二乘法来表达，具体可以查阅相关资料。最小二乘法（又称最小平方法）是一种数学技术。
C#最小二乘法拟合及曲线绘制
04-08
可以最小二乘法拟合任意次数的曲线，绘制了原始折线和拟合曲线的对比图，有现成代码可供引用
C#中利用最小二乘法实现曲线拟合
weixin_42293338的博客
01-30 2580
最小二乘法（又称最小平方法）是一种数学优化技术。它通过最小化误差的平方和寻找数据的最佳函数匹配。利用最小二乘法可以简便地求得未知的数据，并使得这些求得的数据与实际数据之间误差的平方和为最小。∑i1nyxi−yi2∑i1n​yxi​−yi​2最小。最终转化对系数a1 a2 a3求偏导，多次迭代后算出估算值。
C#中的最小二乘法拟合函数实战教程
最新发布
weixin_42601702的博客
09-29 1208
本文还有配套的精品资源，点击获取 简介：在数据分析和科学计算中，拟合函数是理解数据行为的重要工具。本文详细介绍了如何在C#环境下使用最小二乘法实现多项式拟合、指数函数拟合、对数函数拟合和幂函数拟合。首先解释了最小二乘法的基本概念，然后具体探讨了每种拟合类型的具体实现方法。内容涵盖了矩阵运算、损失函数构建、导数计算以及优化算法的选择等关键步骤。此外，还提到了开源库如 ...
C# 最小二乘法拟合曲线成直线
weixin_39448579的博客
01-06 1499
运行最小二乘法拟合曲线成为一条直线
c#算法（5）—最小二乘法（二次曲线拟合）
qq_34059233的博客
03-12 1352
最小二乘法——二次曲线拟合
C#Mathnet最小二乘法拟合自定义指数曲线
mengyingguxing的博客
11-01 1581
Mathnet最小二乘法拟合自定义指数曲线
C#最小二乘法函数拟合.rar
03-18
在这个名为"C#最小二乘法函数拟合.rar"的压缩包中，包含的资源专注于使用最小二乘法进行不同类型的函数拟合，如多项式、指数和幂指数等。最小二乘法是一种优化技术，用于找到最佳拟合曲线或超平面，使得所有数据点到...
最小二乘法曲线拟合(源码)
03-22
在本压缩包中，包含了一个关于最小二乘法曲线拟合的源码示例，允许用户自定义拟合的多项式次数，以适应不同复杂度的数据。 最小二乘法的基本思想是，通过最小化残差平方和来寻找最佳拟合曲线。残差是实际观测值与...
C#+最小二乘法拟合二元多次曲线
04-11
本文将深入探讨如何使用C#语言实现最小二乘法来拟合二元多次曲线。最小二乘法是一种优化方法，常用于找到一组参数，使得模型与实际观测数据之间的残差平方和最小。在二元多次曲线的背景下，我们指的是两个自变量（x1...
c# 拟合曲线 求相关系数R
03-07
拟合曲线是将一组数据点通过数学模型进行拟合，以便更好地理解数据趋势或预测未知值。这个过程涉及到线性拟合和多项式拟合，以及计算相关系数R（或R²），以评估模型对数据的拟合程度。 线性拟合是最基础的拟合方法...
曲线拟合&&线性回归（C#)
06-08
这个是我做的系统的部分算法的实现，主要是曲线拟合和线性回归。不改名字了，直接传上来吧。
C#使用mathNet进行线性拟合和多次拟合
热门推荐
学习记录
10-26 1万+
首先需要引用mathNet，VS2013及以上的版本在联网的情况下可以按照下面的步骤进行添加引用。 首先需要新建一个项目，在自己的项目界面中，依次选择工具–>NuGet包管理器–>程序包管理器控制台。 在打开的程序包管理器控制台中输入如下命令 Install-Package MathNet.Numerics 等待几秒钟即可看到安装成功。 线性拟合代码： Tuple<doub...
（C#）曲线拟合的最小二乘法
12-31 1万+
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace 数值分析实验报告 { class Gauss曲线拟合的最小二乘法 { static void Main() { Imput();
C#基于最小二乘法对曲线进行线性拟合，并计算斜率
weixin_50236846的博客
04-11 642
创作动力：在工控测试类项目中，经常需要对测试数据进行深度计算，其中就包含斜率的计算，为了验证计算的正确与否，需要对excel数据进行二次验证，此时需要一款能够读取excel数据并进行线性拟合计算的斜率的小工具，本项目就应运而生。文章末尾包含源码链接。 功能介绍：1、能够获取Excel中所有sheet页的内容，并赋值到DataTable。 2、对获取到的数据使用最小二乘法来进行线性拟合。
利用最小二乘法拟合任意次函数曲线（C#）
11-09 724
///     ///用最小二乘法拟合二元多次曲线     ///     ///<param name="arrX">已知点的x坐标集合     ///<param name="arrY">已知点的y坐标集合     ///<param name="length">已知点的个数     ///<param name="dimension">方程的最高次数    
用最小二乘法拟合任意次函数曲线（C#）
u011555996的博客
04-03 1667
///<summary> ///用最小二乘法拟合二元多次曲线 ///</summary> ///<param name="arrX">已知点的x坐标集合</param> ///<param name="arrY">已知点的y坐标集合</param> ///<param name="lengt...
C#拟合一次函数、pearson系数
烧饼的博客
07-06 1304
线性关系y=kx+b . 根据数据求出k、b。 //文本框用作输出信息 public void showinfo(string info) { InfoLog.AppendText($"{DateTime.Now.ToShortDateString()}\r {info}"); } private List<double> calkb(double[] xlist, double[] ylist)
c#怎么拟合函数得到参数,具有两个参数的方程的曲线拟合
weixin_36124750的博客
01-11 485
I have two arrays:E= [6656400;13322500;19980900;26625600;33292900;39942400;46648900;53290000]andJ=[0.0000000021;0.0000000047;0.0000000128;0.0000000201;0.0000000659;0.0000000748;0.0000001143;0.00000013...
c#最小二乘法曲线拟合
07-27
对于使用C#实现最小二乘法进行曲线拟合，你可以按照以下步骤进行操作： 1. 首先，确定你想要拟合的曲线类型，例如直线、多项式等。假设你选择的是多项式曲线拟合。 2. 创建一个C#类，并添加一个方法来执行最小...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值