梯度法和牛顿法，利用导函数查找函数的极值与方程根

int fun1()
{
printf("原始函数: y=X * X + 1，其导函数为：f'(y)=2x，输入初始值：");

int InputValue=0;
cin>>InputValue;

// 设置初始点
double x=InputValue;
// 每次增减值
double Step=0.001;

double lastx=x;
int k=0;
while (true)
{
// 求导数值
double d=2*x;

// 如果导数值小于零，需要将x值加大；如果导数值大于零，需要将x值减小
x=x-d*Step;

// 如果导数值为零那么说明到达了极点位置
// if (d==0) break; 其实这句话在计算机里面不能成立，因为双精度型不会绝对等于零，只有无限接近于零

// 只能采用另一种方法，本次的x值和上一次的x值之差，小于一定值的时候，就可以停止了
double t=0;

if (lastx < x){
t=x - lastx;
}
else{
t=lastx - x;
}

t=t / x;
// 达到指定的精度，就停止
if (t < 0) t=0-t;
if (t <= 0.0001) break;

lastx=x;

k++;
}

double y=x * x + 1;
printf("\r\n初始值：%d，极点在: [%.3lf, %.3lf]，循环了%d次\r\n",InputValue,x,y,k);

InputValue=0;
cin>>InputValue;

return 0;
}

const DC=4;

// 生成数据集
void CreateDataList(double* X, double* Y, double* Z)
{
// 随机生成据
int MaxNumber=20;
// srand(time(0));
srand(9);
int N=0;
while (N < DC){
X[N]=rand()%MaxNumber+1;
Y[N]=rand()%MaxNumber+1;
// 原函数: Z=2X*X + 9Y*Y;
Z[N]=2*X[N]*X[N] + 9*Y[N] + X[N]*Y[N];
printf("训练数据集: [%.0lf, %.0lf, %.0lf]\r\n",X[N],Y[N],Z[N]);
N++;
}

}

int main()
{

printf("原始函数: Z=2 * X * X + 9 * Y + X * Y 产生的输入如下：\r\n");

// 生成数据集
double X[DC]={0};
double Y[DC]={0};
double Z[DC]={0};

CreateDataList(X,Y,Z);

printf("拟合函数: Z=a * X * X + b * Y + c\r\n");

/*
创造拟合函数，采用的函数不一定要跟原来的一样，毕竟现实中很难知道原函数是什么，或许也没有原函数，
但是有一点可以确定的是：用不同的函数可以画出同样的坐标曲线图

设用于拟合的函数为：f(X,Y)=a*X*X + b*Y + c

现在就是要让计算机帮找出合适的a,b,c值，有点像大体框架我来搭，继续细节完善让计算机来做


采用最新二乘法作为损失函数: H=(f(X,Y) - Z) * (f(X,Y) - Z) / (2*DC)
实际就是用拟合函数 减 训练集的数据，把这个误差当做做事依据

a 偏导数: H'(a)=(f(X,Y) - Z) * X*X
b 偏导数: H'(b)=(f(X,Y) - Z) * Y
c 偏导数: H'(b)=(f(X,Y) - Z) * 1
*/

double loss=0;

// 每次增减值
double Step=0.001;

// 设置初始点
double a=0;
double b=30;
double c=1;

int K=0;
while (true)
{

// 偏导数的值
double FA=0;
double FB=0;
double FC=0;

int N=0;
while (N < DC){
double ParamX=X[N];
double ParamY=Y[N];


// 将数据集的X,Y数值代入拟合函数
double F=a*ParamX*ParamX + b*ParamY + c;
// 将数据集的X,Y,Z数值代入偏导函数
double Fa=(F-Z[N]) * ParamX*ParamX;
double Fb=(F-Z[N]) * ParamY;
double Fc=(F-Z[N]) * 1;


// 累计偏导数的值
Fa/=1000;
Fb/=1000;
Fc/=1000;
FA+=Fa;
FB+=Fb;
FC+=Fc;

N++;
}

// 本来设想：在某偏导函数某一次的运算后找到极值就停止了，以后的循环里不再计算这个变量偏导函数，
// 但是这样做是错的，因为拟合函数每一次运算都会用到所有变量，而导致每次的导数正负变化都不一样。

// 网上很多教程喜欢用导数值参与运算，我不太喜欢，我更喜欢自己微调，所以把下面三句代码注释掉了
// a=a - (FA * Step / DC);
// b=b - (FB * Step / DC);
// c=c - (FC * Step / DC);

// 其实在实际应用中更加灵活，可以采用类似二分查找法一样，估算值进行跳跃，可大大缩减循环次数
double fu=0;
if (FA < 0){
fu=Step;
}
else{
fu=0-Step;
}
a+=fu;


fu=0;
if (FB < 0){
fu=Step;
}
else{
fu=0-Step;
}
b+=fu;


fu=0;
if (FC < 0){
fu=Step;
}
else{
fu=0-Step;
}
c+=fu;


loss=0;
N=0;
while (N < DC){
double ParamX=X[N];
double ParamY=Y[N];

// 将数据集的X,Y数值代入拟合函数
double F=a*ParamX*ParamX + b*ParamY + c;
// 拟合函数和原值的差
double T=(F-Z[N]);
double error=(T*T) / (2*DC);

loss+=error;

N++;
}

// 达到指定精度，停止循环
if (loss <= 0.01) break;

// 有时候怎么算都达不到指定的精度，所以得设置其他的终止循环条件
// 这里省事，限制循环次数
if (K++ > 10000000) break;
// 也可以设置函数超时，if (time > 超时值) break;
}

printf("\r\n得出拟合函数函数: Z=%.3lf * X * X + %.3lf * Y + %.3lf\r\n",a,b,c);
printf("结果: [a=%.3lf, b=%.3lf, c=%3.lf],循环次数: %d,精度: %.3lf\r\n",a,b,c,K,loss);


int N=0;
while (N < DC){
double ParamX=X[N];
double ParamY=Y[N];

// 将数据集的X,Y数值代入函数
double F=a*ParamX*ParamX + b*ParamY + c;
// 将数据集的X,Y,Z数值代入偏导函数
printf("原值 / 拟合值: %.3lf / %.3lf\r\n",Z[N],F);

N++;
}

int InputValue=0;
cin>>InputValue;


return 0;
}