精华内容
下载资源
问答
  • 不动点迭代法matlab实现

    千次阅读 2021-01-07 10:12:39
    不动点迭代法(Fixed point iteration method) 原理网上已经很多了,这里不再赘述。 需要注意的是不动点迭代法的使用条件。 举个简单的例子,利用不动点法求解方程f(x) = 1 + 0.5*sin(x) − x = 0在(1,2)区间的根...

    不动点迭代法(Fixed point iteration method)

    原理网上已经很多了,这里不再赘述。
    需要注意的是不动点迭代法的使用条件。

    举个简单的例子,利用不动点法求解方程f(x) = 1 + 0.5*sin(x) − x = 0在(1,2)区间的根。
    令g(x)=1+0.5*sin(x)

    
    g = @(x) fun2(x);
    % Initialization
    x0 = 0;
    tol = 1e-5;
    maxIter = 40;
    
    % Test biSection function
    [xStar,xRoot] = fixPoint(g,x0,tol,maxIter);
    fprintf('The fixed point is: %d\n',xStar);
    fprintf('The root of the equation is: %d\n',xRoot);
    
    function [xStar,xRoot] = fixPoint(fun2,x0,tol,maxIter)
    % Inputs:
    % fun2: a function handle, standing for the function written above
    % x0: the initial guess of the fixed point
    % tol: the tolerance within which the program can stop
    % maxIter: the maximum number of iterations the program is allowed to run
    % Outputs:
    % xStar: the numerical value of the fixed point
    % xRoot: the numerical value of the root
    
        x = zeros(maxIter,1);
        x(1) = fun2(x0);
        i = 1;
    
        while abs(fun2(x(i))-x(i))>tol && i<maxIter
            x(i+1) = fun2(x(i));
            xStar = x(i);
            i = i+1;
        end
        xRoot = x(i);
    
    end
    
    function gx = fun2(x)
        gx = 1+0.5*sin(x);
    end
    
    
    展开全文
  • 不动点迭代法解非线性方程的newton法matlab实现
  • Matlab 求根代码 包括Newton法、Secant法、Steffenson法、Aitken's法、不动点迭代法,以及包括这些方法求同一个函数时候初始猜测值和迭代次数的比较,并用图像呈现。
  • 不动点迭代法解非线性方程的aitken加速法matlab实现
  • MATLAB编写关于如何用史蒂芬不动点迭代法解线性方程组的程序
  • 数值分析matlab程序
  • MATLAB用二分法、不动点迭代法及Newton迭代(切线)法求非线性方程的根 作者:凯鲁嘎吉 - 博客园http://www.cnblogs.com/kailugaji/ 一、实验原理 二、实验步骤 三、实验过程 1.(程序) (1)二分法:求 ...

    MATLAB用二分法、不动点迭代法及Newton迭代(切线)法求非线性方程的根

    作者:凯鲁嘎吉 - 博客园
    http://www.cnblogs.com/kailugaji/

    一、实验原理

    二、实验步骤

    三、实验过程

    1.(程序)

    (1)二分法:求   在区间(12)之间的根,取

    abipart.m:

    function [x,m]=bipart(fun,a0,b0,tol)
    a=a0;b=b0;
    m=1+round(round(log((b-a)/tol))/log(2));
    for k=1:m
        p=(a+b)/2;     
        if fun(p)*fun(b)<0
                a=p;
        else
                b=p;
        end
        x=p;
    end
    end 

    (b)fun1.m:

    function f=fun1(x)
    f=x^3+10*x-20;

     2)不动点迭代法:求方程附近的根,取

    (a)budong.m:

    function [x,k]=budong(fun,x0,tol,m)
    for k=1:m
        x=fun(x0);
        if abs(x-x0)<tol
            break;
        end
        x0=x;
    end
    x=vpa(x,8);

       (b)fun.m

    function t=fun(x1)
    syms x;
    f=x^3-2*x-5;
    s=subs(diff(f,x),x,x1);
    x=x1;
    f=x^3-2*x-5;
    t=x-f/s;

    3)牛顿迭代法:求方程附近的根,取

    newton.m:

    function x1=newton(t1,esp,m)
    
    syms x;
    
    fun=x^3+2*x-5;
    
    for k=1:m
    
        if abs(subs(diff(fun,'x'),x,t1))<esp
    
            x1=t1;
    
            break;
    
        else
    
            if subs(diff(fun,'x',2),x,t1)==0
    
                break;
    
                disp('解题失败!')
    
            else
    
                t0=t1;
    
                t1=t0-subs(fun,x,t0)/subs(diff(fun,'x'),x,t0);
    
                if abs(t1-t0)<esp
    
                    x1=t1;
    
                    break;
    
                end
    
            end
    
        end
    
    end
    
    x1=vpa(x1,8);

    2.(运算结果)

    (1)二分法:

    >> [x,m]=bipart(@fun1,1,2,0.0001)
    x =
        1.5945
    m =
        14

    (2)不动点迭代法:

    >> [x,k]=budong(@fun,2,1e-5,100)
    x =
    2.0945515
    k =
         4
    

    (3)牛顿迭代法:

     >> x1=newton(2,1e-4,20)
         x1 =
            1.3282689
      

    3.(拓展(方法改进、体会等))

    对于方程的根为重根的情形,newton法求重根只是线性收敛,迭代缓慢,如果对于求重根的情形,对newton法进行改进,取

                 ,

    。用迭代法

                      

    m重根,则具有二阶收敛性,但要知道的重数m。

       计算方程的根是二重根,用newton法与改进方法求根。

    源程序:

    newton_biroot.m:

    function t=newton_biroot(x1)
    
    syms x;
    
    f=x^4-4*(x^2)+4;
    
    s=subs(diff(f,x),x,x1);
    
    x=x1;
    
    f=x^4-4*(x^2)+4;
    
    t=x-f/s;

    biroot1.m:

    function t=biroot1(x1)
    
    syms x;
    
    f=x^4-4*(x^2)+4;
    
    s=subs(diff(f,x),x,x1);
    
    x=x1;
    
    f=x^4-4*(x^2)+4;
    
    t=x-2*f/s;

    budong.m:

    function [x,k]=budong(fun,x0,tol,m)
    
    for k=1:m
    
        x=fun(x0);
    
        if abs(x-x0)<tol
    
            break;
    
        end
    
        x0=x;
    
        x=vpa(x,8)
    
    end
    
    x=vpa(x,8);

    运行结果:取初值为2

    k

              xk

    newton

    改进方法

    1

              x1

    1.75

    1.5

    2

              x2

    1.5982143

     

    1.4166667

     

    3

              x3

    1.5115099

     

    1.4142157

     

    4

              x4

    1.4644275

     

    1.4142157

     

     计算4步,改进方法就已经收敛,而newton法只是线性收敛,要达到同样精度需迭代17次。

    附结果:

    >> [x,k]=budong(@biroot1,2,1e-5,3)

    x =

    1.5

    x =

    1.4166667

    x = 

    1.4142157

    x =

    1.4142157 

    k =

         3

    >> [x,k]=budong(@biroot1,2,1e-5,10)

    x =

    1.5

    x =

    1.4166667

    x =

    1.4142157

    x =

    1.4142136 

    k =

         4

    >> [x,k]=budong(@newton_biroot,2,1e-5,50)

    x =

    1.75

    x = 

    1.5982143 

    x = 

    1.5115099 

    x = 

    1.4644275

    x =

    1.439751

    x =

    1.4270955

    x =

    1.4206836

    x =

    1.4174559

    x =

    1.4158366 

    x =

    1.4150256

    x =

    1.4146197

    x =

    1.4144166

    x =

    1.4143151

    x = 

    1.4142643 

    x =

    1.414239

    x =

    1.4142263 

    x =

    1.4142199

    k =

        17

    转载于:https://www.cnblogs.com/kailugaji/p/6920975.html

    展开全文
  • 不动点迭代 function xc = fpi( g, x0, tol ) x(1) = x0; i = 1; while 1 x(i + 1) = g(x(i)); if(abs(x(i+1) - x(i)) < tol) break end i = i + 1; end...

    不动点迭代

    function xc = fpi( g, x0, tol )
        x(1) = x0;
        i = 1;
        while 1
            x(i + 1) = g(x(i));
            if(abs(x(i+1) - x(i)) < tol)
                break
            end
            i = i + 1;
        end
        xc = x(i+1);
    end

    牛顿法:

    function xk = funNewton(f, x0, max_steps, tol)
        syms x
        symbol_f = f(x);
        dif_f = matlabFunction(diff(symbol_f));
        clear x
        x = x0;
        for k = 1:max_steps
           xk = x;
           disp(['the ', num2str(k), ' time is ', num2str(x)])
           %xk to save the last time value of x
           x = x - f(x) / dif_f(x);
           %newton solve 
           if(abs(xk - x) < tol)
           %decide whether to break out
                break;
           end
        end
    end

    割线法:

    function xc = CutLine( f, x0, x1, tol )
        x(1) = x0;
        x(2) = x1;
        i = 2;
        while 1
            x(i + 1) = x(i) - (f(x(i)) * (x(i) - x(i - 1))) / (f(x(i)) - f(x(i - 1)));
            if(abs(x(i + 1) - x(i)) < tol)
                break;
            end
            i = i + 1;
        end
        xc = x(i + 1);
    end

    Stewart平台运动学问题求解:

    function out = Stewart( theta )
        % set the parameter
        x1 = 4; 
        x2 = 0; 
        y2 = 4; 
        L1 = 2;
        L2 = sqrt(2);
        L3 = sqrt(2);
        gamma = pi / 2;
        p1 = sqrt(5);
        p2 = sqrt(5);
        p3 = sqrt(5);
        % calculate the answer
        A2 = L3 * cos(theta) - x1;
        B2 = L3 * sin(theta);
        A3 = L2 * cos(theta + gamma) - x2;
        B3 = L2 * sin(theta + gamma) - y2;
        
        N1 = B3 * (p2 ^ 2 - p1 ^ 2 - A2 ^ 2 - B2 ^ 2) - B2 * (p3 ^ 2 - p1 ^ 2 - A3 ^ 2 - B3 ^ 2);
        N2 =  -A3 * (p2 ^ 2 - p1 ^ 2 - A2 ^ 2 - B2 ^ 2) + A2 * (p3 ^ 2 - p1 ^ 2 - A3 ^ 2 - B3 ^ 2);
        D = 2 * (A2 * B3 - B2 * A3);
        
        out = N1 ^ 2 + N2 ^ 2 - p1 ^ 2 * D ^ 2;
    
    end

    test our function at theta = - pi / 4 and theta = pi / 4

    clear all
    clc
    
    format short
    
    disp('f(- pi / 4) is ')
    out1 = Stewart(- pi / 4)
    
    disp('--------------')
    
    disp('f(pi / 4) is ')
    out2 = Stewart(pi / 4)

    转载于:https://www.cnblogs.com/wsine/p/4634513.html

    展开全文
  • 对于形如f(x)=0的单变量非线性方程,可以构造不同的迭代函数进行迭代求根,以f(x)=x3-x-1为例,我们可以简单的通过等式变形构造出x...%不动点迭代法1 clc; clear; syms x;%定义变量x f(x)=input('请输入函数表达式,变量

    对于形如f(x)=0的单变量非线性方程,可以构造不同的迭代函数进行迭代求根,以f(x)=x3-x-1为例,我们可以简单的通过等式变形构造出x=x3-1和x=(x+1)(1/3)两种等价形式;也可以自己增加x的表达式构建x=(1/2)×(x3+x-1),所以同一个非线性方程可以构建无穷多的等价形式,只要最终可以化简成f(x)=0的形式就行;
    不动点迭代是最基础的迭代法,其代码如下:
    代码块1:

    %不动点迭代法1
    clc;
    clear;
    syms x;%定义变量x
    f(x)=input('请输入函数表达式,变量用x表示:f(x)=');
    g(x)=input('请输入等价形式:x=');  %f(x)=0等价为x=g(x)
    x1=input('请选择一个初始值:x1=');
    eps=input('请输入停止精度要求:eps=');%|b-xk|<=eps/2
    k=1;
    x=[x1];  %定义数组x,存储每次迭代产生的xk
    k=k+1;%迭代次数,注意k=2时对应第1次迭代
    x2=g(x1);%1次迭代,x2对应数组x中的x(2)
    x=[x x2];   %把新产生的x2按顺序装进数组x
    T=[1,x1,f(x1);2,x2,f(x2)];   %T初始值为23列,随着迭代增加行数
    while (abs(x(k)-x(k-1))>eps/2)   %判断是达到求根的精度要求,未达到则执行循环(小于才是达到要求)
        if (k>1000)||(abs(f(x(k)))>1e15)    %1000次还没有达到精度要求的话,报错
            error('迭代出错!或许是迭代公式的问题')
        else
            k=k+1;%迭代次数加一
            xk=vpa(g(x(k-1)),30);%产生新的xk,第一次产生x3;注意:可以用vpa函数,控制每次迭代产生xk的有效数字位数,提升迭代速度
            x=[x xk]; %新产生的xk依次装入数组x中,注意:x(1)=x1,x(2)=x2,x(3)=x3
            T=[T;k,xk,f(xk)];%把此次迭代产生的数据装入存储矩阵T中
        end
    end
    fprintf('   k            xk              f(xk)\n');%输出表头
    disp(vpa(T,10));%控制输出的有效数字为8位,根据精度可以自行设置
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k,T(k,2))%注意迭代次数为k-1fprintf('f(x(%d))=%.8f\n',k,T(k,3))
    

    写程序的时候要注意数组和矩阵的下标不能为0,所以迭代计数器k是从1开始的,最后输出时要注意减1;这里循环的判断是由数组x来实现的,我们可以对代码进行精简,去掉数组x,如代码块2所示:
    代码块2:不动点迭代法-精简版

    %不动点迭代法2
    clc;%清屏
    clear;%清工作区
    syms x;%定义变量x
    f(x)=input('请输入函数表达式,变量用x表示:f(x)=');
    g(x)=input('请输入等价形式:x=');  %f(x)=0等价为x=g(x)
    x0=input('请选择一个初始值:x0=');
    eps=input('请输入停止精度要求:eps=');%|b-xk|<=eps/2
    k=0;
    T=[0,x0,f(x0)];
    k=k+1;%k=1,第k次迭代
    xk=g(x0);%1次迭代
    T=[T;k,xk,f(xk)];
    while (abs(g(xk)-xk)>eps/2)||(abs(f(xk))>1)  %判断是达到求根的精度要求,未达到则执行循环(小于才是达到要求)
        if (k>1000)||(abs(f(xk))>1e15)    %1000次还没有达到精度要求的话,报错
            error('迭代出错!或许是迭代公式的问题')
        else
            k=k+1;%迭代次数加一
            xk=vpa(g(xk),30);%产生新的xk,第一次产生x3;注意:可以用vpa函数,控制每次迭代产生xk的有效数字位数,提升迭代速度
            T=[T;k,xk,f(xk)];%把此次迭代产生的数据装入存储矩阵T中
        end
    end
    T=[T;k+1,g(xk),f(g(xk))];%再加一行是因为while循环判断用的时k+1次的数据
    fprintf('   k            xk              f(xk)\n');%输出表头
    disp(vpa(T,10));%控制输出的有效数字为10位,根据精度可以自行设置
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k+1,T(k+2,2))%注意迭代次数为k次
    fprintf('f(x(%d))=%.8f\n',k+1,T(k+2,3))%当k做下标时,要加1
    

    这两个思路是有一些不同的哈,代码中需要特别注意的点我在注释里标的已经很清楚了,就不再多说了
    函数表达式的输入也可以通过内联函数inline实现,如代码块3所示:
    代码块3:不动点迭代法-内联函数版

    %不动点迭代法3
    clc;
    clear;
    format short;
    s=input('请输入函数表达式:f=','s');
    f=inline(s);
    m=input('请输入等价形式:x=','s');
    g=inline(m); %g为方程的等价形式,f(x)=0等价为x=g(x)
    x0=input('请选择一个初始值:x0=');
    eps=input('请输入停止精度要求:eps=');    %|b-xk|<=eps/2
    k=1;
    x=[x0];                                 %定义数组x
    k=k+1;
    x1=g(x0);
    x=[x x1];                               %把新产生的x1装进数组x中
    T=[1,x0,f(x0);2,x1,f(x1)];   %T初始值为23列,随着迭代增加行数
    while abs(x(k)-x(k-1))>eps/2
        if abs(f(x(k)))>1e15||(k>5000)%
            error('迭代出错!或许是迭代公式的问题')
        else
            k=k+1;
            xk=g(x(k-1));
            x=[x xk]; %x(1)=x0,x(2)=x1,x(3)=x3,
            T=[T;k,xk,f(xk)];
        end
    end
    fprintf('    k               xk               f(xk)\n');
    disp(vpa(T,10));
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k-1,T(k,2))
    

    还需要提醒一下就是迭代很有可能不收敛,因为迭代不收敛时方程f(x)的值可能越来越大,最起码不会逼近0,所以可以通过迭代次数k的值以及方程f(x)的来判断是否出现迭代出错;
    斯蒂芬森迭代、牛顿法以及简化牛顿法相较于不动点迭代而言,代码的实现思路时一样的,把迭代函数修改一下就行,其代码块分别如下:

    代码块4:斯蒂芬森迭代-内联函数版

    %斯蒂芬森迭代法1
    clc;
    clear;
    format long;
    s=input('请输入函数表达式:f=','s');
    f=inline(s);
    m=input('请输入等价形式:x=','s');
    g=inline(m);                            %g为方程的等价形式,f(x)=0等价为x=g(x)
    x1=input('请选择一个初始值:x1=');
    eps=input('请输入停止精度要求:eps=');    %|b-xk|<=eps/2
    k=1;
    y1=g(x1);     %y1=g(x0);
    z1=g(y1);     %z1=g(y1);
    x=[x1];                                 %定义数组x
    y=[y1];                                 %定义数组y
    z=[z1];                                 %定义数组z
    k=k+1;        %k=2
    x2=x1-(y1-x1)^2/(z1-2*y1+x1);
    y2=g(x2);     %;
    z2=g(y2);     %;
    x=[x x2];                               %把新产生的x2装进数组x中
    y=[y y2];                               %把新产生的y2装进数组y中
    z=[z z2];                               %把新产生的z2装进数组x中
    fprintf('    k                   xk                  yk                  zk                     f(xk)\n');
    T=[1,x1,y1,z1,f(x1);2,x2,y2,z2,f(x2)];   %T初始值为25列,随着迭代增加行数
    while abs(x(k)-x(k-1))>eps/2
        if (abs(f(x(k)))>1e15)||(k>50)
            error('迭代出错!或许是迭代初值不对的问题')
        else
            k=k+1;
            xk=x(k-1)-(y(k-1)-x(k-1))^2/(z(k-1)-2*y(k-1)+x(k-1));
            x=[x xk]; %
            yk=g(x(k));
            y=[y yk];
            zk=g(yk);
            z=[z zk];
            T=[T;k,xk,yk,zk,f(xk)];
        end
    end
    disp(T);
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k-1,T(k,2))
    

    内联函数版都是我复习前为了交作业写的,内联函数也不太好使,还是看下面这一版比较好:
    代码块5:斯蒂芬森迭代法

    %steffensen迭代法
    clc;%清屏
    clear;%清工作区
    syms x;%定义变量x
    f(x)=input('请输入函数表达式,变量用x表示:f(x)=');
    g(x)=input('请输入等价形式:x=');  %f(x)=0等价为x=g(x)
    x1=input('请选择一个初始值:x1=');
    eps=input('请输入停止精度要求:eps=');    %|b-xk|<=eps/2
    k=1;
    y1=g(x1);     %y1=g(x0);
    z1=g(y1);     %z1=g(y1);
    x=[x1];       %定义数组x
    y=[y1];       %定义数组y
    z=[z1];       %定义数组z
    k=k+1;        %k=2
    x2=x1-(y1-x1)^2/(z1-2*y1+x1);
    y2=g(x2);     %;
    z2=g(y2);     %;
    x=[x x2];                               %把新产生的x2装进数组x中
    y=[y y2];                               %把新产生的y2装进数组y中
    z=[z z2];                               %把新产生的z2装进数组x中
    T=[1,x1,y1,z1,f(x1);2,x2,y2,z2,f(x2)];   %T初始值为25列,随着迭代增加行数
    while abs(x(k)-x(k-1))>eps/2
        if (abs(f(x(k)))>1e15)||(k>500)
            error('迭代出错!或许是迭代初值不对的问题')
        else
            k=k+1;
            xk=vpa(x(k-1)-(y(k-1)-x(k-1))^2/(z(k-1)-2*y(k-1)+x(k-1)),30);
            x=[x xk]; %
            yk=g(x(k));
            y=[y yk];
            zk=g(yk);
            z=[z zk];
            T=[T;k,xk,yk,zk,f(xk)];
        end
    end
    fprintf('  k             xk           yk           zk                   f(xk)\n');
    disp(vpa(T,10));%控制输出的有效数字为10位,根据精度可以自行设置
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k-1,T(k,2))
    

    注意这一行:

     xk=vpa(x(k-1)-(y(k-1)-x(k-1))^2/(z(k-1)-2*y(k-1)+x(k-1)),30);
    

    要控制一下精度哈,不然直接用分数计算,计算量太大了,算不动,太慢了
    也可以考虑精简一下代码把数组x,y,z去掉,但是并不如这样直观,可以自己动手试着改一下,我懒得改了~

    牛顿法代码:
    代码块6:牛顿法

    clc;clear;
    format long;
    syms x;
    f(x)=input('请输入函数表达式,变量用x表示:f(x)=');
    x1=input('请选择一个初始值:x1=');
    eps=input('请输入停止精度要求:eps='); 
    df(x)=diff(f,x);%f(x)的导数
    g(x)=f(x)/df(x);
    h(x)=x-g(x);%迭代函数
    k=1;
    xk=x1;
    k=k+1;
    xk=h(xk); 
    T=[1,x1,f(x1);k,xk,f(xk)];   %T初始值为23列,随着迭代增加行数
    while abs(h(xk)-xk)>eps/2||f(xk)>eps/2
        if (df(xk)==0)||(k>5000)        %error('迭代出错!或许是迭代初值的问题')
        else
            k=k+1;
            xk=vpa(h(xk),30); 
            T=[T;k,xk,f(xk)];
        end
    end
    fprintf('     k           xk              f(xk)\n');
    disp(vpa(T,10))
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k-1,T(k,2))%注意迭代次数为k-1
    fprintf('f(x(%d))=%.8f\n',k-1,T(k,3))
    

    懒了懒了,不想写了,再贴一个代码就去打游戏去;
    简化牛顿法代码:

    clc;clear;
    format long;
    syms x;
    f(x)=input('请输入函数表达式,变量用x表示:f(x)=');
    x1=input('请选择一个初始值:x1=');
    eps=input('请输入停止精度要求:eps='); 
    df(x)=diff(f,x);%f(x)的导数
    g(x)=f(x)/df(x);
    h(x)=x-g(x);%迭代函数
    k=1;
    xk=x1;
    k=k+1;
    xk=h(xk); 
    T=[1,x1,f(x1);k,xk,f(xk)];   %T初始值为23列,随着迭代增加行数
    while abs(h(xk)-xk)>eps/2||f(xk)>eps/2
        if (df(xk)==0)||(k>5000)        %error('迭代出错!或许是迭代初值的问题')
        else
            k=k+1;
            xk=vpa(h(xk),30); 
            T=[T;k,xk,f(xk)];
        end
    end
    fprintf('     k           xk              f(xk)\n');
    disp(vpa(T,10))
    fprintf('经过%d次迭代,函数方程根的近似解为:x=%.8f\n',k-1,T(k,2))%注意迭代次数为k-1fprintf('f(x(%d))=%.8f\n',k-1,T(k,3))
    

    溜了溜了~~~

    展开全文
  • 在对第4题第3问进行分析的过程中,发现matlab程序能够更加直观的求解计算这个问题。 clc; clear; x=2; m=0.00001; N=60; for k=1:N y=x-1/2/sqrt(3)*(x^2-3); if (abs(x-y))>=m format long k y=double(y) x...
  • 分别用Matlab和C写了一下,初学Matlab,如有不足还请指正。 实验内容: 1)在区间[0,1]内用二分法求方程ex+10∗x−2e^x+10*x-2ex+10∗x−2的近似根,要求误差超过0.5×10−30.5\times10^{-3}0.5×10−3。 2)取...
  • Promble1 求出f(x)=3x2−ex=0f(x)=3x2−ex=0...首先我们利用matlab绘图确定出根的大致区域。 由图可知存在三个有根区间[−1,0],[0,1],[3,4][−1,0],[0,1],[3,4][-1,0],[0,1],[3,4] Step1Step1\color {red}{St...
  •  【迭代流程】 若左右两端取值不同,则取其中,求其函数值,取中点和与中点取值异号的端点构成新的区间(其中必有零点)。进行下一次迭代。 2) 实现二分求根算法  使用MATLAB实现二分法代码如下。捕捉异常...
  • 【源码】牛顿迭代法求根的matlab实现

    千次阅读 多人点赞 2020-10-06 10:46:20
    牛顿迭代法本质上是一种特殊的不动点迭代,只不过它的迭代函数的构造比较特殊,所以就代码上来看,和不动点迭代法求根的是完全一样的,所不同的是,其输入的不动点迭代函数满足f_x=x-f(x)/f’(x).下面是简要证明 ...
  • 比较全的迭代法源代码 有Newton法二分法非线性方程迭代法求解multiplicity secant法clamped_cubic_spline法以及不动点法等 非常全了已经= =
  • 一、不动点法(用斯特芬森迭代法进行加速) 1.x^2-3*x+2-exp(x)=0 %f(x)=x^2-3*x+2-exp(x)=0 %xk+1=1/3*xk^2+2/3-1/3*e^xk x=1; fai=@(x)1/3*x^2+2/3-1/3*exp(x); y=fai(x); z=fai(y); wucha=10^(-8); k=(y-x)^2/(z...
  • 简单迭代法求方程根的MATLAB程序

    千次阅读 2012-07-13 22:30:20
    function [x_reality,n_reality] = Simple_stepit...% 简单迭代法(也叫不动点迭代法)求解方程f_name = 0根的MATLAB实现 % f_name为迭代函数 % x_start为开始迭代的初始坐标 % tolerance为函数迭代的精度要求 ...
  • 数值分析作业 姓 名 王建忠 学 号 132080202006 学 院 能源与动力工程 专 业 机械电子工程 2013年 12月16 日 1.Lagrange插值多项式程序 function f=nalagr(x,y,xx) %x为节点向量 %y为节点函数值 %xx是插值 syms s ...
  • 文章目录一、二分法二、不动点法(FPI)三、牛顿四、割线五、练习 这个学期在学数值分析,课程内容相当于学过的计算方法的升级版,数值分析是一门很有用的学科,可以解决很多工程上实际的问题,学习这门课最好的...
  • Matlab 数值计算迭代求根方法总结

    千次阅读 2019-03-22 14:11:30
    不动点迭代法 (1)原理:。需要确定,通过产生的序列来确定。 (2)优劣:通过定理可知不动点个数。原理简单。有可能出现发散序列,为单调发散序列或震荡发散序列。 二分法 (1)原理: 寻找起始点区间,通过...
  • 再者我们考究一下 牛顿迭代法求最优问题,牛顿法相对最速下降法的速度就快得多了,而且还有一个好处就是能高度逼近最优值,而不会出现死等待的现象。 如后面的精度,你可以取如:0.0000000000001等。 但是牛顿法也...

空空如也

空空如也

1 2 3
收藏数 55
精华内容 22
关键字:

matlab不动点迭代法

matlab 订阅