精华内容
下载资源
问答
  • 0.618法的C语言程序 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 0.618法 1.用C或C++等编程语言编写0.618法的程序并...
  • 用python实现的优化方法中的0.618法,chushi这个程序时选择初值,0.618是正常的程序。
  • 最优化方法:0.618法与Fibonacci法.ppt
  • 0.618法求一元函数ft=t^2+2*t在区间[-3,5]中的极小点要求计算到区间的长度小于0.05 用MATLAB编程如下 function [x,minf]=minHJ(f,a,b,eps) format long; if nargin==3 eps=0.05; end l=a+0.382(b-a
  • 黄金分割法也称为中外比,指把一条线段分割为两部分,使其中一部分与全长之比等于另一部分与这...其比值是一个无理数,取其前三位数字的近似值是0.618,所以也称为0.618法。里面含有黄金分割法求解函数极值的c++代码。
  • 0.618法C程序

    2014-09-25 10:52:49
    0.618法C程序
  • 0.618法

    2021-01-08 18:36:57
    0.618法(黄金分割法)0.618法求极小点代码 (黄金分割法)0.618法求极小点 给:f(x),范围[a,b],精度ε(无,则默认为0) 过程① x1 = b - 0.618 * (b - a)。 x2 = a + 0.618 * (b - a)。 过程② 当f(x1) < f(x2...

    (黄金分割法)0.618法求极小点

    给:f(x),范围[a,b],精度ε(无,则默认为0)
    过程①
    x1 = b - 0.618 * (b - a)。
    x2 = a + 0.618 * (b - a)。
    过程②
    当f(x1) < f(x2)时, b = x2, a不变,再求x1,x2。
    当f (x1) > f(x2)时, a = x1, b不变,再求x1,x2。
    过程③
    当|b - a| < ε时,最优解 x* = (b + a) / 2。
    例:过程②
    在这里插入图片描述

    代码

    import sympy
    import numpy as np
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
    x=sympy.Symbol('x')
    a=sympy.Symbol('a')
    b=sympy.Symbol('b')
    f=(x)**2-3*x+5
    epsi=0.05
    r=0.618
    xb=b-r*(b-a)
    xa=a+r*(b-a)
    def accucy(a1,b1):
        lx1 = []
        ly1 = []
        lx2 = []
        ly2 = []
        x1=xb.evalf(subs={b:b1,a:a1})
        x2=xa.evalf(subs={b:b1,a:a1})
        for i in range(1000): #主要的求解过程,默认为1000次循环,不可能无限循环
            fx1=f.evalf(subs={x:x1})
            fx2=f.evalf(subs={x:x2})
            lx1.append(x1)
            ly1.append(fx1)
            lx2.append(x2)
            ly2.append(fx2)
            print(a1,b1)
            if (b1-a1)<epsi:
                print((b1+a1)/2)
                break
            if fx1>fx2:
                a1=x1
                x1=x2
                x2=xa.evalf(subs={b:b1,a:a1})
            else:
                b1=x2
                x2=x1
                x1=xb.evalf(subs={b:b1,a:a1})
    
        lx=lx1+lx2[:0:-1]
        ly=ly1+ly2[:0:-1]
        plt.plot(lx, ly, marker='o', color="red", label="0.168法")
    def Graph():
        ly=[]
        lx=[]
        for i in np.arange(1,2,0.05):
            dk=f.evalf(subs={x:i})
            ly.append(dk)
            lx.append(i)
            print(i,dk)
        plt.plot(lx, ly, marker="o", color="blue",label="f函数")
    accucy(1,2)
    Graph()
    plt.legend()
    plt.show()
    
    

    在这里插入图片描述

    展开全文
  • 0.618法的matlab实现 精品文档 精品文档 收集于网络如有侵权请联系管理员删除 收集于网络如有侵权请联系管理员删除 精品文档 收集于网络如有侵权请联系管理员删除 实 验 报 告 实验题目: 0.618法的MATLAB实现 学生...
  • 0.618法和fibonacci法的matlab算法
  • matlab实现进退法、0.618法、牛顿法

    千次阅读 2020-12-31 17:11:59
    文章目录实验一 一维最优化方法实验目的及要求:实验原理:算法1:进退法算法2:0.618法算法3:牛顿法实验内容(方法和步骤)例题题目1 编写程序实现进退法。题目2 利用进退法求解极值区间实例题目3 编写程序实现0....

    实验一 一维最优化方法

    实验目的及要求:

    1. 编写程序实现进退法,利用进退法求解极值区间实例;

    2. 编写程序实现0.618 法,利用0.618 法求解极值实例;

    3. 编写程序实现牛顿法,来求解一维函数的局部极小值点。

    实验原理:

    M a t l a b Matlab Matlab 环境下,按照要求编写函数和程序,求解实例,直至取得正确的运行结果。(写出每种算法的步骤)

    算法1:进退法
    1. 设定初始值 α = 2 , k = 0 , ϕ 0 = ϕ ( λ 0 ) \alpha=2,k=0,\phi _0=\phi (\lambda _0) α=2k=0ϕ0=ϕ(λ0),传入参数 h 0 h_0 h0
    2. 使 λ k + 1 = λ k + h k \lambda _{k+1}=\lambda _k+h_k λk+1=λk+hk,计算 ϕ k + 1 = ϕ ( λ k + 1 ) \phi _{k+1}=\phi (\lambda _{k+1}) ϕk+1=ϕ(λk+1)
    3. ϕ k + 1 < ϕ k \phi _{k+1}<\phi _k ϕk+1<ϕk,转向4;反之转向5。
    4. 加步, h k + 1 = a h k , λ = λ k , λ k = λ k + 1 , ϕ k = ϕ k + 1 , k + + h_{k+1}=ah_k,\lambda =\lambda _k,\lambda _k=\lambda _{k+1},\phi _{k}=\phi _{k+1},k{++} hk+1=ahkλ=λkλk=λk+1ϕk=ϕk+1k++,转向2。
    5. 反向探索:
      • k = 0 k=0 k=0则转换方向: h k = − h k , λ = λ k + 1 h_k=-h_k,\lambda =\lambda _{k+1} hk=hkλ=λk+1,转向2。
      • 否则停止迭代, a = m i n ( λ , λ k + 1 ) , b = m a x ( λ , λ k + 1 ) a=min(\lambda ,\lambda _{k+1}),b=max (\lambda ,\lambda _{k+1}) a=min(λ,λk+1)b=max(λ,λk+1),输出 [ a , b ] [a,b] [a,b]
    算法2:0.618法
    1. 选取初始区间 [ a 1 , b 1 ] [a_1,b_1] [a1,b1]和误差 ε > 0 \varepsilon>0 ε>0 τ \tau τ=0.618。
    2. 计算 λ 1 = a 1 + ( 1 − τ ) ( b 1 − a 1 ) , μ 1 = a 1 + τ ( b 1 − a 1 ) \lambda_{1}=a_{1}+(1-\tau)\left(b_{1}-a_{1}\right), \mu_{1}=a_{1}+\tau\left(b_{1}-a_{1}\right) λ1=a1+(1τ)(b1a1),μ1=a1+τ(b1a1),并求出 ϕ ( λ 1 ) , ϕ ( μ 1 ) \phi(\lambda_1),\phi(\mu_1) ϕ(λ1)ϕ(μ1) k = 1 k=1 k=1
    3. ∣ b k − a k ∣ < ε \left|b_{k}-a_{k}\right|<\varepsilon bkak<ε,停止计算,输出 t ˉ = λ k + μ k 2 \bar{t}=\frac{\lambda_{k}+\mu_{k}}{2} tˉ=2λk+μk;反之转向4。
    4. 比较函数值
      • ϕ ( λ k ) < ϕ ( μ k ) \phi(\lambda_k)<\phi(\mu_k) ϕ(λk)<ϕ(μk),转向5。
      • 反之,转向6。
    5. 向左搜索,令 a k + 1 = a k , b k + 1 = μ k , μ k + 1 = λ k , φ ( μ k + 1 ) = φ ( λ k ) a_{k+1}=a_{k}, b_{k+1}=\mu_{k}, \mu_{k+1}=\lambda_{k}, \varphi\left(\mu_{k+1}\right)=\varphi\left(\lambda_{k}\right) ak+1=ak,bk+1=μk,μk+1=λk,φ(μk+1)=φ(λk),并计算 λ k + 1 = a k + 1 + ( 1 − τ ) ( b k + 1 − a k + 1 ) \lambda_{k+1}=a_{k+1}+(1-\tau)\left(b_{k+1}-a_{k+1}\right) λk+1=ak+1+(1τ)(bk+1ak+1) φ ( λ k + 1 ) \varphi\left(\lambda_{k+1}\right) φ(λk+1),转向7。
    6. 向右搜索,令 a k + 1 = λ k , b k + 1 = b k , λ k + 1 = μ k , φ ( λ k + 1 ) = φ ( μ k ) a_{k+1}=\lambda_{k}, b_{k+1}=b_{k}, \lambda_{k+1}=\mu_{k}, \varphi\left(\lambda_{k+1}\right)=\varphi\left(\mu_{k}\right) ak+1=λk,bk+1=bk,λk+1=μk,φ(λk+1)=φ(μk),并计算 μ k + 1 = a k + 1 + τ ( b k + 1 − a k + 1 ) \mu_{k+1}=a_{k+1}+\tau\left(b_{k+1}-a_{k+1}\right) μk+1=ak+1+τ(bk+1ak+1) φ ( μ k + 1 ) \varphi\left(\mu_{k+1}\right) φ(μk+1),转向7。
    7. k + + k{++} k++,转向3。
    算法3:牛顿法
    1. 设定初始点 t 0 t_0 t0,允许误差 ε > 0 \varepsilon>0 ε>0 k = 0 k=0 k=0
    2. ϕ ′ ( t k ) < ε \phi'(t_k)<\varepsilon ϕ(tk)<ε输出 t k t_k tk,停止计算,反之转向3。
    3. 计算 t k + 1 = t k − φ ′ ( t k ) φ ′ ′ ( t k ) , k + + t_{k+1}=t_{k}-\frac{\varphi^{\prime}\left(t_{k}\right)}{\varphi^{\prime \prime}\left(t_{k}\right)},k{++} tk+1=tkφ(tk)φ(tk)k++,转向2。

    实验内容(方法和步骤)

    例题

    题目1 编写程序实现进退法。

    利用Matlab 编写函数 [xmin,xmax]=Brackeing(f,x0,h0). 区间[xmin,xmax] 包含函数f的一个局部极值点。

    调用上述函数,实现代码在代码实现部分:

    function [xmin,xmax]=Brackeing(f,x0,h)
    %{
    Brackeing 进退法
       f       函数
       x0      初始点
       h0      步长
       
       xmin    左区间
       xmax    右区间
    %}
    F = matlabFunction(f);  %建立函数句柄
    a = 2;                  %加倍系数
    k = 1;                  %迭代数
    lambda = 0;             %记录答案
    flag = false;           %标记
    
    x = zeros(1,10);        %申请自变量空间
    f_val = zeros(1,10);    %申请函数值空间
    x(1) = x0;              %自变量赋值
    f_val(1) = F(x(1));     %函数赋值
    
    
    while true
    %%%%%%%%%%%%% 试探&计算
        x(k+1) = x(k) + h;      
        f_val(k+1) = F(x(k+1));
    %%%%%%%%%%%%%
        if f_val(k+1) >= f_val(k) %  比较
            if k == 1       %检查
                h = -h;     %改变方向反向前进
                lambda = x(k+1);
                x(k+1) = x(k) + h;      
                f_val(k+1) = F(x(k+1));
            else 
                flag = true;
            end
        end
        
        if flag         %结束计算
            break
        end
            
    %%%%%%%%%%%%% 加步
        h = a * h;
        lambda = x(k);
        x(k) = x(k+1);
        f_val(k) = f_val(k+1);
        k = k + 1;
    %%%%%%%%%%%%%
    end
    
    xmin = min(lambda, x(k+1));     %左边界
    xmax = max(lambda, x(k+1));     %右边界
    disp(xmin)
    disp(xmax)
    %%%%%%%%%%%%% 绘图查看
    figure('Name', 'Brackeing')
    xx = xmin-0.5:0.01:xmax+0.5;
    yy = F(xx);
    plot(xx, yy, 'LineWidth', 2)
    hold on
    plot([xmin,xmax], [min(yy), min(yy)],':r', 'LineWidth', 1.5)
    end
    
    题目2 利用进退法求解极值区间实例

    利用进退法求解极值区间实例。取初始点x0=0,步长h0=0.1 ,用进退法求函数 f ( x ) = ( x 2 − 1 ) 2 − ( x − 1 ) 2 f(x)=(x^2-1)^2-(x-1)^2 f(x)=(x21)2(x1)2+3的极值区间。

    代码实现部分为:

    syms x y;
    y = (x^2 - 1)^2 - (x - 1)^2 + 3;
    [xmin,xmax]=Brackeing(y,0,0.1);
    

    输出结果为:

    xmin = -3.1000
    xmax = -0.7000
    

    检查结果为:

    在这里插入图片描述

    题目3 编写程序实现0.618 法

    利用Matlab 编写函数 . 调用函数得到的x 为函数f 在区间[a,b] 上的局部极小值点。

    代码实现部分为:

    function [x,miny]=MinHJ(f,a,b,eps)
    %{
        MinHJ   0.618法
        f       函数
        a       左区间
        b       右区间
        eps     精度
    
        x       自变量
        miny    局部极小值
    %}
    xmax = b;
    xmin = a;
    F = matlabFunction(f);  %函数句柄
    tau = 0.618;            %缩短率
    lambda = a + (1 - tau)*(b - a);     %计算lambda
    mu = a + tau * (b - a);             %计算mu
    
    lambda_val = F(lambda);             %lambda函数值
    mu_val = F(mu);                     %mu函数值
    
    while b - a >= eps                  %误差区间之外
        %fprintf('a=%d,b=%d,a_val=%d,b_val=%d\n',a,b,lambda_val,mu_val);
        if lambda_val < mu_val
            b = mu;
            mu = lambda;
            mu_val = lambda_val;
            lambda = a + (1 - tau)*(b - a);
            lambda_val = F(lambda);
        else
            a = lambda;
            lambda = mu;
            lambda_val = mu_val;
            mu = a + tau * (b - a);
            mu_val = F(mu);
        end
    end
    
    %计算结果
    x = (lambda + mu) / 2;
    miny = F(x);
    
    %%%%%%%% 绘图
    figure('Name', 'MinHJ')
    xx = xmin:0.01:xmax;
    yy = F(xx);
    plot(xx, yy, 'LineWidth', 2)
    hold on
    plot(x,miny,'p', 'LineWidth', 2)
    end
    
    题目4 利用0.618 法求解极值实例

    利用0.618 法求下面函数的极小值: f ( x ) = ( x 2 − 1 ) 2 − ( x − 1 ) 2 + 3 , t ∈ ( − 10 , 10 ) f(x)=\left(x^{2}-1\right)^{2}-(x-1)^{2}+3, t \in(-10,10) f(x)=(x21)2(x1)2+3,t(10,10),误差为0.01

    调用上述代码,实现部分为:

    syms x y;
    y = (x^2 - 1)^2 - (x - 1)^2 + 3;
    [x,miny]=MinHJ(y,-10,10,0.01);
    

    在这里插入图片描述

    输出结果为:

    x = -1.3656
    miny = -1.8481
    

    检查结果为:

    题目5 编写程序实现牛顿法

    利用Matlab 编写函数 [x,minf]=Newton(f,x0,eps). 其中f 为目标函数, x0 为初始点,eps 为算法终止的精度。用牛顿法求解无约束优化问题minf(x) 。

    代码实现部分为:

    function [x,minf]=Newton(f,x0,eps)
    %{
    Newton      牛顿法
        f       函数
        x0      初始点
        eps     误差
       
        x       目标x
        minf    目标函数值
    %}
    xmax = x0+2;
    xmin = x0-2;
    F0 = matlabFunction(f);             %原函数函数句柄
    F1 = matlabFunction(diff(f));       %一阶导函数函数句柄
    F2 = matlabFunction(diff(f,2));     %二阶导函数函数句柄
    
    while abs(F1(x0)) >= eps            %迭代
        x0 = x0 - F1(x0) / F2(x0);
    end
    
    x = x0;
    minf = F0(x);
    
    %%%%%%%% 绘图
    figure('Name', 'MinHJ')
    xx = xmin:0.01:xmax;
    yy = F0(xx);
    plot(xx, yy, 'LineWidth', 2)
    hold on
    plot(x,minf,'p', 'LineWidth', 2)
    end
    
    
    while abs(F1(x0)) >= eps            %迭代
        x0 = x0 - F1(x0) / F2(x0);
    end
    
    x = x0;
    minf = F0(x);
    
    %%%%%%%% 绘图
    figure('Name', 'MinHJ')
    xx = xmin:0.01:xmax;
    yy = F0(xx);
    plot(xx, yy, 'LineWidth', 2)
    hold on
    plot(x,minf,'p', 'LineWidth', 2)
    end
    
    展开全文
  • 0.618法matlab

    2021-05-21 17:13:49
    0.618法 建立golds.m文件 function [s,phis,k,G,E]=golds(phi,a,b,delta,epsilon) %输入:phi是目标函数,a,b是搜索区间的两个端点 % delta,epsilon分别是自变量和函数值的容许误差 %输出:s,phis分别是近似极小点和...

    0.618法
    建立golds.m文件
    function [s,phis,k,G,E]=golds(phi,a,b,delta,epsilon)
    %输入:phi是目标函数,a,b是搜索区间的两个端点
    % delta,epsilon分别是自变量和函数值的容许误差
    %输出:s,phis分别是近似极小点和极小值,G是nx4矩阵
    % 其第k行分贝时a,p,q,b的第k次迭代值[ak,pk,qk,bk]
    % E=[ds,dphi],分别是s和phis的误差限
    t=(sqrt(5)-1)/2;h=b-a;
    phia=feval(phi,a);phib=feval(phi,b);
    p=a+(1-t)h;q=a+th;
    phip=feval(phi,p);phiq=feval(phi,q);
    k=1;G(k,:)=[a,p,q,b];
    while(abs(phib-phia)>epsilon)|(h>delta)
    if(phip<phiq)
    b=q;phib=phiq;q=p;phiq=phip;
    h=b-a;p=a+(1-t)h;phip=feval(phi,p);
    else
    a=p;phia=phip;p=q;phip=phiq;
    h=b-a;q=a+t
    h;phiq=feval(phi,q);
    end
    k=k+1;G(k,:)=[a,p,q,b];
    end
    ds=abs(b-a);dphi=abs(phib-phia);
    if(phip<=phiq)
    s=p;phis=phip;
    else
    s=q;phis=phiq;
    end
    E=[ds,dphi];

    展开全文
  • 黄金分割的python实现 在准备学优化方法期末考试的时候拿到习题没有答案,就想写一个程序然后和自己算出来的答案对一下就写了个程序,考完试了留着也没用索性写一篇出来造福学弟学妹,黄金分割通俗的讲就是给一个...

    黄金分割法的python实现

    在准备学优化方法期末考试的时候拿到习题没有答案,就想写一个程序然后和自己算出来的答案对一下就写了个程序,考完试了留着也没用索性写一篇出来造福学弟学妹,黄金分割法通俗的讲就是给一个区间给一个函数在这个区间里求函数的最小值

    1.一维搜索黄金分割法

    这里搬一下书上的概念书上的概念严谨但确实不好懂做两道例题就好了其实
    考察一维搜索问题:

    { m i n φ ( λ ) s . t . a 1 ≤ λ ≤ b 1 \begin{cases} min&\varphi(\lambda)\\ s.t.&a_1\le\lambda\le b_1 \end{cases} {mins.t.φ(λ)a1λb1
    其中 φ ( λ ) \varphi(\lambda) φ(λ)为凸函数

    1 。 1^。 1 ε > 0 \varepsilon>0 ε>0为允许的搜索区间最后的长度令 α \alpha α=0.618则黄金分割法计算步骤如下

    λ 1 = a 1 + ( 1 − α ) ( b 1 − a 1 ) φ ( λ 1 ) μ 1 = a 1 + α ( b 1 − a 1 ) φ ( μ 1 ) \lambda_1=a_1+(1-\alpha)(b_1-a_1) \quad \varphi(\lambda_1)\\ \mu_1=a_1+\alpha(b_1-a_1) \qquad \varphi(\mu_1) λ1=a1+(1α)(b1a1)φ(λ1)μ1=a1+α(b1a1)φ(μ1)
    k = 1 k=1 k=1

    2 。 2^。 2 b k − a k < ε b_k-a_k<\varepsilon bkak<ε,则计算结束,最优解 λ ∗ ∈ [ a k , b k ] \lambda^*\in[a_k,b_k] λ[ak,bk],可取 λ ∗ ≈ ( 1 / 2 ) ( a k + b k ) \lambda^*\approx(1/2)(a_k+b_k) λ(1/2)(ak+bk);否则 φ ( λ k ) > φ ( μ k ) \varphi(\lambda_k)>\varphi(\mu_k) φ(λk)>φ(μk), 则转 3 。 3^。 3;若 φ ( λ k ) ≤ φ ( μ k ) \varphi(\lambda_k)\le\varphi(\mu_k) φ(λk)φ(μk),则转 4 。 4^。 4

    3 。 3^。 3 a k + 1 = λ k , b k + 1 = b k a_{k+1}=\lambda_k,b_{k+1}=b_k ak+1=λk,bk+1=bk,再令 λ k + 1 = μ k , μ k + 1 = a k + 1 + α ( b k + 1 − a k + 1 ) \lambda_{k+1}=\mu_k, \mu_{k+1}=a_{k+1}+\alpha(b_{k+1}-a_{k+1}) λk+1=μk,μk+1=ak+1+α(bk+1ak+1),计算 φ ( μ k + 1 ) \varphi(\mu_{k+1}) φ(μk+1) 5 。 5^。 5

    4 。 4^。 4 a k + 1 = a k , b k + 1 = μ k a_{k+1}=a_k,b_{k+1}=\mu_k ak+1=ak,bk+1=μk,再令 μ k + 1 = λ k , λ k + 1 = a k + 1 + ( 1 − α ) ( b k + 1 − a k + 1 ) \mu_{k+1}=\lambda_k, \lambda_{k+1}=a_{k+1}+(1-\alpha)(b_{k+1}-a_{k+1}) μk+1=λk,λk+1=ak+1+(1α)(bk+1ak+1),计算 φ ( μ k + 1 ) \varphi(\mu_{k+1}) φ(μk+1) 5 。 5^。 5

    5 。 5^。 5 k = k + 1 k=k+1 k=k+1,返回 2 。 2^。 2

    2.python代码实现

    例:求解 min ⁡ φ ( λ ) = λ 2 + 2 λ , s . t . − 3 ≤ λ ≤ 5 \min\varphi(\lambda)=\lambda^2+2\lambda,s.t. -3\le\lambda\le 5 minφ(λ)=λ2+2λ,s.t.3λ5
    ε = 0.2 \varepsilon=0.2 ε=0.2取精度为0.001
    取三位小数用python的round(x,3)实现

    # 只需改如下四个参数即可
    f = lambda x: x**2 + 2*x
    # 定义变量
    e = 0.2       # 终止线
    a = -3           # 左边
    b = 5          # 右边
    
    
    # 黄金分割法计算法则
    lanb = lambda a, b : a + 0.382* (b -a)
    mui = lambda a, b : a + 0.618* (b -a)
    
    Mui = round(mui(a, b),3)
    Mui_value = round(f(Mui), 3)
    
    Lamb = round(lanb(a, b) ,3)
    Lamb_value= round(f(Lamb), 3)
    
    print(f'a={a} b={b}')
    print(f'lanb:{Lamb}')
    print(f'mui:{Mui}')
    print(f'f(lanb)= {Lamb_value}')
    print(f'f(mui)= {Mui_value}')
    print() #换行最后看着舒服
    
    while b - a > e: #判断是否到达终止线
        if Lamb_value < Mui_value:
            print('f(lanb) < f(mui)')
            print()
            b = Mui
            Mui = Lamb
            Lamb = round(lanb(a, b), 3)
        else:
            print('f(mui) < f(lanb) ')
            print()
            a = Lamb
            Lamb = Mui
            Mui = round(mui(a, b), 3)
    
        Mui_value = round(f(Mui), 3)
        Lamb_value = round(f(Lamb), 3)
        print(f'a={a} b={b}')
        print(f'lanb:{Lamb}')
        print(f'mui:{Mui}')
        print(f'f(lanb)= {Lamb_value}')
        print(f'f(mui)= {Mui_value}')
    
    
    print(f'b-a绝对值为{abs(b -a)} 小于终止线 算法停止')
    print(f'X⭐包含于[{a}, {b}]')
    print(f'X⭐ = {round((a + b)/ 2, 3)}')
    

    3.运行结果

    a=-3 b=5
    lanb:0.056
    mui:1.944
    f(lanb)= 0.115
    f(mui)= 7.667
    f(lanb) < f(mui)
    
    a=-3 b=1.944
    lanb:-1.111
    mui:0.056
    f(lanb)= -0.988
    f(mui)= 0.115
    f(lanb) < f(mui)
    
    a=-3 b=0.056
    lanb:-1.833
    mui:-1.111
    f(lanb)= -0.306
    f(mui)= -0.988
    f(mui) < f(lanb) 
    
    a=-1.833 b=0.056
    lanb:-1.111
    mui:-0.666
    f(lanb)= -0.988
    f(mui)= -0.888
    f(lanb) < f(mui)
    
    a=-1.833 b=-0.666
    lanb:-1.387
    mui:-1.111
    f(lanb)= -0.85
    f(mui)= -0.988
    f(mui) < f(lanb) 
    
    a=-1.387 b=-0.666
    lanb:-1.111
    mui:-0.941
    f(lanb)= -0.988
    f(mui)= -0.997
    f(mui) < f(lanb) 
    
    a=-1.111 b=-0.666
    lanb:-0.941
    mui:-0.836
    f(lanb)= -0.997
    f(mui)= -0.973
    f(lanb) < f(mui)
    
    a=-1.111 b=-0.836
    lanb:-1.006
    mui:-0.941
    f(lanb)= -1.0
    f(mui)= -0.997
    f(lanb) < f(mui)
    
    a=-1.111 b=-0.941
    lanb:-1.046
    mui:-1.006
    f(lanb)= -0.998
    f(mui)= -1.0
    b-a绝对值为0.17 小于终止线 算法停止
    X⭐包含于[-1.111, -0.941]
    X⭐ = -1.026
    
    

    结束

    用的书上的例子,书上的 λ 2 \lambda_2 λ2算成-1.112算错了应该是-1.111所以后面的结果不一样
    在这里插入图片描述

    展开全文
  • 0.618算法C++实现

    2020-11-16 23:13:41
    使用C++模拟的0.618算法。使用的人可以直接更改其中的参数,然后运行程序就可以求出方程的解了。 适合初学算法的人练习使用
  • 0.618法的matlab实现

    2021-09-19 08:49:04
    一、题目: 0. 618法寻最优解← 问题描述:← 求函数f(x)= 3x2- 2 tan x在区间[0, 1]上的极小值,其中容许误差ε= 10-4。《●实验的基本 要求、输出最优解、函数的最优值、终止条件; k 2、画图显示其寻优过程。
  • 梯度下降算法0.618法

    2020-10-13 16:45:17
    梯度下降方向梯度下降算法总结精确一维搜索进退法0.618法 梯度下降算法总结 觉得CSDN这块有用的很少,于是写下自己的一些感悟,下降梯度结合精度对于算法其实非常有帮助,在上非线性规划这门课中,老师的讲得很仔细...
  • 最优化方法之0.618法(java) 算法原理 题目 试用0.618法求目标函数f(X)=x^3-2*x+1的最优解。给定初始区间[0,2],收敛精度sgm=0.002。 代码 主类 package project; public class main1 { public static void main...
  • 最近我们开学了,今年选修了“优化算法”,最近都在学习算法,所以想着把书本上的算法用Matlab实现,说不定以后能直接用上呢。废话不多说,直接开始,主要是代码的分享,...% 黄金分割优化算法,亦称0.618优化算法 %
  • 应用于设计的最优化方法,应用鲍威尔,已经黄金分割的一维搜索方法
  • //0.618法 class Solution { public: Solution(double x, double y) :a(x), b(y) { cout << "init parameter success\n"; } double func(double& x) const//计算函数值 { return x*(x + 2); } ...
  • 一维搜索:0.618法

    千次阅读 2018-08-05 11:41:20
    0.618法又叫黄金分割法,适用于单峰函数,可以不连续。 1.伪代码 (1) 置初始区间[a1,b1][a1,b1][a_1,b_1]及精度要求L&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;0L&amp;amp;amp;amp;amp;amp;...
  • 这次主要总结3个经典的算法:成功-失败法、牛顿法和0.618法。 一.成功-失败法 成功失败法的计算步骤如下: (1)给定初始点x0∈R,搜索步长h>0及精度e>0. (2)计算x1=x0+h,f(x1)。 (3)若f(x1)<f(x0),则...
  • 一维搜索之0.618法(试探法)

    千次阅读 2020-05-15 22:51:11
    初步介绍一维搜索的0,618法求目标函数极小值。
  • %%%% 0.618法 %%%%% %%%%% Liu Deping %%%%% %%%%% 2020.09.21 %%%%% clc; clear all format short s=input('请输入函数表达式:f = ','s'); f=inline(s); a = input('请输入区间左端点a的值:'); b = input('请输入...
  • 0.618法(近似黄金分割法)实验

    千次阅读 2019-10-09 01:30:02
    通过程序运行,我们发现程序进行了4次迭代,在第4次迭代时结束运行,观察输出结果,最优解约为0.875,与教材上答案一致。 Python代码 def face(x): return x**3-2*x+1 #目标函数 def mark(a,b): if a.....
  • 最优化-(黄金分割法)0.618法

    千次阅读 2021-01-04 21:07:02
    0.618法求极小值过程代码 过程 (黄金分割法)0.618法求极小点。 给:f(x),范围[a,b],精度ε(无,则默认为0) 过程① x1 = b - 0.618 * (b - a) x2 = a + 0.618 * (b - a) 过程② 当f(x1) < f(x2)时, b = x2, ...
  • @Mathematica实现0.618法求函数最大最小值 Mathematica实现0.618法(黄金分割法)求最大最小值 0.618法又叫黄金分割法,此篇文章将给出黄金分割法的Mathematica代码实现及实例。 GoldenSection[a_, b_, f_, ...
  • 0.618 matlab实现

    2014-03-09 17:05:44
    0.618的matlab代码,经过优化过,希望对你们有点用处
  • 1、0.618法 // 0.618.cpp : 优化方法:0.618法确定一维搜索问题的搜索区间。 // #include "stdio.h" #include "iostream" #include "math.h" using namespace std; //#define Lambda 0.618 double f(double x)...
  • 最优化问题可以分为两大类:无约束最优化问题、约束最优化问题。...本文对一些算法进行总结,如黄金分割、最速下降(梯度下降)、牛顿、阻尼牛顿、拟牛顿、共轭方向…… 包含matlab代码资源

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,521
精华内容 2,608
关键字:

0.618法