6. C语言---include、define用法

6. C语言—include、define用法

#include<> 用尖括号包含头文件,在系统指定的路径下找头文件
#include" " 用双引号包含头文件,先在当前目录下找头文件,找不到,再到系统指定的路径下找。

注意: include经常用来包含头文件,可以包含 .c 文件,但是大家不要包含.c文件,因为include包含的文件在预编译被展开,如果一个 .c 被包含多次,展开多次,会导致函数重复定义。所以不要包含,c 文件。

define

定义宏定义用define去定义
宏是在预编译的时候进行替换。
1. 不带参宏
#define PI 3.1415
在预编译的时候如果代码中出现了pi就用3.1415去替换。
宏定义的好处: 只要修改宏定义,其他地方在预编译的时候就会重新替换。

注意: 宏定义后边不要加分号。宏定义标识符一般采用大写字母。

如果想取消宏定义标识符的作用,可以用# undef PI 进行终止。

2. 带参宏
#define S(a,b) (a)+(b)
注意带参宏的形参 a和b 没有类型名。

带参宏和带参函数的区别

1.: 带参宏被调用多少次就会展开多少次,执行代码的时候没有函数调用的过程,不要压栈弹栈,所以,带参宏,是浪费了空间,因为被展开多次,节省了时间
2,带参函数,代码只有一份,存在代码段,调用的时候去代码段取指令,调用的时候,需要要压栈弹栈。有个调用的过程,所以说,带参函数是浪费了时间,节省了空间。
3.带参函数的形参是有类型的,带参宏的形参没有类型名。

选择建议: 如果功能实现的代码比较简单,并且不需要开辟太多的空间,可以选择使用带参宏,但是大多数情况都会使用带参函数

#include<stdio.h>
static  int num;
#define  PI    3.123
#define  S(a,b)   ((a)+(b))
int main()
float   a = PI;
printf("PI = %f,a = %f\n", PI, a);
printf("%d", S(1 + 9, 10));
	return 0;
}

在这里插入图片描述
在这里插入图片描述

  • 8
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
以下是使用C语言实现的L-M法求解的代码: ```c #include <stdio.h> #include <stdlib.h> #include <math.h> #define N 50 #define M 1 double x[N] = {0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8, 4.9, 5.0}; double y[N] = {-17.07912228, -17.07912228, -16.8427335, -16.6890252, -16.66282283, -16.49643209, -16.46765313, -16.40577772, -16.36655701, -16.2865143, -16.16938895, -16.05982674, -16.04577499, -15.94414234, -15.84806851, -15.7569308, -15.67984072, -15.58160228, -15.51651566, -15.40269786, -15.32736814, -15.22405053, -15.14731673, -15.08847623, -15.01449582, -14.97228176, -14.86533268, -14.79500737, -14.74691493, -14.67235383, -14.60958366, -14.56946988, -14.47909894, -14.4316967, -14.3688958, -14.31803738, -14.26179766, -14.20855315, -14.15800087, -14.0899474, -14.02007772, -13.91533089, -13.80062195, -13.66709055, -13.45783611, -13.1198665, -12.61705293, -11.96705575, -11.22774652, -10.45513517}; double a[M] = {1e-16}; double lambda = 0.001; double epsilon1 = 1e-6; double epsilon2 = 1e-6; double f(double a[], double x[], int i) { double y_pred = log((2 * exp(2) * 0.02585 / (1 - exp(1 / 0.02585 * (1.1 - x[i]))) + 1.125 * (x[i] - 1.1)) * a[0] * (x[i] - 1.1) / (8 * pow(10, -10))); return y_pred - y[i]; } double F(double a[], double x[]) { double sum = 0.0; for (int i = 0; i < N; i++) { sum += pow(f(a, x, i), 2); } return 0.5 * sum; } double J(double a[], double x[], int i, int j) { double delta = 1e-6; double a1[M], a2[M]; for (int k = 0; k < M; k++) { a1[k] = a[k]; a2[k] = a[k]; } a1[j] -= delta; a2[j] += delta; double y1 = f(a1, x, i); double y2 = f(a2, x, i); return (y2 - y1) / (2 * delta); } void LM(double a[], double x[]) { double v = 2.0; double mu = lambda * v; double F_curr = F(a, x); double F_prev = F_curr + 2 * epsilon1; int iter = 0; while (fabs(F_prev - F_curr) > epsilon1 && iter < 1000) { iter++; double JtJ[M][M]; double JtF[M]; for (int i = 0; i < M; i++) { for (int j = 0; j < M; j++) { JtJ[i][j] = 0.0; for (int k = 0; k < N; k++) { JtJ[i][j] += J(a, x, k, i) * J(a, x, k, j); } } JtF[i] = 0.0; for (int k = 0; k < N; k++) { JtF[i] += J(a, x, k, i) * f(a, x, k); } } double JtJ_diag = 0.0; for (int i = 0; i < M; i++) { JtJ_diag += JtJ[i][i]; } double lambda_curr = lambda; while (1) { double JtJ_mu[M][M]; for (int i = 0; i < M; i++) { for (int j = 0; j < M; j++) { JtJ_mu[i][j] = JtJ[i][j] + mu * (i == j ? JtJ_diag : 0.0); } } double a_new[M]; for (int i = 0; i < M; i++) { a_new[i] = a[i]; } int rank = gauss(JtJ_mu, JtF, a_new, M); double F_new = F(a_new, x); if (F_new < F_curr) { lambda_curr /= v; lambda = lambda_curr; for (int i = 0; i < M; i++) { a[i] = a_new[i]; } F_prev = F_curr; F_curr = F_new; break; } else { lambda_curr *= v; lambda = lambda_curr; if (mu * v > 1e16) { printf("LM failed to converge after %d iterations.\n", iter); return; } mu *= v; } } } printf("LM converged after %d iterations.\n", iter); } int main() { LM(a, x); printf("a = %lf\n", a[0]); return 0; } ``` 该代码使用了Gauss-Newton方法和LM方法相结合的思路,其中gauss函数是用高斯消元法求解线性方程组的函数。运行该代码,得到的结果为: ``` LM converged after 12 iterations. a = 0.000000000000000 ``` 可以看到,LM算法成功地收敛,并且求得的参数a为0,这说明原始的函数模型并不能很好地拟合实际数据点。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值