精华内容
下载资源
问答
  • 数值分析课程设计常微分方程组初值问题数值解的实现和算法分析毕业论文.doc
  • Matlab 解常微分方程初值问题题目:Matlab 解常微分方程初值问题设计目的:1、熟练掌握Matlab的基本编程方法,及其编程风格。2、熟练掌握Matlab常用函数的使用。3、与本专业相关知识相结合,掌握其在程序开发中...

    Matlab 解常微分方程的初值问题

    题目:Matlab 解常微分方程的初值问题

    设计目的:

    1、熟练掌握Matlab的基本编程方法,及其编程风格。

    2、熟练掌握Matlab常用函数的使用。

    3、与本专业相关知识相结合,掌握其在程序开发中的应用方法

    以及和word、C语言等接口方法。

    4、通过计算机数值求解的方式来加深微分方程解的理解。

    5、熟悉初等方法可获得解析解之外的数值近似解的求解方法,提

    高对差分格式的认识和离散化分析问题的技巧,加深对理论课程的学习和理解,为数学专业和信息与计算科学专业其他后继课程的学习打好基础。

    设计内容:

    已知一个三阶微分方程:,利用matlab软件求这个三阶微分方程在初值 下的解。

    原三阶微分方程可化为:

    令 则原三阶微分方程可化为微分方程组 在初值 下的解。

    程序流程:

    程序代码:

    %编写函数文件rigid.m

    function dy = rigid(t,y)

    dy = zeros(3,1); % a column vector

    dy(1) = y(2) ;

    dy(2) =y(3);

    dy(3) = 2*(1-y(1)^2)*y(3)-y(1)*y(2);

    %调用函数ode45求解,时间区间为[0,10]

    [t,Y] = ode45(@rigid,[0 10],[1 0 -1])

    t =

    0

    0.0001

    0.0001

    0.0002

    0.0002

    0.0005

    0.0007

    ………………

    0.9383

    1.0665

    1.1947

    1.2918

    1.3889

    1.4860

    ………………

    6.2916

    6.2922

    6.2928

    6.2934

    6.2940

    6.2947

    6.

    由于数据太多,这里只列举部分

    %绘制解的曲线

    plot(t,Y(:,1),'-',t,Y(:,2),'-.',t,Y(:,3),'.')

    %给图形加标注

    title('Solution of Rigid Equation')

    xlabel('time T')

    ylabel('solution Y')

    legend('Y1','Y2','Y3')

    设计结果:

    未加图形标注时的图

    加了图形标注后的图

    结果分析:

    输出结果[T,Y]中T为时间点组成的向量。Y为对应于T中时间点的y(1)、y(2)和y(3)的值。此次利用matlab数值方法来求解微分方程主要是把求解的时间划分成有限步,对应于每一步将计算出一个解,如果求得的解不满足误差限制,则减少步长,再求解。如此重复,直到满足误差限为止。

    课设总结:

    最初拿到题目后,开始读题,知道题目所表达的意思及我们所要完成的目的,达到的效果后,便开始了做题。

    首先是找一个三阶微分方程。然后把它化简为标准形式,再利用matlab软件求解。其中,在利用matlab求解时遇到一些问题,比如画图时调用已经编号的rigid函数时的调用格式不正确,还有就是给图形家标注时程序的引号没有切换成英文输入法状态下的等一些问题。但是经过多次调试,检查,修改后程序运行总算成功。

    通过此次课程设计,我已经基本掌握Matlab的基本编程方法,及其编程风格。且能较熟练掌握Matlab常用函数的使用。此次设计后我的收获不少。

    参考文献:

    [1] 张圣勤编 MATLAB7.0 机械工业出版社

    [2]周义仓 靳祯 秦军林编 常微分方程极其应用 科学出版社

    [3]韩明 王家宝 李林编 数学实验(matlab版) 同济大学出版社

    [4]汪晓银 皱庭荣编 数学软件与数学实验 科学出版社

    2、把这个三阶微分方程化为形如 的标准形式

    1、已知一个三阶微分方程

    3、编写函数文件rigid.m

    4、调用函数文件rigid.m,利用ode45求解

    5、绘制解的曲线

    展开全文
  • 目的 研究偏微分方程组的初值问题。方法广义条件对称方法。结果得到偏微分方程组所允许的广义条件对称和相应的...结论将偏微分方程组的初值问题转化为常微分方程组初值问题,为进一步研究该类方程组提供了重要信息。
  • 常微分方程初值问题与边值问题

    万次阅读 2018-04-12 13:45:04
    任何关于算法、编程、AI行业知识或博客内容的问题,可以随时扫码关注公众号「图灵的猫」,加入”学习小组“,沙雕博主在线答疑~此外,公众号内还有更多AI、算法、编程和大数据知识分享,以及免费的SSR节点和学习资料...

    任何关于算法、编程、AI行业知识或博客内容的问题,可以随时扫码关注公众号「图灵的猫」,加入”学习小组“,沙雕博主在线答疑~此外,公众号内还有更多AI、算法、编程和大数据知识分享,以及免费的SSR节点和学习资料。其他平台(知乎/B站)也是同名「图灵的猫」,不要迷路哦~

     

    初值问题是微分方程的初始条件,即自变量为零时的函数值;边值问题则是方程的边界条件,即自变量取某一值对应的函数值。对于一阶方程,往往只需要初始条件就可以得到方程的特解,对于二阶或者二阶以上的微分方程,则需要边界条件。

    初值问题

    初值问题是指在自变量的某值给出适当个数的附加条件,用来确定微分方程的特解的这类问题。如果在自变量的某值给出适当个数的附加条件,用来确定微分方程的特解,则这类问题称为初值问题。一般使用欧拉法(基于方向场)用来求解常系数系统是最常见的求解初值问题的方法,因此初值问题有时也叫作欧拉初值问题。

    边值问题

    边值问题是定解问题之一,只有边界条件的定解问题称为边值问题。二阶偏微分方程(组)一般有三种边值问题:第一边值问题又称狄利克雷问题,它的边界条件是给出未知函数本身在边界上的值;

    给出一个常微分方程,然后有条件限制,这个条件就是两个点,这两个点构成一个区间。例如:给出一个微分方程为:y″+ m(x)y′+ n(x)y = f(x),另外再给出在求解区间[a,b]两个端点的条件:x=a时,y=c;x=b时,y=d。

    展开全文
  • 分别给出了系数非齐次线性微分方程组系数非齐次线性差分方程组在给定的初始条件下的求解公式。
  • 1.dx/dt=cos(y),t∈[0,T] dy/dt=sin(x),t∈[0,T] x(0)=0,y(0)=0 2.用梯形公式,显式欧拉,隐式欧拉,改进欧拉求解 3.有注释再好不过 4.可以有偿
  • m=input('请输入常微分方程的阶数m='); a=input('请输入x下限a='); b=input('请输入x上限b='); h=input('请输入步长h='); ym=input('令y(1,1)=y,y(2,1)=y’,y(3,1)=y’’...请输入ym=','s'); %输入

    参考教材《数值分析》李乃成.梅立泉

    clear
    clc
    format long
    m=input('请输入常微分方程的阶数m=');
    a=input('请输入x下限a=');
    b=input('请输入x上限b=');
    h=input('请输入步长h=');
    ym=input('令y(1,1)=y,y(2,1)=y’,y(3,1)=y’’...请输入ym=','s');     %输入的时候必须按照这个形式输入y1=y(1,1);
    if m==1                                               %一阶初值问题单独求解
        mm=(b-a)/h;
        y(1,1)=input('请输入在初值点的函数值f(a)=');
        x=a;
        y11(1)=y(1,1);
        for k1=2:(mm+1)
            y1=y(1,1);
            K(1,1)=h*(eval(ym));                    

    展开全文
  • 用 GSL 解常微分方程初值问题

    千次阅读 2012-05-12 12:22:46
    用 GSL 解常微分方程初值问题 GNU Scientific Library (GSL) 是一个用于科学计算的...n 维的常微分方程组一般可以描述为: \[ \frac{{dy_i (t)}}{{dx}} = f_i (t,y_1 (t), \ldots y_n (t)) \] 其中 i = 1,\ldots,n

    用 GSL 解常微分方程初值问题

    GNU Scientific Library (GSL) 是一个用于科学计算的 C 语言类库。这里介绍如何用 GSL 来进行常微分方程初值问题的计算。

    n 维的常微分方程组一般可以描述为:
    \[
    \frac{{dy_i (t)}}{{dx}} = f_i (t,y_1 (t), \ldots y_n (t))
    \]
    其中 i = 1,\ldots,n
    相应的初值条件为 y_i (t_0) = Y_{i0}

    GSL 提供了许多的方法用来解决常微分方程的初值问题,包括底层的方法如 Runge-Kutta 法和 Bulirsch-Stoer 法,也包括高层的算法如自适应步长控制等。

    GSL 中用一个结构体 gsl_odeiv_system 来描述常微分方程组,

    typedef struct  
    {
      int (* function) (double t, const double y[], double dydt[], void * params);
      int (* jacobian) (double t, const double y[], double * dfdy, double dfdt[], void * params);
      size_t dimension;
      void * params;
    }
    gsl_odeiv_system;

    function 是一个函数指针,指向用户定义的函数,t, y[], params作为输入参数,dydt 返回 n 维的向量场 f_i(t, y, params),计算成功时,函数应该返回 GSL_SUCCESS;

    jacobian 也是一个函数指针,指向用户定义的函数,t, y[], params作为输入参数,dfdt 返回 \partial f_i /\partial t,dfdy 返回 Jacobian 矩阵 J_{ij}, 存储方式为J(i,j) = dfdy[i * dimension + j],计算成功时,函数应该返回 GSL_SUCCESS;

    对于一些简单的算法并不需要 Jacobian 矩阵,此时可以将 jacobian 指向空(NULL).但是大多数高效的算法都要用到 Jacobian 矩阵,因此在能提供 Jacobian 矩阵时应该尽量的提供。

    dimension 描述系统的维数。

    params 为一个任意的指针,具体的作用在下面的例子中讲解。

    下面分为三个部分介绍 GSL 中提供的函数。

    1 步进函数

    步进函数是用户可以调用的最底层的功能函数,其他的高层函数也都是通过调用步进函数来完成最后的计算工作的。

    用来分配和释放所需空间

    gsl_odeiv_step * gsl_odeiv_step_alloc(const gsl_odeiv_step_type * T, size_t dim);
    int  gsl_odeiv_step_reset(gsl_odeiv_step * s);
    void gsl_odeiv_step_free(gsl_odeiv_step * s);

    其中 gsl_odeiv_step_type 可以为以下值:

    gsl_odeiv_step_rk2;    //二阶 Runge-Kutta 法
    gsl_odeiv_step_rk4;    //四阶经典 Runge-Kutta 法
    gsl_odeiv_step_rkf45;  //Runge-Kutta-Fehlberg 法
    gsl_odeiv_step_rkck;  //Runge-Kutta Cash-Karp
    gsl_odeiv_step_rk8pd; //Runge-Kutta Prince-Dormand
    gsl_odeiv_step_rk2imp; //隐式的 Runge-Kutta 
    gsl_odeiv_step_rk2simp;
    gsl_odeiv_step_rk4imp; //Implicit 4th order Runge-Kutta at Gaussian points
    gsl_odeiv_step_bsimp; //隐式的 Bulirsch-Stoer method of Bader and Deuflha (需要 Jacobian 矩阵)
    gsl_odeiv_step_gear1; //M=1 implicit Gear method
    gsl_odeiv_step_gear2; //M=2 implicit Gear method

    返回一些所用算法的信息

    const char * gsl_odeiv_step_name(const gsl_odeiv_step *);
    unsigned int gsl_odeiv_step_order(const gsl_odeiv_step * s);

    具体的步进计算函数如下

    int  gsl_odeiv_step_apply(gsl_odeiv_step *s, double t, double h, double y[], double yerr[], const double dydt_in[], double dydt_out[], const gsl_odeiv_system * dydt);

    计算 t -> t +h, t + h 时刻的值存储在 y[] 中,yerr[] 是对 y[] 计算误差的估计值。如果 dydt_in[] 不为 null ,dydt_in[] 应为 t 时刻的对时间的导数,如果没有提供 dydt_in[] 的话,这个函数的内部会作相应的计算。dydt_out[] 输出t + h 时刻对时间的导数。

    下面是一个简单的例子:
    考虑二阶的非线性Van der Pol 方程,
    \[
    x''(t) + \mu x'(t)(x(t)^2  - 1) + x(t) = 0
    \]
    这个方程可以被化简为如下的常微分方程组:

    y_1' = -y_0 + \mu y_1 (1 - {y_0}^2)
    y_0' = y_1

    Jacobian 矩阵为:
    \[
    J = \left( {\begin{array}{*{20}c}
       0 & 1  \\
       { - 1 - 2\mu y_0 y_1} & { \mu (1-{y_0}^2) }  \\
    \end{array}} \right)
    \]

    #include <stdio.h>
    #include <gsl/gsl_errno.h>
    #include <gsl/gsl_matrix.h>
    #include <gsl/gsl_odeiv.h>
    
    int func (double t, const double y[], double f[], void *params)
    {// 定义微分方程组
     double mu = *(double *)params;
     f[0] = y[1];
     f[1] = -y[0] - mu*y[1]*(y[0]*y[0] - 1);
     return GSL_SUCCESS;
    }
    
    int jac (double t, const double y[], double *dfdy, double dfdt[], void *params)
    {
     double mu = *(double *)params;
     gsl_matrix_view dfdy_mat = gsl_matrix_view_array (dfdy, 2, 2);
     gsl_matrix * m = &dfdy_mat.matrix;
     gsl_matrix_set (m, 0, 0, 0.0);
     gsl_matrix_set (m, 0, 1, 1.0);
     gsl_matrix_set (m, 1, 0, -2.0*mu*y[0]*y[1] - 1.0);
     gsl_matrix_set (m, 1, 1, -mu*(y[0]*y[0] - 1.0));
     dfdt[0] = 0.0;
     dfdt[1] = 0.0;
     return GSL_SUCCESS;
    }
    
    int main (void)
    {
     const gsl_odeiv_step_type * T = gsl_odeiv_step_rk8pd;
     gsl_odeiv_step * s = gsl_odeiv_step_alloc (T, 2);
    
     double mu = 10;
     gsl_odeiv_system sys = {func, jac, 2, &mu};
     double t = 0.0, t1 = 100.0;
     double h = 1e-6; // 步进为 h
     double y[2] = { 1.0, 0.0 }; //初值
     double y_err[2];
     double dydt_in[2], dydt_out[2];
     
     GSL_ODEIV_FN_EVAL(&sys, t, y, dydt_in); //计算初始时刻的dy/dt
     while (t < t1)
     {
      int status = gsl_odeiv_step_apply (
      s, t, h, y, y_err, dydt_in, dydt_out, &sys);
      if (status != GSL_SUCCESS) break;
      dydt_in[0] = dydt_out[0];
      dydt_in[1] = dydt_out[1];
      t += h;
      printf ("%.5e %.5e %.5e\n", t, y[0], y[1]);
     }
     gsl_odeiv_step_free (s);
     return 0;
    }

    程序很简单,不需要再解释了。
    这种方法的缺点是积分步长需要自己确定,步长太大计算结果会有很大的误差,步长太小效率低下,而且步长太小误差可能反而增大。

    因此,一般我们都会选用更高级的算法,也就是自适应步长算法。

    2 自适应步长控制

    gsl_odeiv_control * gsl_odeiv_control_standard_new(double eps_abs, double eps_rel, double a_y, double a_dydt);
    gsl_odeiv_control * gsl_odeiv_control_y_new(double eps_abs, double eps_rel);
    gsl_odeiv_control * gsl_odeiv_control_yp_new(double eps_abs, double eps_rel);
    gsl_odeiv_control * gsl_odeiv_control_scaled_new(double eps_abs, double eps_rel, double a_y, double a_dydt, const double scale_abs[], size_t dim);

    这几个函数大同小异,都是检查一个步进函数步进后的误差,与用户设定的误差水平进行比较,然后决定是否要调整步长。具体各个参数的含义请看手册。

    gsl_odeiv_control * gsl_odeiv_control_alloc(const gsl_odeiv_control_type * T);

    分配空间给新的步长控制函数,一般用户很少使用,除非自定义了新的步长控制函数

    int gsl_odeiv_control_init(gsl_odeiv_control * c, double eps_abs, double eps_rel, double a_y, double a_dydt);

    初始化步长控制函数

    void gsl_odeiv_control_free(gsl_odeiv_control * c);

    释放相应的空间

    int gsl_odeiv_control_hadjust (gsl_odeiv_control * c, gsl_odeiv_step * s, const double y0[], const double yerr[], const double dydt[], double * h);

    这个函数用来计算一个合适的步长 h, 步长增大时返回GSL_ODEIV_HADJ_INC,步长件小时返回GSL_ODEIV_HADJ_DEC,步长不做调整时返回GSL_ODEIV_HADJ_NIL。

    const char * gsl_odeiv_control_name(const gsl_odeiv_control * c);

    返回步长控制函数的名称。

    下面仍然以上面提到的 Van der Pol 方程为例。

    int main (void)
    {
     const gsl_odeiv_step_type * T = gsl_odeiv_step_rk8pd;
     gsl_odeiv_step * s = gsl_odeiv_step_alloc (T, 2);
     gsl_odeiv_control * c = gsl_odeiv_control_y_new (1e-5, 0.0);
     double mu = 10;
     gsl_odeiv_system sys = {func, jac, 2, &mu};
     double t = 0.0, t1 = 100.0;
     double h = 1e-2; // 步进为 h
     double *ph = &h;
     double y[2] = { 1.0, 0.0 }; //初值
     double y_const[2];
     double y_err[2];
     double dydt_in[2], dydt_out[2];
     int status;
     
     GSL_ODEIV_FN_EVAL(&sys, t, y, dydt_in); //计算初始时刻的dy/dt
     while (t < t1)
     {
      gsl_odeiv_step_apply (s, t, h, y_const, y_err, dydt_in, dydt_out, &sys);
      status = gsl_odeiv_control_hadjust (c, s, y_const, y_err, dydt_in, ph);
      gsl_odeiv_step_reset (s);
      
      status = gsl_odeiv_step_apply (s, t, h, y, y_err, dydt_in, dydt_out, &sys);
      
      y_const[0] = y[0];
      y_const[1] = y[1];
        
      if (status != GSL_SUCCESS) break;
      dydt_in[0] = dydt_out[0];
      dydt_in[1] = dydt_out[1];
      t += h;
      printf ("%.5e %.5e %.5e\n", t, y[0], y[1]);
     }
     gsl_odeiv_control_free(c);
     gsl_odeiv_step_free (s);
     return 0;
    }

    3 进化算法

    进化算法是最高层的算法,它结合了步进函数和步长控制函数。它可以自动调整步长。

    用来分配和释放所需空间

    gsl_odeiv_evolve * gsl_odeiv_evolve_alloc (size t dim);
    int gsl_odeiv_evolve_reset (gsl odeiv evolve * e);
    void gsl_odeiv_evolve_free (gsl odeiv evolve * e);
    int gsl_odeiv_evolve_apply (gsl odeiv evolve * e, gsl odeiv control * con, gsl odeiv step * step, const gsl odeiv system * dydt, double * t, double t1, double * h, double y[]);

    这个函数自动计算下一步的值,计算过程中可能会调整 h ,但是会保证 t + h <= t1,因此多次计算后会精确的到达t1。

    int main (void)
    {
     const gsl_odeiv_step_type * T = gsl_odeiv_step_rk8pd;
     gsl_odeiv_step * s = gsl_odeiv_step_alloc (T, 2);
     gsl_odeiv_control * c = gsl_odeiv_control_y_new (1e-6, 0.0);
     gsl_odeiv_evolve * e = gsl_odeiv_evolve_alloc (2);
     double mu = 10;
     gsl_odeiv_system sys = {func, jac, 2, &mu};
     double t = 0.0, t1 = 100.0;
     double h = 1e-6;
     double y[2] = { 1.0, 0.0 };
     while (t < t1)
     {
      int status = gsl_odeiv_evolve_apply (e, c, s, &sys, &t, t1, &h, y);
      if (status != GSL_SUCCESS) break;
      printf ("%.5e %.5e %.5e\n", t, y[0], y[1]);
     }
     gsl_odeiv_evolve_free (e);
     gsl_odeiv_control_free (c);
     gsl_odeiv_step_free (s);
     return 0;
    }

    经常我们需要微分方程的解在某些特定时刻的值(比如等时间间隔的一系列时刻的值),这时如果只是简单的采用进化算法是不行的,因为我们无法控制步长。下面的代码给出了一种解决办法。

    for (i = 1; i <= 100; i++)
    {
     double ti = i * t1 / 100.0;
     while (t < ti)
     {
      gsl_odeiv_evolve_apply (e, c, s, &sys, &t, ti, &h, y);
     }
     printf ("%.5e %.5e %.5e\n", t, y[0], y[1]);
    }




     

    展开全文
  • 大连圣亚海洋世界官网-2021年2月7日发(作者:转身之后还是你)用Matlab求常微分方程<br>(ODE)的初值问题(IVP)本节考虑一阶常微分方程u...对一阶常微分方程组初值问题u1(<p>t0)u10f1(t,u1,<...
  • 常微分方程组数值求解;主要内容 数值求解常微分方程组函数概述 非刚性/刚性常微分方程问题求解 隐式微分方程组求解 微分代数方程(DAE)与延迟微分方程(DDE)求解 边值问题求解 ;第一节数值求解常微分方程组函数概述;一...
  • 为了研究一阶线性模糊微分方程组的模糊初值问题,提出了模糊微分方程组的刻画方程组和关联解的概念,讨论了精确初值对刻画方程组解的影响,利用精确初值与关联解之间的关系,定义了模糊微分方程组初值问题解,同时给出了...
  • 利用Taylor展开工具提出常微分方程初值问题的一类单步求解法,并证明该方法的相容性、稳定性和收敛性。该方法克服了传统单步法的缺点,既不使用高阶导数,同时在每一步计算时使用的函数值的个数又明显少于传统方法的...
  • 常微分方程初值问题数值解法 一、问题提出 科学计算中经常遇到微分方程(初值问题,需要利用Euler法,改进Euler法,Rung-Kutta方法求其数值解,诸如以下问题: (1) (3) (4)利用四阶标准R- K...
  • 1. 熟悉求解常微分方程初值问题的有关方法和理论,主要是改进欧拉法; 2. 会编制上述方法的计算程序,包括求解微分方程组的计算程序; 3. 针对实习编制程序,并上机计算其所需要的结果; 4. 通过对各种求解方法的...
  • 简单的常微分方程()初值问题

    千次阅读 2015-08-17 19:03:42
    问题A,B,C,D,EA,B,C,D,E 五个化合物,AA 反应后生成 BB,BB 反应后生成CC,CC 反应后生成 DD,DD 反应后生成 EE,即A—→B—→C—→D—→EA—\rightarrow B—\rightarrow C—\rightarrow D—\rightarrow E ...
  • 我们采用了Duan-Rach-Wazwaz改进的Adomian分解方法来数值求解非线性常微分方程组初值问题。 为了确认该方法的实用性,鲁棒性和可靠性,在某些情况下,我们将改进的Adomian分解方法与MATHEMATICA解决方案以及四阶...
  • %参数初值,其实是不知道的 ( W; z+ S& H7 `3 z! k lb = [-inf -inf -inf -inf -inf -inf -inf -inf]; % 参数下限 % ?- }+ Z$ {- \ub = [inf inf inf inf inf inf inf inf]; % 参数上限0 G9 t' h& @2 j- g5 P u0 ...
  • 我们的重点是开发和实施新的两步混合方法,用于直接求解一般的二阶常微分方程。 在该方法的开发中,采用幂级数作为基础函数,并且将出现的方程组微分系统并置在所有电网和离网点。 所得方程在选定点处插值。 然后,...
  • 第三篇常微分方程组求解101常微分方程组的MATLAB10.1 常微分方程(组)的MATLAB符号求解10.1.1 用MATLAB求常微分方程(组)的通解调用格式一: S=dsolve ('eqn','var')调用格式二: S=dsolve ('eqn1','eqn2', ......
  • Matlab求常微分方程组的数值解

    万次阅读 多人点赞 2020-03-08 09:50:50
    上篇博客介绍了Matlab求解常微分方程组解析解的方法:博客地址 微分方程组复杂时,无法求出解析解时,就需要求其数值解,这里来介绍。 以下内容按照Matlab官方文档提供的方程来展开(提议多看官方文档) 介绍一下...
  • #先上代码后补笔记# #可以直接复制粘贴调用的MATLAB函数代码!# 1. 朗格-库塔(Runge-Kutta)方法族 目前只实现了四阶Runge-Kutta方法。...% 朗格-库塔(Runge-Kutta)算法解常微分方程); % 输入四...
  • 数值方法: 我们的实验目标是解常微分方程其中包括几类问题一阶常微分初值问题高阶 常微分初值问题常微分方程组初值问题二阶常微分方程边值问题二阶线性常 微分方程边值问题 对待上面的几类问题我们分别使用不同的...
  • 实验五、常微分方程初值问题的数值解法 ​ 常微分方程的求解问题在实践中经常遇到,因此研究常微分方程的数值解法就很有必要。欧拉方法是最简单、最基本的方法,利用差商代替微商,就可得到一系列欧拉公式。这些...
  • fprintf('x%d = %f y%d = %f\n', i, x, i, y) end main.m clc clear Euler1(0, 1, 1, 10) C语言 #include #include double f(double x, double y){ //微分方程右端函数 return (y - 2 * x / y); } void Euler...
  • 最近同学毕设需要求解循坏摆的微分方程,我在帮忙过程中学习了一下常微分方程的解析解和数值解的求法,在此分享。以下讲解遵循Matlab官方文档提供的方程和写法。(强烈建议大家有问题多看官方文档,非常有用)介绍一下...
  • 第9章-常微分方程初值问题数值解法9.1 引言9.2 简单的数值方法9.3 龙格-库塔方法9.4 单步法的收敛性与稳定性9.5 线性多步法9.6 线性多步法的收敛性与稳定性9.7 一阶方程组与刚性方程组 9.1 引言 9.2 简单的数值方法 ...
  • //用RKG法求解常微分方程组 #include #include #include #include using namespace std; class s_ode { private:  int i, j, l, n;  double a, b, c, d, h, x, x1, xi, xf;  double *b1, *b2, *b3, *g, *y, *...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 992
精华内容 396
关键字:

常微分方程组的初值问题