今天给各位分享c语言求梯度的知识，其中也会对矩阵函数求梯度进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
本文目录一览：
1、求C语言高手编程2、C语言中 对于有限个的楼层,可以用switch,那么n个楼层,用什么？3、C语言题如图(需用switch语句)4、机械优化设计 变尺度法 c语言程序
求C语言高手编程
Numerical Recipes in C
一书及所附程序，有完整程序。不过我封装了它的C++版本，可以对但参数或多参数求极值，完整的头文件为：
#ifndef __OPTIMIZATION_H__
#define __OPTIMIZATION_H__
//////////////////////////////////////////////////////////////////////////
// class TOptimization
//
// $ 求函数一个或多个参数的最小值
//
// 该类默认对一个参数优化，一般只要输入优化参数数目
// 优化目标函数就可以使用。
//
// …主要代码来自：
// Numerical Recipes in C++
// The Art of Scientific Computing
// Second Edition
// William H. Press Saul A. Teukolsky
// William T. Vetterling Brian P. Flannery
//
// 中译本：
// C++ 数值算法(第二版) 胡健伟 赵志勇 薛运华 等译
// 电子工业出版社 北京 (2005)
//
// Author: Jian Feng
// Email: fengj@tom.com
// Dec. 9, 2006
//
//////////////////////////////////////////////////////////////////////////
//
// 输入函数：
//
// @MaxIterationStep: 最大迭代次数， 默认 1000
// @ParameterNumbers: 优化参数数目， 默认 1
// @InitMatrix: 初始化矩阵参数(N*N)， 默认
// @Tolerance: 容许公差， 默认 1E-7
//
// 执行函数：
//
// @ExecutePowell: 利用powell方法进行多参数优化
// @ExecuteBrent: 利用brent方法进行单参数优化
//
// 输出函数：
//
// @OptimizatedParameters: 优化结果数据
// @ObjectiveFunctionValue: 目标函数在优化值处的值
//
// 使用示例：
//
// 1. 单参数
// double objfun(double a){
// double sum = 0;
// for(int i = 0; i DataPoints; ++i)
// sum += SQR(Exps[i] – Theo(a));
// }
// double value
// TOptimization opt;
// if(opt.ExecuteBrent(objfun, -10, -1)) opt.OptimizatedParameters(value);
//
// 2. 多参数
// double objfun(double *a){
// double sum = 0;
// for(int i = 0; i DataPoints; ++i)
// sum += SQR(Exps[i] – Theo(a));
// }
// double value[3]
// TOptimization opt(3);
// double ival[3] = {-1, 0, 1};
// if(opt.ExecutePowell(objfun, ival)) opt.OptimizatedParameters(value);
//
namespace{
static int ncom; //公用变量
static double *pcom_p; //公用变量
static double *xicom_p; //公用变量
static double (*nrfunc)(double*); //公用函数指针
}
class TOptimization
{
private:
typedef double (*Reff)(double *);
typedef double (*Ptrf)(double );
public:
TOptimization(int n = 1);
~TOptimization(){ FreeMemory(); }
//主要方法
void ParameterNumbers(int n){ FreeMemory(); num = n; AllocateMemory(); }
//利用powell方法对一个或多个参数优化
bool ExecutePowell(Reff obj, double *a = 0);
//利用brent方法对一个参数优化，需给出参数所在的区间
bool ExecuteBrent(Ptrf obj, double vFrom = 0, double vTo = 1);
void OptimizatedParameters(double *a){ for(int i=0; inum; ++i) a[i]=coef[i];}
void OptimizatedParameters(double a){ a = vmin; }
//void OptimizatedParameters(double *a){
// if(method) for(int i=0; inum; ++i) a[i]=coef[i];
// else *a = vmin;
//}
//其它方法
void InitMatrix(double **m)
{
for(int i=0; inum; ++i)
for(int j = 0; jnum; ++j)
matx[i][j]=m[i][j];
setm = true;
}
void MaxIterationStep(int s){ ITMAX = s; }
void Tolerance(double eps){ ftol = eps; }
double ObjectiveFunctionValue()const{ return fret; }
private:
double brent(double ax, double bx, double cx, Ptrf f, double tol, double xmin, int flag);
void mnbrak(double ax, double bx, double cx, double fa, double fb, double fc, Ptrf func);
void linmin(double *p, double *xi, double fret, Reff func);
bool powell(double *p, double **xi, double ftol, int iter, double fret, Reff func);
void shft2(double a, double b, const double c){ a=b; b=c; }
void shft3(double a, double b, double c, const double d){ a=b; b=c; c=d; }
double SQR(double x){ return x * x; }
void SWAP(double a, double b){ double dum=a; a=b; b=dum; }
double SIGN(const double a, const double b){return b = 0?(a=0?a:-a):(a=0?-a:a);}
double MAX(const double a, const double b){return b a ? (b) : (a);}
void AllocateMemory();
void FreeMemory();
static double f1dim(double x)
{
int j;
double *xt = new double [ncom];
//Vec_Dp pcom=*pcom_p,xicom=*xicom_p;
double *pcom = pcom_p, *xicom = xicom_p;
for (j=0;jncom;j++)
xt[j]=pcom[j]+x*xicom[j];
//delete []xt;
double val = nrfunc(xt);
delete []xt;
return val;
}
bool setm; //是否设置优化方向初始矩阵
int num; //优化参数
int ITMAX; //最大迭代数
int iter; //实际迭代步数
int method; //优化方法 0: 1-D brent, 2: M-D Powell
double vmin; //一维优化参数
double ftol; //容许差
double fret; //目标函数值
double *coef; //多维优化参数值
double **matx; //多维优化参数方向的初始值
};
//////////////////////////////////////////////////////////////////////////
inline TOptimization::TOptimization(int n )
{
num = n;
ftol = 1e-7;
ITMAX = 1000;
iter = 0;
fret = 0.;
vmin = 0.;
method = 0;
setm = false;
AllocateMemory();
}
inline void TOptimization::AllocateMemory()
{
pcom_p = new double [num];
xicom_p = new double [num];
coef = new double [num];
matx = new double *[num];
for(int i = 0; i num; ++i)
{
coef[i] = 0.;
matx[i] = new double [num];
for(int j = 0; j num; ++j)
matx[i][j]=(i == j ? 1.0 : 0.0);
}
}
inline void TOptimization::FreeMemory()
{
for(int i = 0; i num; ++i)
{
delete []matx[i];
}
delete []matx;
delete []pcom_p;
delete []xicom_p;
delete []coef;
}
inline bool TOptimization::ExecutePowell(Reff obj, double *a)
{
method = 1;
if(a)
for(int i = 0; i num; ++i) coef[i] = a[i];
return powell(coef, matx, ftol, iter, fret, obj);
}
inline bool TOptimization::ExecuteBrent(Ptrf obj, double vFrom, double vTo)
{
method = 0;
int flag;
double cx, fa, fb, fc;
mnbrak(vFrom,vTo,cx,fa,fb,fc,obj);
fret = brent(vFrom,vTo,cx,obj, ftol,vmin, flag);
return flag ? true : false;
}
inline void TOptimization::mnbrak(double ax, double bx, double cx, double fa,
double fb, double fc, Ptrf func)
{
const double GOLD=1.618034,GLIMIT=100.0,TINY=1.0e-20;
double ulim,u,r,q,fu;
fa=func(ax);
fb=func(bx);
if (fb fa) {
SWAP(ax,bx);
SWAP(fb,fa);
}
cx=bx+GOLD*(bx-ax);
fc=func(cx);
while (fb fc) {
r=(bx-ax)*(fb-fc);
q=(bx-cx)*(fb-fa);
u=bx-((bx-cx)*q-(bx-ax)*r)/
(2.0*SIGN(MAX(fabs(q-r),TINY),q-r));
ulim=bx+GLIMIT*(cx-bx);
if ((bx-u)*(u-cx) 0.0) {
fu=func(u);
if (fu fc) {
ax=bx;
bx=u;
fa=fb;
fb=fu;
return;
} else if (fu fb) {
cx=u;
fc=fu;
return;
}
u=cx+GOLD*(cx-bx);
fu=func(u);
} else if ((cx-u)*(u-ulim) 0.0) {
fu=func(u);
if (fu fc) {
shft3(bx,cx,u,cx+GOLD*(cx-bx));
shft3(fb,fc,fu,func(u));
}
} else if ((u-ulim)*(ulim-cx) = 0.0) {
u=ulim;
fu=func(u);
} else {
u=cx+GOLD*(cx-bx);
fu=func(u);
}
shft3(ax,bx,cx,u);
shft3(fa,fb,fc,fu);
}
}
inline double TOptimization::brent(double ax, double bx, double cx,
Ptrf f, double tol, double xmin, int flag)
{
flag = 1;
const double CGOLD=0.3819660;
const double ZEPS=1.0e-20;
int iter;
double a,b,d=0.0,etemp,fu,fv,fw,fx;
double p,q,r,tol1,tol2,u,v,w,x,xm;
double e=0.0;
a=(ax cx ? ax : cx);
b=(ax cx ? ax : cx);
x=w=v=bx;
fw=fv=fx=f(x);
for (iter=0;iterITMAX;iter++) {
xm=0.5*(a+b);
tol2=2.0*(tol1=tol*fabs(x)+ZEPS);
if (fabs(x-xm) = (tol2-0.5*(b-a))) {
xmin=x;
return fx;
}
if (fabs(e) tol1) {
r=(x-w)*(fx-fv);
q=(x-v)*(fx-fw);
p=(x-v)*q-(x-w)*r;
q=2.0*(q-r);
if (q 0.0) p = -p;
q=fabs(q);
etemp=e;
e=d;
if (fabs(p) = fabs(0.5*q*etemp) || p = q*(a-x) || p = q*(b-x))
d=CGOLD*(e=(x = xm ? a-x : b-x));
else {
d=p/q;
u=x+d;
if (u-a tol2 || b-u tol2)
d=SIGN(tol1,xm-x);
}
} else {
d=CGOLD*(e=(x = xm ? a-x : b-x));
}
u=(fabs(d) = tol1 ? x+d : x+SIGN(tol1,d));
fu=f(u);
if (fu = fx) {
if (u = x) a=x; else b=x;
shft3(v,w,x,u);
shft3(fv,fw,fx,fu);
} else {
if (u x) a=u; else b=u;
if (fu = fw || w == x) {
v=w;
w=u;
fv=fw;
fw=fu;
} else if (fu = fv || v == x || v == w) {
v=u;
fv=fu;
}
}
}
flag = 0;
xmin=x;
return fx;
}
inline void TOptimization::linmin(double *p, double *xi, double fret, Reff func)
{
int j, flag;
const double TOL=1.0e-8;
double xx,xmin,fx,fb,fa,bx,ax;
int n=num;
ncom=n;
//pcom_p=new Vec_Dp(n);
//xicom_p=new Vec_Dp(n);
nrfunc=func;
//Vec_Dp pcom=*pcom_p,xicom=*xicom_p;
double *pcom = pcom_p, *xicom = xicom_p;
for (j=0;jn;j++) {
pcom[j]=p[j];
xicom[j]=xi[j];
}
ax=0.0;
xx=1.0;
mnbrak(ax,xx,bx,fa,fx,fb,f1dim);
fret=brent(ax,xx,bx,f1dim,TOL,xmin, flag);
for (j=0;jn;j++) {
xi[j] *= xmin;
p[j] += xi[j];
}
//delete xicom_p;
//delete pcom_p;
}
inline bool TOptimization::powell(double *p, double **xi, double ftol, int iter,
double fret, Reff func)
{
const int ITMAX=500;
const double TINY=1.0e-20;
int i,j,ibig;
double del,fp,fptt,t;
int n=num;
//Vec_Dp pt(n),ptt(n),xit(n);
double *pt, *ptt, *xit;
for(i = 0; i n; ++i)
{
pt = new double [n];
ptt = new double [n];
xit = new double [n];
}
fret=func(p);
for (j=0;jn;j++) pt[j]=p[j];
for (iter=0;;++iter) {
fp=fret;
ibig=0;
del=0.0;
for (i=0;in;i++) {
for (j=0;jn;j++) xit[j]=xi[j][i];
fptt=fret;
linmin(p,xit,fret,func);
if (fptt-fret del) {
del=fptt-fret;
ibig=i+1;
}
}
if (2.0*(fp-fret) = ftol*(fabs(fp)+fabs(fret))+TINY) {
delete []pt;
delete []ptt;
delete []xit;
return true;
}
if (iter == ITMAX)
{
delete []pt;
delete []ptt;
delete []xit;
return false;
//cerr”powell exceeding maximum iterations.”;
}
for (j=0;jn;j++) {
ptt[j]=2.0*p[j]-pt[j];
xit[j]=p[j]-pt[j];
pt[j]=p[j];
}
fptt=func(ptt);
if (fptt fp) {
t=2.0*(fp-2.0*fret+fptt)*SQR(fp-fret-del)-del*SQR(fp-fptt);
if (t 0.0) {
linmin(p,xit,fret,func);
for (j=0;jn;j++) {
xi[j][ibig-1]=xi[j][n-1];
xi[j][n-1]=xit[j];
}
}
}
}
}
#endif
C语言中 对于有限个的楼层,可以用switch,那么n个楼层,用什么？
C语言switch是针对已知的优先个条件做分支处理，如果n种可能取值，且n是一个变量的话，那么不能用switch，而要设计合适的算法。
例如：
int floor = 1;
switch (floor)
{
case 1:
case 2: action1(); // 执行动作1
break; // 不执行任何其他动作
case 3:
case 4: action2(); // 执行动作2
break; // 不执行默认的动作
default:
printf( “不支持该楼层送货” ); // 如果没有识别到任何命令，输出一个警告信息
}
如果floor取值不是1-4而是变化的，那么假设每2层一个送货价格的梯度
可以直接计算：
add_step=floor/2;
price = base + add*add_step;
C语言题如图(需用switch语句)
#includestdio.h
int main() {
// 金额的四个梯度
int arrAmount[] = { 1000, 500, 200, 0 };
// 每个梯度对应的折扣
double arrDiscount[] = { 0.7, 0.8, 0.9, 1.0 };
int index = -1, i = 0;
double discount = 1.0, realAmount = 0;
printf(“请输入金额：”);
int amount;
scanf(“%d”, amount);
if (amount 0) {
printf(“输入金额必须为非负数”);
return 1;
}
// 查找当前输入金额所对应的折扣率
for (i = 0; i 4; i++) {
if (amount = arrAmount[i]) {
index = i;
break;
}
}
// 当前金额对应的折扣率计算
switch(index) {
case 0:
discount = arrDiscount[0];
realAmount = amount * arrDiscount[0];
break;
case 1:
discount = arrDiscount[1];
realAmount = amount * arrDiscount[1];
break;
case 2:
discount = arrDiscount[2];
realAmount = amount * arrDiscount[2];
break;
case 3:
discount = arrDiscount[3];
realAmount = amount * arrDiscount[3];
break;
default:
return 1;
}
printf(“折扣率：%.2lf, 实际金额：%.2lf”, discount, realAmount);
return 0;
}
这道题真正的难点在于根据金额查找到对应的折扣率，通过从1000到0所有梯度的金额对比就能得到输入金额对应的折扣率。
机械优化设计 变尺度法 c语言程序
计算 f(x1,x2)=x1^2+2*x2^2-4*x1-2*x1*x2 的无约束极值，初始点x0=[1,1]。
/*
tt —- 一维搜索初始步长
ff —- 差分法求梯度时的步长
ac —- 终止迭代收敛精度
ad —- 一维搜索收敛精度
n —– 设计变量的维数
xk[n] — 迭代初始点
*/
#includestdio.h
#includestdlib.h
#includemath.h
#includeconio.h
#define tt 0.01
#define ff 1.0e-6
#define ac 1.0e-6
#define ad 1.0e-6
#define n 2
double ia;
double fny(double *x)
{
double x1=x[0],x2=x[1];
double f;
f=x1*x1+2*x2*x2-4*x1-2*x1*x2;
return f;
}
double * iterate(double *x,double a,double *s)
{
double *x1;
int i;
x1=(double *)malloc(n*sizeof(double));
for(i=0;in;i++)
x1[i]=x[i]+a*s[i];
return x1;
}
double func(double *x,double a,double *s)
{
double *x1;
double f;
x1=iterate(x,a,s);
f=fny(x1);
return f;
}
void finding(double a[3],double f[3],double *xk,double *s)
{
double t=tt;
int i;
double a1,f1;
a[0]=0;f[0]=func(xk,a[0],s);
for(i=0;;i++)
{
a[1]=a[0]+t;
f[1]=func(xk,a[1],s);
if(f[1]f[0]) break;
if(fabs(f[1]-f[0])=ad)
{
t=-t;
a[0]=a[1];f[0]=f[1];
}
else
{
if(ia==1) return; //break
t=t/2;ia=1;
}
}
for(i=0;;i++)
{
a[2]=a[1]+t;
f[2]=func(xk,a[2],s);
if(f[2]f[1]) break;
t=2*t;
a[0]=a[1];f[0]=f[1];
a[1]=a[2];f[1]=f[2];
}
if(a[0]a[2])
{
a1=a[0];
f1=f[0];
a[0]=a[2];
f[0]=f[2];
a[2]=a1;
f[2]=f1;
}
return;
}
double lagrange(double *xk,double *ft,double *s)
{
int i;
double a[3],f[3];
double b,c,d,aa;
finding(a,f,xk,s);
for(i=0;;i++)
{
if(ia==1) { aa=a[1]; *ft=f[1]; break; }
d=(pow(a[0],2)-pow(a[2],2))*(a[0]-a[1])-(pow(a[0],2)-pow(a[1],2))*(a[0]-a[2]);
if(fabs(d)==0) break;
c=((f[0]-f[2])*(a[0]-a[1])-(f[0]-f[1])*(a[0]-a[2]))/d;
if(fabs(c)==0) break;
b=((f[0]-f[1])-c*(pow(a[0],2)-pow(a[1],2)))/(a[0]-a[1]);
aa=-b/(2*c);
*ft=func(xk,aa,s);
if(fabs(aa-a[1])=ad) {if(*ftf[1]) aa=a[1];break;}
if(aaa[1])
{
if(*ftf[1]) {a[2]=aa;f[2]=*ft;}
else if(*ftf[1]) {a[0]=a[1];a[1]=aa;f[0]=f[1];f[1]=*ft;}
else if(*ft==f[1])
{
a[2]=aa;a[0]=a[1];
f[2]=*ft;f[0]=f[1];
a[1]=(a[0]+a[2])/2;
f[1]=func(xk,a[1],s);
}
}
else
{
if(*ftf[1]) {a[0]=aa;f[0]=*ft;}
else if(*ftf[1]) {a[2]=a[1];a[1]=aa;f[2]=f[1];f[1]=*ft;}
else if(*ft==f[1])
{a[0]=aa;a[2]=a[1];
f[0]=*ft;f[2]=f[1];
a[1]=(a[0]+a[2])/2;
f[1]=func(xk,a[1],s);
}
}
}
if(*ftf[1]) {*ft=f[1];aa=a[1];}
return aa;
}
double *gradient(double *xk)
{
double *g,f1,f2,q;
int i;
g=(double*)malloc(n*sizeof(double));
f1=fny(xk);
for(i=0;in;i++)
{q=ff;
xk[i]=xk[i]+q; f2=fny(xk);
g[i]=(f2-f1)/q; xk[i]=xk[i]-q;
}
return g;
}
double * bfgs(double *xk)
{
double u[n],v[n],h[n][n],dx[n],dg[n],s[n];
double aa,ib;
double *ft,*xk1,*g1,*g2,*xx,*x0=xk;
double fi;
int i,j,k;
ft=(double *)malloc(sizeof(double));
xk1=(double *)malloc(n*sizeof(double));
for(i=0;in;i++)
{
s[i]=0;
for(j=0;jn;j++)
{
h[i][j]=0;
if(j==i) h[i][j]=1;
}
}
g1=gradient(xk);
fi=fny(xk);
x0=xk;
for(k=0;kn;k++)
{
ib=0;
if(ia==1) { xx=xk; break; }
ib=0;
for(i=0;in;i++) s[i]=0;
for(i=0;in;i++)
for(j=0;jn;j++)
s[i]+= -h[i][j]*g1[j];
aa=lagrange(xk,ft,s);
xk1=iterate(xk,aa,s);
g2=gradient(xk1);
for(i=0;in;i++)
if((fabs(g2[i])=ac)(fabs(g2[i]-g1[i])=ac))
{ib=ib+1;}
if(ib==0) { xx=xk1; break; }
fi=*ft;
if(k==n-1)
{ int j;
xk=xk1;
for(i=0;in;i++)
for(j=0;jn;j++)
{
h[i][j]=0;
if(j==i) h[i][j]=1;
}
g1=g2; k=-1;
}
else
{
int j;
double a1=0,a2=0;
for(i=0;in;i++)
{
dg[i]=g2[i]-g1[i];
dx[i]=xk1[i]-xk[i];
}
for(i=0;in;i++)
{
int j;
u[i]=0;v[i]=0;
for(j=0;jn;j++)
{
u[i]=u[i]+dg[j]*h[j][i];
v[i]=v[i]+dg[j]*h[i][j];
}
}
for(j=0;jn;j++)
{
a1+=dx[j]*dg[j];
a2+=v[j]*dg[j];
}
if(fabs(a1)!=0)
{
a2=1+a2/a1;
for(i=0;in;i++)
for(j=0;jn;j++)
h[i][j]+=(a2*dx[i]*dx[j]-v[i]*dx[j]-dx[i]*u[j])/a1;
}
xk=xk1; g1=g2;
}
}
if(*ftfi) { *ft=fi; xx=xk;}
xk=x0;
return xx;
}
void main ()
{
int k;
double *xx,f;
double xk[n]={1,1};
xx=bfgs(xk);
f=fny(xx);
printf(“\n\nThe Optimal Design Result Is:\n”);
for(k=0;kn;k++)
{printf(“\n\tx[%d]*=%f”,k+1,xx[k]);}
printf(“\n\tf*=%f”,f);
getch();
}
这是基于一本书上的算法。但我很奇怪，原书中的算法有结果列出，但是我却不能通过编译。真是纳闷！修改后可以得到结果了，如果你要使用这个简单的程序，你只需更改 维数n、double fny(double *x)的实现部分以及main函数中的xk初值就可以了。不过这个程序也不是很好。
c语言求梯度的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于矩阵函数求梯度、c语言求梯度的信息别忘了在本站进行查找喔。
微信扫一扫 
支付宝扫一扫 
