黄金分割法_机械优化设计_C语言程序
黄金分割法的优化设计
实验报告
学院：机电工程
机制自动化11-03班
学号：************
姓名：***
1，黄金分割法的程序流程图
2，对应流程图的C语言程序
下面应用C语言程序利用黄金分割法求一元函数F=x^2+2*x的最优解，已知初始区间为[-3,5] ,取收敛精度e=10-4。
C语言程序如下：
#include<stdio.h>
#include<math.h>
#define f(x) pow(x,2)+2*x
#define M 0.618
void main()
{
double y1,y2,x1,x2,x,a,b,e;
int n;
n=1;
printf("请输入收敛精度e=");
scanf("%lf",&e);
printf("请输入区间左值a=");
scanf("%lf",&a);
printf("请输入区间右值b=");
scanf("%lf",&b);
printf("n a b x1 x2 y1 y2\n");
x1=b-M*(b-a);
x2=a+M*(b-a);
y1=f(x1);
y2=f(x2);
printf("%d %.4lf %.4lf %.4lf %.4lf %.4lf %.4lf\n",n,a,b,x1,x2,y1,y2);
n=n++;
do
{
if(y1<y2)
{
b=x2;
x2=x1;
y2=y1;
x1=b-M*(b-a);
y1=f(x1);
printf("%d %.4lf %.4lf %.4lf %.4lf %.4lf %.4lf\n",n,a,b,x1,x2,y1,y2);
n=n++;
}
else
{
a=x1;
x1=x2;
y1=y2;
x2=a+M*(b-a);
y2=f(x2);
printf("%d %.4lf %.4lf %.4lf %.4lf %.4lf %.4lf\n",n,a,b,x1,x2,y1,y2);
n=n++;
}
}while(fabs((b-a)/b)>=e&&fabs((y2-y1)/y2)>=e);
x=(a+b)*0.5;
printf("x=%.5lf\n",x);
getchar();
}
3.运行结果:
假定经十二次迭代后已满足收敛精度要求，则得x*=1/2(a+b)=1/2(-1.0214-0.9812)=-1.0013，相应的函数极值f(x*)=-0.9999；
近似精确值x*=-1,f(x*)=-1,与解析法求得的精确值相同。
黄金分割法与进退法的C语言程序
a=min[a1,a3]， b=max[a3,a1]，函数最小值所在的区间为[a， b] 。
我编的修改
#include<math.h> #include<stdio.h> #define f(x) 3*x*x*x-4*x+2 main() { double f1,f2,f3,temp,x1,x2,x3,h,a,b,Y1,Y2,A,A1,A2,e=0.2;
else if(f2<f1) { h=2*h;
x3=x2+h; f3=f(x3); }
while(f2>f3)
{ x1=x2;
x2=x3;
f2=f(x3);
x3=x2+h;
f3=f(x3);
}
a=x1<x3?x1:x3;
b=x1>x3?x1:x3;
printf("[%f,%f]\n",a,b);
A1=b+0.328*(b-a); Y1=f(A1);
基本思想：
对 f(x)任选一个初始点 a1 及初始步长 h， 通过比较这两点函数值的大小，确定 第三点位置，比较这三点的始步长 h＝h0，计算 y1＝f(a1)，
机械优化设计实验报告
一、实验目的本次实验旨在通过计算机编程，加深对机械优化设计方法的理解，掌握常用的优化算法，并能够利用计算机解决实际问题。
二、实验内容1. 黄金分割法（1）实验原理黄金分割法是一种常用的优化算法，适用于一元函数的极值求解。
其基本原理是：在给定初始区间内，通过迭代计算，逐步缩小搜索区间，直到满足收敛条件。
（2）实验步骤① 设计实验程序，实现黄金分割法的基本算法。
② 编写函数，用于计算一元函数的值。
③ 设置初始区间和收敛精度。
④ 迭代计算，更新搜索区间。
⑤ 判断是否满足收敛条件，若满足则输出结果，否则继续迭代。
（3）实验结果通过编程实现黄金分割法，求解函数f(x) = x^3 - 6x^2 + 9x + 1在区间[0, 10]内的极小值。
实验结果显示，该函数在区间[0, 10]内的极小值为1，且收敛精度达到0.001。
2. 牛顿法（1）实验原理牛顿法是一种求解非线性方程组的优化算法，其基本原理是：利用函数的导数信息，逐步逼近函数的极值点。
（2）实验步骤① 设计实验程序，实现牛顿法的基本算法。
② 编写函数，用于计算一元函数及其导数。
③ 设置初始值和收敛精度。
④ 迭代计算，更新函数的近似值。
⑤ 判断是否满足收敛条件，若满足则输出结果，否则继续迭代。
（3）实验结果通过编程实现牛顿法，求解函数f(x) = x^3 - 6x^2 + 9x + 1在区间[0, 10]内的极小值。
实验结果显示，该函数在区间[0, 10]内的极小值为1，且收敛精度达到0.001。
3. 拉格朗日乘数法（1）实验原理拉格朗日乘数法是一种求解约束优化问题的优化算法，其基本原理是：在约束条件下，构造拉格朗日函数，并通过求解拉格朗日函数的驻点来求解优化问题。
（2）实验步骤① 设计实验程序，实现拉格朗日乘数法的基本算法。
② 编写函数，用于计算目标函数、约束函数及其导数。
③ 设置初始值和收敛精度。
④ 迭代计算，更新拉格朗日乘数和约束变量的近似值。
黄金分割法C程序源代码
运行结果如下：
请输入初始点 t0=0
请输入初始步长 h=1
请输入加步系数 alpha(需大于 1)=2
f1=3.000000,f2=2.000000,t0=0.000000,t=1.000000,h=1.000000,k=0 f1=2.000000,f2=180.000000,t0=1.000000,t=3.000000,h=2.000000,k=1 [a,b]=[0.000000,3.000000] 第 1 次迭代的过程如下: [t1,t2]=[1.145898,1.854102] 第 2 次迭代的过程如下: [t1,t2]=[0.708204,1.145898] 第 3 次迭代的过程如下: [t1,t2]=[0.437694,0.708204] 第 4 次迭代的过程如下: [t1,t2]=[0.708204,0.875388] 第 5 次迭代的过程如下: [t1,t2]=[0.604878,0.708204] 第 6 次迭代的过程如下: [t1,t2]=[0.541020,0.604878] 第 7 次迭代的过程如下: [t1,t2]=[0.604878,0.644345] 第 8 次迭代的过程如下:
*a=t<t1?t:t1; *b=t>t1?t:t1; break; } } t1=t0+h; f1=f(t1); } }
double hjfg() { double beta,t1,t2,t; double f1,f2; double a=0,b=0; double *c,*d; int k=0; c=&a,d=&b; sb(c,d); printf("\n[a,b]=[%lf,%lf]",a,b);
优化设计黄金分割法实验报告
机械优化设计黄金分割法实验报告1、黄金分割法基本思路：黄金分割法适用于［a,b］区间上的任何单股函数求极小值问题，对函数除要求“单谷”外不做其他要求，甚至可以不连续。
因此，这种方法的适应面非常广。
黄金分割法也是建立在区间消去法原理基础上的试探方法，即在搜索区间［a,b］内适当插入两点al,a2,并计算其函数值。
al,a2将区间分成三段，应用函数的单谷性质，通过函数值大小的比较，删去其中一段，是搜索区间得以缩小。
然后再在保留下来的区间上作同样的处理，如此迭代下去，是搜索区间无限缩小，从而得到极小点的数值近似解。
2黄金分割法的基本原理一维搜索是解函数极小值的方法之一，其解法思想为沿某一已知方向求目标函数的极小值点。
一维搜索的解法很多，这里主要采用黄金分割法（0.618法）。
该方法用不变的区间缩短率0.618代替斐波那契法每次不同的缩短率，从而可以看成是斐波那契法的近似，实现起来比较容易，也易于人们所接受。
rl=a+O382(Js-a)r2=a+0,618(b-a)如图fi(r2)>f(rl)所以新区间为［迈以为新区间，继续求新的试点黄金分割法是用于一元函数f(x)在给定初始区间［a,b］内搜索极小点**的一种方法。
它是优化计算中的经典算法，以算法简单、收敛速度均匀、效果较好而著称，是许多优化算法的基础，但它只适用于一维区间上的凸函数⑹，即只在单峰区间内才能进行一维寻优，其收敛效率较低。
其基本原理是：依照“去劣存优”原则、对称原则、以及等比收缩原则来逐步缩小搜索区间［7］。
具体步骤是：在区间［a,b］内取点：al,a2把［a,b］分为三段。
如果f(a1)>f(a2),令a=a1,a1=a2,a2=a+r*(b-a);如果f(a1)<f(a2),令b=a2,a2=a1,a1=b-r*(b-a),如果|(b-a)/b|和|(y1-y2)/y2|都大于收敛精度e重新开始。
因为［a,b］为单峰区间，这样每次可将搜索区间缩小0.618倍或0.382倍，处理后的区间都将包含极小点的区间缩小，然后在保留下来的区间上作同样的处理，如此迭代下去，将使搜索区［a,b］逐步缩小，直到满足预先给定的精度时，即获得一维优化问题的近似最优解。
基于c语言的黄金分割法的优化设计
基于ｃ语言的黄金分割法的优化设计作者：王秀芳来源：《新西部下半月》2008年第08期【摘要】机械优化设计是适应生产现代化要求发展起来的一门崭新的学科。
它是在现代机械设计理论的基础上提出的一种更科学的设计方法，它可使机械产品的设计质量达到更高的要求。
基于黄金分割法提出的利用C语言程序求解全局最优解的方法，是一种相当简单而有效的方法。
【关键词】 C语言；黄金分割法；优化设计机械优化设计是应用数学方法寻求机械设计的最佳方案，首先要根据实际机械设计问题建立相应的数学模型，即用数学形式来描述实际机械设计问题。
在建立数学模型时，需要应用专业知识确定设计的限制条件和所追求的目标，确立各设计变量之间的相互关系等。
数学模型一旦建立，机械优化设计问题就变成一个数学求解。
应用数学规划方法的理论，根据数学模型的特点，可以选择适当的方法，以计算机作为工具，求得最佳设计参数。
非线性问题的求解一直是优化问题中的热点和难点，由于它是解决许多工程问题特别是控制问题的有效方法，所以受到人们极大的关注，并因此构造出许多求解约束和无约束优化问题的算法，如共轭方向法、二次插值法、进退法以及牛顿法等。
这些经典算法在各种实际问题中起到了非常重要的作用并显示出其独特的优点。
虽然已经有了不少很好的计算优化问题的方法，但好的方法总是不厌其多。
该文根据一维搜索中的黄金分割法提出一种利用C语言程序求解全局最优解的方法，这是一种相当简单而有效的方法。
一、黄金分割法及其基本原理黄金分割法是用于一元函数f（x）在确定的初始区间［a，b］内搜索极小点a*的一种方法。
它是优化计算中的经典算法，以算法简单、效果明显而著称，是许多优化算法的基础。
但它只适用于一维区间上的凸函数。
其基本思想是：依照“去坏留好”原则、对称原则、以及等比收缩原则来逐步缩小搜索范围。
具体地说，就是在区间［a，b］中取点x1=a+0.382(b-a)，x2=a+0.618(b-a)，如果f(x1)＞f(x2), 令a=x1；如果f(x1)≤f(x2),令b=x2，重新开始。
进退法黄金分割法c语言编程
进退法黄金分割法c语言编程黄金分割法（Golden Ratio）是一种常用的数学方法，它在艺术、设计和自然界中被广泛应用。
进退法（Backtracking）则是一种算法思想，常用于解决组合问题和搜索问题。
在C语言编程中，我们可以结合黄金分割法和进退法来解决一些复杂的问题，提高程序的效率和性能。
黄金分割法在数学上是指将一条线段分割为两个部分，使得整条线段与较短部分之比等于较短部分与较长部分之比。
在艺术和设计中，黄金分割法被用于确定画面的比例和构图，使得画面更加美观。
在自然界中，许多植物和动物的身体比例也遵循着黄金分割法。
在C语言编程中，我们可以借鉴黄金分割法的思想，将问题分割成更小的子问题，通过求解子问题来解决原始问题。
这就是进退法的基本思想。
进退法常用于解决组合问题和搜索问题，特别是需要穷举所有可能的解的情况。
例如，我们可以使用进退法来解决八皇后问题。
八皇后问题是一个经典的组合问题，在一个8×8的棋盘上放置八个皇后，使得任意两个皇后都不能互相攻击。
我们可以使用进退法来穷举所有可能的解，通过逐步尝试来找到符合条件的解。
首先，我们需要定义一个数据结构来表示棋盘，可以使用一个二维数组来表示，数组大小为8×8，每个元素表示一个方格，0表示该方格为空，1表示该方格有一个皇后。
然后，我们使用递归来实现进退法的思想。
从棋盘的第一行开始，我们逐个尝试在每个方格上放置皇后。
如果当前方格符合条件，我们继续递归地尝试在下一行放置皇后；如果当前方格不符合条件，我们回溯到上一行，继续在下一个方格上尝试。
在每一步的递归过程中，我们都可以使用黄金分割法来决定下一步尝试的方向。
黄金分割法将问题分割成两个子问题：一种是将当前方格标记为皇后，继续递归地解决下一行的问题；另一种是将当前方格不标记为皇后，回溯到上一行尝试下一个方格。
通过使用黄金分割法和进退法的思想，我们可以有效地解决八皇后问题和其他一些组合问题。
这种方法可以极大地减少穷举的次数，提高程序的效率和性能。
机械优化设计外推法,黄金分割法,二次插值法
for(;a1>a3;) {t=a3; a3=a1; a1=t; t=y1; y3=y1;
if(f(x1)>f(x2)) *a=x1; else *b=x2; *n=*n+1; s=hj(a,b,e,n); } return s; } void main() { double s,a,b,e,m; int n=0; printf("输入 a，b 值和精度 e 值\n"); scanf("%lf %lf %lf",&a,&b,&e); s=hj(&a,&b,e,&n); m=(a+b)/2; printf("a=%lf,b=%lf,s=%lf,m=%lf,n=%d\n",a,b,s,m,n); }
} } while(sqrt(pow((x[2][1]-x[0][1]),2)+ pow((x[2][2]-x[0][2]),2))>=1e-6); xx[1]=x[2][1]; xx[2]=x[2][2]; fi=fun2(xx[1],xx[2]); printf("the best answer is : \nx1*= %f\nx2*=%f\nf*=%f\n",xx[1],xx[2],fi);
for(i=1;i<=2;i++) { if(i==1) {d[i][1]=1;
机械优化设计-黄金分割法
总结：
• 一维搜索第一步:找初始单谷区间； 1.进退法
第二步:使区间缩小。 2.黄金分割法
二、一维搜索方法分类
根据插入点位置的确定方法，可以把一维搜索法 分成两大类： ⑴试探法：即按照某种规律来确定区间内插入点 的位置，如黄金分割法，斐波那契法等。
斐波那契数列：1、1、2、3、5、8、13、21 、34、55、89、144...... ⑵插值法（函数逼近法）：通过构造插值函数来 逼近原函数，用插值函数的极小点作为区间的插 入点，如二次插值法，三次插值法等。
y1=subs(f,a1); y2=subs(f,a2); if y1>y2 a=a1; a1=a2; y1=y2; a2=a+0.618*(b-a); disp(['判定： f1>=f2']); else b=a2; a2=a1; y2=y1; a1=a+0.382*(b-a); disp(['判定： f1<f2']); end
b=input('输入初始单谷区间右端点='); e=input('搜索精度（数值越小所求极小值精度越高） e='); k=0; format long; a1=a+0.382*(b-a); a2=a+0.618*(b-a); fprintf('第0次缩短区间\n'); fprintf('a1='); disp(a1); fprintf('a2='); disp(a2); while b-a>e
k=k+1; disp(['第',num2str(k),'次缩短区间']); fprintf('a1='); disp(a1); fprintf('a2='); disp(a2); end format long; xmin=(a+b)/2; fmin=subs(f,xmin); fprintf('迭代次数k='); disp(k); disp('极小值为'); disp('fmin ='); disp(fmin); fprintf('极小点为'); t=a:e/100:b; T=subs(f,t); plot(t,T);
基于C语言的黄金分割法的优化设计
算法的可靠性是指在合理 的精度要 求下 ， 一定计 算时 间内或一 在 定迭代次数 内， 求解优化问题的成功率 ， 越高则 可靠性越好 。
２ 效 率要 高 、
二 、 言 程 序 的 概 念 及 作 用 Ｃ语
算法的效率是指解题的效率 ， 如果 目标 函数和 约束 函数的 数值计 算 比较复杂时 ， 最好选用不计算梯度与 海色 矩阵的优化方 法， 尽可能选
设计 方法， 它可使机械产品的设计质量达到更 高的要求。基于黄金 分割法提 出的利用 Ｃ 言程序 求解全局最优解的方 法， 一种相 当简单 而 语 是
有效的方法。
【 关键词 】 Ｃ语言 ； 分割法 ； 化设计 黄金 优
机械优化设计是应 用数学 方法寻求机 械设计 的最佳 方案 ， 先要 首 根据实际机械设计问题建 立相应 的数学模 型 ， 即用数 学形 式来描 述实 际机械设计 问题 。在建立数 学模型 时 ， 需要应 用专业 知识 确定设 计的 限制条件和所追 求的目标 ， 确立 各设计变 量之 间的相 互关 系等 。数学 模型一旦建立 ， 机械优化设 计问题 就变成一 个数 学求解 。应用数 学规 划 方法 的理论 ， 根据数学模 型的 特点 ， 以选 择适 当的方 法 ， 可 以计 算机 ＋０ １ 的最优解 。已知初始区间为［ ， ］ 取迭代精度 ｅ ０３ 。 ２８ ， ＝ ．５
维普资讯
科 技 与 社 会
基于 Ｃ 语言的 黄金分割法的优化设计
基 于 Ｃ 言 的 黄 金 分 割 法 的优 化 设 计 语
王 秀 芳
（ 江 工 业职 业技 术 学 院 浙
机械优化设计c语言程序
计算f(x1,x2)=x0^2+x1^2-x0*x1-10*x0-4*x1+60#include "stdio.h"#include "stdlib.h"#include "math.h"double objf(double x[]){double ff;ff=x[0]*x[0]+x[1]*x[1]-x[0]*x[1]-10*x[0]-4*x[1]+60;return(ff);}void jtf(double x0[],double h0,double s[],int n,double a[],double b[]) {int i;double *x[3],h,f1,f2,f3;for(i=0;i<3;i++)x[i]=(double *)malloc(n*sizeof(double));h=h0;for(i=0;i<n;i++)*(x[0]+i)=x0[i];f1=objf(x[0]);for(i=0;i<n;i++)*(x[1]+i)=*(x[0]+i)+h*s[i];f2=objf(x[1]);if(f2>=f1){h=-h0;for(i=0;i<n;i++)*(x[2]+i)=*(x[0]+i);f3=f1;for(i=0;i<n;i++){*(x[0]+i)=*(x[1]+i);*(x[1]+i)=*(x[2]+i);}f1=f2;f2=f3;}for(;;){h=2*h;for(i=0;i<n;i++)*(x[2]+i)=*(x[1]+i)+h*s[i];f3=objf(x[2]);if(f2<f3) break;else{ for(i=0;i<n;i++){*(x[0]+i)=*(x[1]+i);*(x[1]+i)=*(x[2]+i);}f1=f2;f2=f3;}}if(h<0)for(i=0;i<n;i++){a[i]=*(x[2]+i);b[i]=*(x[0]+i);}elsefor(i=0;i<n;i++){a[i]=*(x[0]+i);b[i]=*(x[2]+i);}for(i=0;i<3;i++)free(x[i]);}double gold(double a[],double b[],double eps,int n,double xx[]) {int i;double f1,f2,*x[2],ff,q,w;for(i=0;i<2;i++)x[i]=(double *)malloc(n*sizeof(double));for(i=0;i<n;i++){*(x[0]+i)=a[i]+0.618*(b[i]-a[i]);*(x[1]+i)=a[i]+0.382*(b[i]-a[i]);}f1=objf(x[0]);f2=objf(x[1]);do{if(f1>f2){for(i=0;i<n;i++){b[i]=*(x[0]+i);*(x[0]+i)=*(x[1]+i);}f1=f2;for(i=0;i<n;i++)*(x[1]+i)=a[i]+0.382*(b[i]-a[i]);f2=objf(x[1]);}else{ for(i=0;i<n;i++){a[i]=*(x[1]+i);*(x[1]+i)=*(x[0]+i);}f2=f1;for(i=0;i<n;i++)*(x[0]+i)=a[i]+0.618*(b[i]-a[i]);f1=objf(x[0]);}q=0;for(i=0;i<n;i++)q=q+(b[i]-a[i])*(b[i]-a[i]);w=sqrt(q);}while(w>eps);for(i=0;i<n;i++)xx[i]=0.5*(a[i]+b[i]);ff=objf(xx);for(i=0;i<2;i++)free(x[i]);return(ff);}double oneoptim(double x0[],double s[],double h0,double epsg,int n,double x[]){double *a,*b,ff;a=(double *)malloc(n*sizeof(double));b=(double *)malloc(n*sizeof(double));jtf(x0,h0,s,n,a,b);ff=gold(a,b,epsg,n,x);free(a);free(b);return (ff);}double powell(double p[],double h0,double eps,double epsg,int n,double x[]){int i,j,m;double *xx[4],*ss,*s;double f,f0,f1,f2,f3,fx,dlt,df,sdx,q,d;ss=(double *)malloc(n*(n+1)*sizeof(double)); s=(double *)malloc(n*sizeof(double));for(i=0;i<n;i++){for(j=0;j<=n;j++)*(ss+i*(n+1)+j)=0;*(ss+i*(n+1)+i)=1;}for(i=0;i<4;i++)xx[i]=(double *)malloc(n*sizeof(double));for(i=0;i<n;i++)*(xx[0]+i)=p[i];for(;;){for(i=0;i<n;i++){*(xx[1]+i)=*(xx[0]+i);x[i]=*(xx[1]+i);}f0=f1=objf(x);dlt=-1;for(j=0;j<n;j++){for(i=0;i<n;i++){*(xx[0]+i)=x[i];*(s+i)=*(ss+i*(n+1)+j);}f=oneoptim(xx[0],s,h0,epsg,n,x); df=f0-f;if(df>dlt){dlt=df;m=j;}}sdx=0;for(i=0;i<n;i++)sdx=sdx+fabs(x[i]-(*(xx[1]+i))); if(sdx<eps){free(ss);free(s);for(i=0;i<4;i++)free(xx[i]);return(f);}for(i=0;i<n;i++)*(xx[2]+i)=x[i];f2=f;for(i=0;i<n;i++){*(xx[3]+i)=2*(*(xx[2]+i)-(*(xx[1]+i))); x[i]=*(xx[3]+i);}fx=objf(x);f3=fx;q=(f1-2*f2+f3)*(f1-f2-dlt)*(f1-f2-dlt); d=0.5*dlt*(f1-f3)*(f1-f3);if((f3<f1)||(q<d)){if(f2<=f3)for(i=0;i<n;i++)*(xx[0]+i)=*(xx[2]+i);elsefor(i=0;i<n;i++)*(xx[0]+i)=*(xx[3]+i);}else{for(i=0;i<n;i++){*(ss+(i+1)*(n+1))=x[i]-(*(xx[1]+i)); *(s+i)=*(ss+(i+1)*(n+1));}f=oneoptim(xx[0],s,h0,epsg,n,x);for(i=0;i<n;i++)*(xx[0]+i)=x[i];for(j=m+1;j<=n;j++)for(i=0;i<n;i++)*(ss+i*(n+1)+j-1)=*(ss+i*(n+1)+j);}}}void main(){double p[]={1,2};double ff,x[2];ff=powell(p,0.3,0.001,0.0001,2,x);printf("x[0]=%f,x[1]=%f,ff=%f\n",x[0],x[1],ff); getchar();}#include<stdio.h>#include<math.h>void main(){float x1[20],x2[20],y[20], a[20];floatX1, X2, ymin, e;int k;printf("input x1[0]x2[0] e\n");scanf("%f,%f,%f",&x1[0],&x2[0],&e); printf("x1\t\tx2\t\ty\t\ta\n");k=0;do{a[k]=(625*x2[k]*x2[k]+x1[k]*x1[k])/(2*x1[k]*x1[k]+625*50*x2[k]*x2[k]);x1[k+1]=x1[k]-a[k]*2*x1[k];x2[k+1]=x2[k]-a[k]*50*x2[k];y[k+1]=x1[k+1]*x1[k+1]+25*x2[k+1]*x2[k+1];printf("\n%f\t%f\t%f\t%f\t",x1[k+1],x2[k+1],y[k+1],a[k]); k=k+1;}while ((x1[k]-x1[k-1])<e);X1=x1[k];X2=x2[k];ymin=X1*X1+25*X2*X2;printf("\n%f\t%f\t%f",X1,X2,ymin);}3、抓屏结果黄金分割法1、数学模型Y=(x-2)(x-3)2、方法简介黄金分割法适用于[a,b]区间的任何单谷函数极小值问题。