精华内容
下载资源
问答
  • C语言直线拟合函数

    千次阅读 2020-10-15 10:12:48
    直线拟合算法 函数说明: 通过一些点拟合出一条直线。 参数: pt_input 指向传入的点的指针。 ptNumbers 传入的点数量。 k 指向拟合直线参数k的指针。 b 指向拟合直线参数b的指针。 返回值: 返回一个代数值判断拟合...

    直线拟合算法

    函数说明:

    通过一些点拟合出一条直线。

    参数:

    pt_input
    指向传入的点的指针。

    ptNumbers
    传入的点数量。

    k
    指向拟合直线参数k的指针。

    b
    指向拟合直线参数b的指针。

    返回值:

    返回一个代数值判断拟合是否成功。如果成功,则返回 0。如果返回-1,表示点的数量<2。如果返回-2,表示x坐标无变化。

    代码:

    typedef struct tagPOINT_2 {
    	double x;
    	double y;
    }POINT_2, *PPOINT_2;
    
    int LineInfo(POINT_2 *pt_input, int ptNumbers, double * k, double * b)
    {
    	int nRet = 0;
    	
    	double X_aver = 0;
    	double Y_aver = 0;
    	double A = 0;
    	double B = 0;
    
    	double _2_XY_av = 0;
    	double _2_XX_av = 0;
    
    	do
    	{
    		if (ptNumbers < 2)
    		{
    			nRet = -1;
    			break;
    		}
    
    		for (int loop = 0; loop < ptNumbers; loop++)
    		{
    			X_aver += pt_input[loop].x;
    			Y_aver += pt_input[loop].y;
    
    			_2_XY_av += pt_input[loop].x * pt_input[loop].y;
    			_2_XX_av += pt_input[loop].x * pt_input[loop].x;
    		}
    		X_aver /= ptNumbers;
    		Y_aver /= ptNumbers;
    
    		_2_XY_av /= ptNumbers;
    		_2_XX_av /= ptNumbers;
    
    		for (int loop = 0; loop < ptNumbers; loop++)
    		{
    			A += fabs((pt_input[loop].x - X_aver) * (pt_input[loop].y - Y_aver));
    			B += fabs((pt_input[loop].x - X_aver) * (pt_input[loop].x - X_aver));
    		}
    
    		if (B < 0.000001)
    		{
    			nRet = -2;
    			break;
    		}
    		//方式一
    		//*k = A / B;
    		//*b = Y_aver - *k * X_aver;
    		//方式二
    		*k = (_2_XY_av - X_aver * Y_aver) / (_2_XX_av - X_aver * X_aver);
    		*b = Y_aver - (*k) * X_aver;
    	} while (0);
    
    	return nRet;
    }
    
    

    测试代码:

    #include <stdio.h>
    #include <math.h>
    int main()
    {
    	POINT_2 pt[10] = {
    	{0.1 , 0.3},
    	{1.2 , 2.0},
    	{2.2 , 4.3},
    	{3.1 , 5.8},
    	{4.0 , 8.5},
    	{5.3 , 10.8},
    	{5.9 , 11.1},
    	{6.8 , 13.9},
    	{8.1 , 16.5},
    	{9.0 , 17.9},
    	};
    	int ret;
    	double k = 0, b = 0;
    	ret = LineInfo(pt, 10, &k, &b);
    	switch (ret)
    	{
    	case 0: printf("拟合成功,直线为y = %lf * x + %lf\n", k, b); break;
    	case -1: printf("拟合失败,传入的点少于二点\n"); break;
    	case -2: printf("拟合失败,传入的点x坐标重合\n"); break;
    	default:printf("error\n"); break;
    	}
    
    	return 0;
    }
    

    测试结果:

    在这里插入图片描述

    展开全文
  • C语言代码实现最小二乘法线性拟合直线

    千次阅读 多人点赞 2019-04-11 16:46:38
     P[POINT_NUM]:传入要线性拟合的点数据(结构体数组)  N:线性拟合的点的数量  K0:直线斜率参数存放地址  b0:直线截距参数存放地址 */ void Least_square_method(POINTS P[],int N,double *K0,double *b0...

    #include<stdio.h>
    /*
    要求的方程为: y=ax+b。

                      N∑xy-∑x∑y                        _     _
    其中:a= --------------------        b = y - ax
                    N∑(x^2)-(∑x)^2

    设:A=∑xy  B=∑x  C=∑y  D=∑(x^2)

                       NA-BC      
    则:     a = -----------                 b = C/N-aB/N
                        ND-BB

    注:N为要拟合的点数量
    */

    #define POINT_NUM  20  //最多输入20个点进行线性拟和
    typedef struct POINT //点的结构
    {
        double x;
        double y;
    }POINTS;

    POINTS  points[POINT_NUM]; //存放点数据

    /*
    参数说明:
            P[POINT_NUM]:传入要线性拟合的点数据(结构体数组)
            N:线性拟合的点的数量
            K0:直线斜率参数存放地址
            b0:直线截距参数存放地址
    */
    void Least_square_method(POINTS P[],int N,double *K0,double *b0)
    {
        int i=0;
        double K=0,b=0,A=0,B=0,C=0,D=0;
        for(i=0;i<N;i++)
        {
            A+=P[i].x*P[i].y;
            B+=P[i].x;
            C+=P[i].y;
            D+=P[i].x*P[i].x;
        }
        K=(N*A-B*C)/(N*D-B*B);
        b=C/N-K*B/N;
        /*将计算得到的直线参数通过指针传递到函数外部*/
        *K0=K;
        *b0=b;
        
    /*    printf("A=%f\nB=%f\nC=%f\nD=%f\n",A,B,C,D);
        if(b>0) printf("y=%fx+%f\n",K,b);
        else if(b==0)printf("y=%fx\n",K);
        else printf("y=%fx%f\n",K,b);*/
    }


    int main()
    {
        double k,b;
        points[0].x=123;
        points[1].x=130;
        points[2].x=141;
        points[3].x=150;
        points[4].x=165;
        
        points[0].y=150;
        points[1].y=160;
        points[2].y=175;
        points[3].y=190;
        points[4].y=205;
        
        Least_square_method(points,5,&k,&b); //调函数拟合直线
        
        if(b>0) printf("函数为:y=%fx+%f\n",k,b);
        else if(b<0) printf("函数为:y=%fx%f\n",k,b);
        else printf("函数为:y=%fx\n",k);
        return 0;
    }
    /*
    在EXCEL中计算得到的拟合函数为 y = 1.3342x - 13.187
    程序运算结果:  函数为:y=1.334183x-13.187113
    */
     

    展开全文
  • 北航数值分析第三次大作业,使用普通的多项式方法和正交基函数方法。求解非线性方程组使用梯度下降法,与曲面拟合完全独立。
  • 线性回归C语言

    2014-06-06 21:42:50
    用于数据处理的直线拟合,采用概率论中的线性回归得到拟合直线的斜率和截距
  • C语言实现几种基础的求解非线性方程的迭代法
  • 使用c语言实现一个给出若干点的拉格朗日线性插值。
  • 线性回归学习算法c语言实现Linear Search is basically a sequential search algorithm. 线性搜索基本上是一种顺序搜索算法 。 In this algorithm, the key element is searched in the given input array in ...

    线性回归学习算法c语言实现

    Linear Search is basically a sequential search algorithm.

    线性搜索基本上是一种顺序搜索算法

    In this algorithm, the key element is searched in the given input array in sequential order.

    在此算法中,键元素按给定顺序在给定的输入数组中搜索。

    If the key element is found in the input array, it returns the element.

    如果在输入数组中找到key元素,它将返回该元素。



    线性搜索算法 (Linear Search Algorithm)

    Linear_Search ( Array X, Value i)

    Linear_Search(数组X,值i)

    • Set j to 1

      将j设为1
    • If j > n, jump to step 7

      如果j> n,则跳至步骤7
    • If X[j] == i, jump to step 6

      如果X [j] == i,则跳至步骤6
    • Then, increment j by 1 i.e. j = j+1

      然后,将j加1,即j = j + 1
    • Go back to step 2

      返回步骤2
    • Display the element i which is found at particular index i, then jump to step 8

      显示在特定索引i处找到的元素i,然后跳到步骤8
    • Display element not found in the set of input elements.

      在输入元素集中找不到显示元素。
    • Exit/End

      退出/结束


    线性搜索的伪代码 (Pseudo Code for Linear Search)

    
    procedure LINEAR_SEARCH (array, key)
    
       for each item in the array
          if match element == key
             return element's index
          end if
       end for
    
    end procedure
    


    C语言中线性搜索的实现 (Implementation of Linear Search in C)

    • Initially, we need to mention or accept the element to be searched from the user.

      首先,我们需要提及或接受用户要搜索的元素。
    • Then, we create a for loop and start searching for the element in a sequential fashion.

      然后,我们创建一个for循环并开始按顺序搜索元素。
    • As soon as the compiler encounters a match i.e. array[element] == key value, return the element along with its position in the array.

      编译器遇到匹配项即array [element] ==键值后,立即返回元素及其在数组中的位置。
    • If no values are found that match the input, it returns -1.

      如果找不到与输入匹配的值,则返回-1。
    Linear Search
    Linear Search 线性搜寻
    
    #include <stdio.h> 
    
    int LINEAR_SEARCH(int inp_arr[], int size, int val) 
    { 
    	 
    	for (int i = 0; i < size; i++) 
    		if (inp_arr[i] == val) 
    			return i; 
    	return -1; 
    } 
    
    
    int main(void) 
    { 
    	int arr[] = { 10, 20, 30, 40, 50, 100, 0 }; 
    	int key = 100; 
    	int size = 10; 
    	int res = LINEAR_SEARCH(arr, size, key); 
    	if (res == -1)
    	printf("ELEMENT NOT FOUND!!");
        else
        printf("Item is present at index %d", res);
        
    	return 0; 
    } 
    

    Output:

    输出:

    
    Item is present at index 5
    

    线性搜索的时间复杂度 (Time Complexity of Linear Search)

    The best-case complexity is O(1) if the element is found in the first iteration of the loop.

    如果在循环的第一次迭代中找到元素,则最佳情况下的复杂度为O(1)

    The worst-case time complexity is O(n), if the search element is found at the end of the array, provided the size of the array is n.

    如果在数组的末尾找到搜索元素,则最坏情况下的时间复杂度是O(n) ,前提是数组的大小为n。



    结论 (Conclusion)

    Thus, in this article, we have understood and implemented Linear Search Algorithm.

    因此,在本文中,我们已经理解并实现了线性搜索算法。

    翻译自: https://www.journaldev.com/35170/linear-search-algorithm-c

    线性回归学习算法c语言实现

    展开全文
  • 直线拟合经典算法c语言

    热门讨论 2011-08-03 09:20:18
    如果你有一些数据点,他们是离散的。你要从中找到这些点的规律,就做一条直线,穿过尽可能多的点,使得这些数据和直线上所的估计的点的方差最小。找到的这条直线就是拟合直线。它代表了数据之间的线性规律
  • 1)] //即yData countOfElements //即元素个数 order - Order of the polynomial fitting //要拟合的最高阶数 OUTPUTS: coefficients[0..order] - indexed by term (the (coef*x^3) is coefficients[3]) //拟合的各项...

    本方法转自https://github.com/natedomin/polyfit

    polyfit.c:

    /*------------------------------------------------------------
    METHOD:  polyfit
    INPUTS:  dependentValues[0..(countOfElements-1)] 	//即xData
             independentValues[0...(countOfElements-1)] //即yData
             countOfElements							//即元素个数
             order - Order of the polynomial fitting	//要拟合的最高阶数
    OUTPUTS: coefficients[0..order] - indexed by term	
                   (the (coef*x^3) is coefficients[3])
             //拟合的各项系数的结果,x^3 的系数为coefficients[3]
    -------------------------------------------------------------*/
    int polyfit(const double* const dependentValues ,
                const double* const independentValues ,
                unsigned int        countOfElements ,
                unsigned int        order ,
                double* coefficients)
    {
        // Declarations...
        // ----------------------------------
        enum { maxOrder = 5 };
    
        double B[maxOrder + 1] = {0.0f};
        double P[((maxOrder + 1) * 2) + 1] = {0.0f};
        double A[(maxOrder + 1) * 2 * (maxOrder + 1)] = {0.0f};
    
        double x , y , powx;
    
        unsigned int ii , jj , kk;
    
        // Verify initial conditions....
        // ----------------------------------
    
        // This method requires that the countOfElements > 
        // (order+1) 
        if (countOfElements <= order)
            return -1;
    
        // This method has imposed an arbitrary bound of
        // order <= maxOrder.  Increase maxOrder if necessary.
        if (order > maxOrder)
            return -1;
    
        // Begin Code...
        // ----------------------------------
    
        // Identify the column vector
        for (ii = 0; ii < countOfElements; ii++)
        {
            x = dependentValues[ii];
            y = independentValues[ii];
            powx = 1;
    
            for (jj = 0; jj < (order + 1); jj++)
            {
                B[jj] = B[jj] + (y * powx);
                powx = powx * x;
            }
        }
    
        // Initialize the PowX array
        P[0] = countOfElements;
    
        // Compute the sum of the Powers of X
        for (ii = 0; ii < countOfElements; ii++)
        {
            x = dependentValues[ii];
            powx = dependentValues[ii];
    
            for (jj = 1; jj < ((2 * (order + 1)) + 1); jj++)
            {
                P[jj] = P[jj] + powx;
                powx = powx * x;
            }
        }
    
        // Initialize the reduction matrix
        //
        for (ii = 0; ii < (order + 1); ii++)
        {
            for (jj = 0; jj < (order + 1); jj++)
            {
                A[(ii * (2 * (order + 1))) + jj] = P[ii + jj];
            }
    
            A[(ii * (2 * (order + 1))) + (ii + (order + 1))] = 1;
        }
    
        // Move the Identity matrix portion of the redux matrix
        // to the left side (find the inverse of the left side
        // of the redux matrix
        for (ii = 0; ii < (order + 1); ii++)
        {
            x = A[(ii * (2 * (order + 1))) + ii];
            if (x != 0)
            {
                for (kk = 0; kk < (2 * (order + 1)); kk++)
                {
                    A[(ii * (2 * (order + 1))) + kk] =
                        A[(ii * (2 * (order + 1))) + kk] / x;
                }
    
                for (jj = 0; jj < (order + 1); jj++)
                {
                    if ((jj - ii) != 0)
                    {
                        y = A[(jj * (2 * (order + 1))) + ii];
                        for (kk = 0; kk < (2 * (order + 1)); kk++)
                        {
                            A[(jj * (2 * (order + 1))) + kk] =
                                A[(jj * (2 * (order + 1))) + kk] -
                                y * A[(ii * (2 * (order + 1))) + kk];
                        }
                    }
                }
            }
            else
            {
                // Cannot work with singular matrices
                return -1;
            }
        }
    
        // Calculate and Identify the coefficients
        for (ii = 0; ii < (order + 1); ii++)
        {
            for (jj = 0; jj < (order + 1); jj++)
            {
                x = 0;
                for (kk = 0; kk < (order + 1); kk++)
                {
                    x = x + (A[(ii * (2 * (order + 1))) + (kk + (order + 1))] *
                        B[kk]);
                }
                coefficients[ii] = x;
            }
        }
    
        return 0;
    }
    

    验证该函数的正确性,代码如下:
    main.c

    #include <stdbool.h>
    #include <stdint.h>
    #include <stdio.h>
    
    #define ELE_COUNT 5
    int main(void)
    {
      const unsigned int order = 3;
      int result;
      // These inputs should result in the following approximate coefficients:
      //         0.5           2.5           1.0        3.0
      //    y = (0.5 * x^3) + (2.5 * x^2) + (1.0 * x) + 3.0
      double    xData[ELE_COUNT] = {12.0,    77.8,      44.1,     23.6,    108.2};
      double    yData[ELE_COUNT] = {1239.00, 250668.38, 47792.19, 7991.13, 662740.98};
      double coefficients[order + 1]; // resulting array of coefs
    
      // Perform the polyfit
      result = polyfit(xData ,
                       yData ,
                       ELE_COUNT ,
                       order ,
                       coefficients);
      printf("\n------------------------------\npolyfit result is:\n");
      printf("%lfx^3+%lfx^2+%lfx+%f" , coefficients[3],coefficients[2],coefficients[1],
      								   coefficients[0]);
      printf("\n------------------------------\n");
      return 0;
    }
    

    进行编译运行后,结果如下,可看出结果基本一致,也可自行拿其他函数进行验证。

    在这里插入图片描述

    展开全文
  • 线性回归 c语言实现Linear regression models the relation between an explanatory (independent) variable and a scalar response (dependent... 线性回归通过拟合线性方程来对解释性(独立)变量和标量响应(因变量)...
  • 作图法求出直线的斜率a和截据b,可以确定这条直线所对应的经验公式,但用作图法拟合直线时,由于作图连线有较大的随意性,尤其在测量数据比较分散时,对同一组测量数据,不同的人去处理,所得结果有差异,因此是一种...
  • 简单线性回归c语言实现,计算偏差平方和,平均标准偏差,回归平方和,偏差平均值
  • 线性最小二乘法C语言代码

    热门讨论 2011-10-10 21:09:01
    线性最小二乘法C语言代码 main () { int n,i,flag2; char flag1='y'; float ar[50],br[50],x,y,xe,ye,xye,xxe,sx,sy,sxy,sxx,a,b; printf ("\n欢迎使用最小二乘法数据处理程序\n");
  • C语言实现线性回归求斜率

    千次阅读 2020-11-01 14:17:01
    /* *****注意数据类型 *参数 count 数据个数 数组行(列)的个数 数组的行列数目相等 *参数 dataCol_X[count] 数据的列数据 *参数 dataRow_Y[count] 数据的行数据 *返回值 k 斜率 *使用注意 需要重定义数据类型 ...
  • 本文主要介绍一种用C语言来实现最小二乘法曲线拟合的方法。
  • C语言实现拟合直线方程

    千次阅读 2015-12-26 15:33:43
    C语言实现拟合直线方程在进行拟合直线的时候,最一般的做法是最小二乘法,此方法比较快速,易懂,下列程序用最小二乘法拟合直线。
  • 本文档包括1,2,3,4阶最小二乘法拟合实例代码,包含计算公式,本人亲手所写,绝对良心之作,已验证通过
  • 最小二乘算法的c程序,主要是针对现行拟合的情况
  • 作业需要,需要在单片机上显示距离与ad值大小的关系,理论推倒得到这两个的关系是抛物线,因此查书写了这段c语言程序。 具体的证明过程我也不会,书上提到了对于抛物线采用多项式拟合的方法,好像是将x,x^2,看成了...
  • 基于最小二乘法的曲线拟合,大致思路为根据曲线的阶数以及原数据的组数,建立正规方程组,然后解正规方程计算出a0~an每个系数的值。
  • 最小二乘法的曲线拟合程序(c语言),c语言程序代码
  • 采用单片机等微处理器采集一些“线性”传感器数据时,注意这里的线性是指相似于线性变化,比如NTC热敏电阻、PT100铂电阻、PH复合电极传感器,这些传感器的变化特性类似于二维坐标轴上的一条斜线。如下图可以看出数据...
  • 最小二乘法拟合直线 #include<stdio.h> /* 要求的方程为: y=ax+b。 N∑xy-∑x∑y _ _ 其中:a= --------------- b = y - ax N∑(x^2)-(∑x)^2 设:A=∑xy B=∑x C=∑y D=∑(x^2) ...
  • 今天我们用C语言实现一个简单的线性回归算法;在代码前面我们在回顾一下线性回归。 线性回归是回归问题中的一种,线性回归假设目标值与特征是线性相关的,即满足一个多元一次方程式。通过构建损失函数,来求解损失...
  • 最小二乘法曲线拟合C语言可执行代码
  • 简单的一元线性回归算法已经在这里“C语言简单的一元线性回归算法”,并且也简单阐述了梯度求解推导过程。 今天我们再呈上多元线性回归算法梯度下降的C语言实现,代码中已经加入了相应的注释。如下: ...
  • 现在给定n个点,(x1,y1),(x2,y2),(x3,y3),(x4,y4),(x5,y5)..(xn,yn).现在希望得到一条最好的曲线(也就是求一个函数...为了方便,我们考虑最简单的线性模型。  1, n ∑(yi-f(xi))  i=1 但是考虑到有些点在线
  • 上一篇我们贴上了简单粗暴的线性回归的代码,里面各种参数都设置的是固定参数,不具有可扩展性,今天我们在上一篇的基础上做了部分改进,当然对于熟悉C语言的大侠来说可能这篇博客会太low了,您完全可以跳过。...
  • 最小二乘法 多项式拟合 C语言实现

    万次阅读 多人点赞 2018-01-30 09:07:20
    最小二乘法 多项式拟合 C语言实现
  • 高斯曲线虽然也是非线性函数,但它的各个参数具有明确的物理意义,因为高斯拟合在分析仪器的测量中具有广泛的应用前景。利用它来描述或拟合求出一些实验数据的分析,往往能起到常规方法不能达到的作用。 2.结果...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,768
精华内容 707
关键字:

c语言拟合线性

c语言 订阅