数值计算方程求解实现

最新推荐文章于 2022-06-24 16:01:54 发布
最新推荐文章于 2022-06-24 16:01:54 发布
阅读量1.8k 收藏 1
点赞数
分类专栏： 数值计算 文章标签： 数值计算 方程求解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaofengcanyuexj/article/details/17454713
版权

原创作品，出自 “晓风残月xj” 博客，欢迎转载，转载时请务必注明出处（http://blog.csdn.net/xiaofengcanyuexj）。

由于各种原因，可能存在诸多不足，欢迎斧正！

二、引言

   计算机不具有人的思维，那么如果想要求得一个方程的精确解，需要将这类方程的求根公式输入计算机，然而多数方程不存在求根公式，因此求精确根非常困难，甚至不可能，从而寻找方程的近似根就显得特别重要。 

    下面总结求得方程近似解的算法，虽然每一步计算过程的具体运算复杂，但每一步的方式相同，所以可以通过编写程序，利用循环和迭代让计算机完成。

三、算法描述

1、二分法（Bisection）

原函数：f(x)=cosx-0.5

（1）初始化x1和x2分别为0和π/2，f(x1)和f(x2)显然异号。说明（x1，x2）内一定存在0点。

（2）求出f[(x1+x2)/2]的值，并求出真实解π/3与(x1+x2)/2的误差。

    如果f(x1)*f[(x1+x2)/2]大于0，则0点在(x1+x2)/2的右侧，这种情况下令x1=(x1+x2)/2。

如果f(x1)*f[(x1+x2)/2]大于0，则0点在(x1+x2)/2的右侧，这种情况下令x1=(x1+x2)/2。

如果f(x1)*f[(x1+x2)/2]=0，则0点就是(x1+x2)/2。

（3）重复（2）—（3）步直到满意为止。

2、非线性内插法（Linear-interpolation）

原函数：f(x)=cosx-0.5

（1）初始化x1和x2分别为为0和π/2。

（2）求出(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))的值。计算真实解与x0的误差。

    如果f(x1)*(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))大于0，则0点在(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))的右侧，在这种情况下令(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))。

如果f(x1)*(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))小于0，则0点在(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))的左侧，在这种情况下令(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))。

如果f(x1)*(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))=0，则0点就是(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1))。

（3）重复（2）—（3）步直到满意为止。

3、牛顿迭代法（Nowton raphson）

原函数：f(x)=cosx-0.5

（1）初始化x0为π/2，x0显然在0点的右侧。

（2）求出x0-(f(x0)/(-sin(x0)))的值，并赋给x0。计算真实解与x0的误差。

（3）重复（2）—（3）步直到满意为止。

4、截距法（Secant） 

原函数：f(x)=cosx-0.5

（2）初始化x0和x1分别为为0和π/2，f(x1)和f(x2)显然异号。说明（x0，x2）内一定存在0点。

（2）求出x1-(x1-x0)*f(x1)/(f(x1)-f(x0))的值，并赋给x0。计算真实解与x0的误差。

（3）求出x1-(x1-x0)*f(x1)/(f(x1)-f(x0))的值，并赋给x1。计算真实解与x1的误差。

（4）重复（2）—（4）步直到满意为止。

5、直接迭代法I（Direct iteration1）

原函数：f(x)=cosx-0.5

（1）令g(x)=x+cosx-0.5

（2）初始化x0=0。

（3）求出g(x0)的值，并赋给x0。计算真实解与x0的误差。

（4）重复（2）—（4）步直到满意为止。

6、直接迭代法II（Direct iteration2）

原函数：f(x)=cosx-0.5

（1）令g(x)=2x*cosx

（2）初始化x0=0。

（3）求出g(x0)的值，并赋给x0。计算真实解与x0的误差。

（4）重复（2）—（4）步直到满意为止。

7、直接迭代法III（Direct iteration3）

原函数：f(x)=cosx-0.5

（1）令g(x)=4*x*(x-π)/(π*π)

（2）初始化x0=π/2。

（3）求出x0-f(x0)/g(x0)的值，并赋给x0。计算真实解与x0的误差。

（4）重复（2）—（4）步直到满意为止。

五、实验及分析

数据分析：

上述实验数据在我们的个人计算机数据范围，精度的因素影响下基本与教材一致。每次迭代的前几次结果几乎完全一样，足以说明程序的正确性。后几次往往由于数据太小，在有限字节内在存储，运算等方面存在一定误差，属系统误差，排除算法实现上的硬伤。

有必要提出，Direct Interration2 的初值不是书上所说的PI/2，而是0.0635232+PI/3,这点我们在实现算法时深受其害，代初值PI/2是得不到书上的测试数据的。0.0635232+PI/3是由x-x*=e这个数学关系得到的。

而且Direct Interration3的初值0很明显是有问题的，迭代式

     X[n+1]=g(X[n])=X[n]-f(X[n])/h(X[n])

 其中h(x)=4*x*(x-PI)/PI^2(由泰勒展开式得)

在第一次迭代过程中h(x)=h(0)=0,分母为0，这是不合法的。然而通过测试x[0]=PI/2正好与数据吻合。

六、我们的特色

   1.界面：

      我觉得我们的界面比较美观，如下

   

       提供menu菜单供选择，其中1-7为单个算法演示，8为所有    7个程序的演示，9为退出，实现了人机互动，操作方便，便于门    外汉使用。

2.健壮性

      我们的程序还有输入出错处理机制，在强调正确的同时，保证  了程序的健壮性，如：

  有出错提示。

  代码如下，通过相应输入调用相关函数

while(1)

{

tag=0;

do{

if(tag!=0)

cout<<"Your choice is illegal!Please input again!"<<endl;

tag++;

cout<<"              =============Menu============="<<endl;

cout<<"              ||  1.Bisection||                     ||"<<endl;

cout<<"              ||  2.linearinterpolation               ||"<<endl;

cout<<"              ||  3.Nowton Raphson                ||"<<endl;

cout<<"              ||  4.Secant                         ||"<<endl;

cout<<"              ||  5.Direct iteration1                 ||"<<endl;

cout<<"              ||  6.Direct iteration2                 ||"<<endl;

cout<<"              ||  7.Direct iteration3                 ||"<<endl;

cout<<"              ||  8.all of seven                     ||"<<endl;

cout<<"              ||  9.return                          ||"<<endl;

cout<<"              ==============================="<<endl;

cout<<"              Please input your choice[ ]\b\b";

cin>>choice;

cout<<endl<<endl;

}while(choice<1||choice>9);

if(1==choice||8==choice)Bisection();

if(2==choice||8==choice)linearinterpolation();

if(3==choice||8==choice)NowtonRaphson();

if(4==choice||8==choice)Secant();

if(5==choice||8==choice)Directiteration1();

if(6==choice||8==choice)Directiteration2();

if(7==choice||8==choice)Directiteration3();

if(9==choice)exit(0);

}

简洁直观。

3.变量设置

   我们将程序中经常用到的变量设为全局变量，避免过多的耗掉存储空间，同时也避免了频繁传参带来的不必要麻烦，double x0,x1,x2,x[20],e[20];当然这一切都是在避免冲突,保证正确性、健壮性的前提下完成的。

4.模块化

虽说算法比较简单，程序比较小，但我们小组还是采取了模块化编程，具体来说也就是少写复杂语句，多调用函数，一来程序看起来比较清晰（无论思路还是视觉上，也无论是对读者还是读编程者），再者有利于合作，让小组成员都参与进来，明确分工，紧密合作。如

我们的程序就尽量回避复杂语句，多调用函数，并把多次用到的输出功能单独写成print函数。

   我们的函数清单：

   double f(double x)      //计算cos(x)-0.5

void print1(int n)       //打印输出1

void print2(int n)       //打印输出2

void print3(int n)       //打印输出3

   以下7个函数就么必要一一注释了，我们的函数还有变量名是尽量做到见名知意，这也是基本的编程规范吧！

void Bisection()

void linearinterpolation()

void linearinterpolation()

void Secant()

void Directiteration1()

void Directiteration2()

void Directiteration3()

 

5.程序的高效性（低时间消耗+低空间占用）

     对于时间，由于算法固定了，就是这几个经典的，很难再有所减少了，但是编程习惯、代码风格却能在一定程度上减少空间的过度损耗，在算法中要存储每次迭代的x[n]和误差e[n],(当然可以不存储直接输出，但为了输出形式更美观我们组存储了)，我们是设了全局变量，因为7个算法的实现都得用到它。另外，我们没用递归调用函数，而是在1个函数中用循环语句实现迭代，由于算法比较简单，代码量较少，用循环语句并未降低程序的可读性，还相应的减少了递归调用带来的额外计算机资源占用。我们知道，递归的话函数调用是有开销的，而且递归的次数受堆栈大小的限制，递归太深系统可能支撑不了。

     下面是我们的一个Bisection函数，我们就是回避递归，转而用循环语句。不影响程序的可读性又有效地释放了空间，何乐而不为呢？

void Bisection()

{

cout<<"******************result of Bisection**********************"<<endl;

cout<<"初始化x1=0,x2=PI/2"<<endl;

x1=0;x2=PI/2;

int i=0;

while(1)

{

x[i]=(x1+x2)/2;

e[i]=x[i]-PI/3;

if(f(x1)*f(x[i])>0)

x1=x[i];

else if(f(x2)*f(x[i])>0)

x2=x[i];

else 

x1=x2=x[i];

i++;

if(16==i)break;

}

print1(i);

}

6.我们在写的过程中，尝试着用字符串的形式输入函数，再通过字符串的比较由计算机自动识别函数，如cos、sin等C++标准模板库中有的函数就在直接包含头文件调用，成功是实现了部分，只是在和其他小组商量了之后才统一用书上的函数，再者是有的函数在某些点处不收敛，用NowtonRaphson();Secant();Directiteration3()可能不能快速地得到解。

六、总结

  在知识层面感觉没什么好总结的，留给其他组吧。在这次以小组为单位的学习过程中，我感觉最大的收获就是大家都积极参与，无论基本功如何，我们组的每个成员都参与其中，都有事可做，并主动的做。 


#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;
#define PI 3.141592653
double x0,x1,x2,x[20];
double e[20];

double f(double x)
{
	return cos(x)-0.5;
}

void print1(int n)
{
	int j;
	cout<<"Iteration                   Error                 e[n+1]/e[n]"<<endl;
	for(j=0;j<n;j++)
		if(j<n-1)cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<setw(20)<<e[j+1]/e[j]<<endl;
		else cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<endl<<endl;
}

void print2(int n)
{
	int j;
	cout<<"Iteration                   Error                 e[n+1]/e[n]                 e[n+1]/e[n]^2"<<endl;
	for(j=0;j<n;j++)
		if(j<n-1)cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<setw(20)<<e[j+1]/e[j]<<"           "<<setw(20)<<e[j+1]/pow(e[j],2)<<endl;
		else cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<endl<<endl;
}

void print3(int n)
{
	int j;
	cout<<"Iteration                   Error                 e[n+1]/e[n]                 |e[n+1]|/|e[n]|^1.618"<<endl;
	for(j=0;j<n;j++)
		if(j<n-1)cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<setw(20)<<e[j+1]/e[j]<<"           "<<setw(20)<<fabs(e[j+1])/pow(fabs(e[j]),1.618)<<endl;
		else cout<<setw(8)<<j<<"     "<<setw(20)<<x[j]-PI/3<<"       "<<endl<<endl;

}

void Bisection()
{
	cout<<"******************result of Bisection**********************"<<endl;
	cout<<"初始化x1=0,x2=PI/2"<<endl;
	x1=0;x2=PI/2;
	int i=0;
	while(1)
	{
		x[i]=(x1+x2)/2;
		e[i]=x[i]-PI/3;
		if(f(x1)*f(x[i])>0)
			x1=x[i];
		else if(f(x2)*f(x[i])>0)
			x2=x[i];
		else 
			x1=x2=x[i];		
		i++;
		if(16==i)break;
	}
	print1(i);
}

void linearinterpolation()
{
	cout<<"*****************result of linearinterpolation******************"<<endl;
	cout<<"初始化x1=0,x2=PI/2"<<endl;
	x1=0;x2=PI/2;
	int i=0,j;
	while(1)
	{
		x[i]=(x1*f(x2)-x2*f(x1))/(f(x2)-f(x1));
		e[i]=x[i]-PI/3;
		if(f(x1)*f(x[i])>0)
			x1=x[i];
		else if(f(x2)*f(x[i])>0)
			x2=x[i];
		else 
			x1=x2=x[i];		
		i++;
		if(16==i)break;
	}
	print1(i);
}


void NowtonRaphson()
{
	int i=0;
	cout<<"**********************************result of Nowton Raphson*********************************"<<endl;
	cout<<"初始化x0=PI/2"<<endl;
	x0=PI/2;
	while(1)
	{
		x0=x0-(f(x0)/(-sin(x0)));
		x[i]=x0;
		e[i]=x0-PI/3;
		i++;
		if(5==i)break;
	}
	print2(i);
}

void Secant()
{
	cout<<"***********************result of Secant**********************"<<endl;
	cout<<"初始化x0=0,x1=PI/2"<<endl;
	x0=0;x1=PI/2;
	int i=0;
	while(1)
	{
		if(0==i%2)
		{
			x0=x1-(x1-x0)*f(x1)/(f(x1)-f(x0));
			x[i]=x0;
		}
		else 
		{
			x1=x0-(x0-x1)*f(x0)/(f(x0)-f(x1));
			x[i]=x1;
		}
		e[i]=x[i]-PI/3;	
		i++;
		if(i==7)break;
	}
	print3(i);
}




double g(double x)
{
	return x+cos(x)-0.5;
}

void Directiteration1()
{
	cout<<"*********************result of Direct iteration1****************"<<endl;
	cout<<"初始化x0=0"<<endl;
	x0=0;
	int i=0;
	x0=g(x0);
	e[i]=x0-PI/3;
	while(1)
	{
		x[i]=x0;
		x0=g(x0);
		i++;
		e[i]=x0-PI/3;
		if(i==16)break;
	}
	print1(i);
}


double g2(double x)
{
	return 2*x*cos(x);
}

void Directiteration2()
{
	cout<<"*******************result of Direct iteration2******************"<<endl;
	cout<<"初始化x0=PI/3+0.0635232"<<endl;
	x0=PI/3+0.0635232;
	int i=0;
	while(1)
	{
		x[i]=x0;
		e[i]=x0-PI/3;
		x0=g2(x0);	
		i++;
		if(i==16)break;
	}
	print1(i);
}

double h(double x)
{
	return 4*x*(x-PI)/pow(PI,2);
}
void Directiteration3()
{
	cout<<"*******************result of Direct iteration3******************"<<endl;
	cout<<"初始化x0=PI/2"<<endl;
	x0=PI/2;
	int i=0;
	while(1)
	{
		x0=x0-f(x0)/h(x0);
		e[i]=x0-PI/3;
		x[i]=x0;
		i++;		
		if(i==10)break;
	}
	print1(i);
	
}



int main()
{
	int choice;
	int tag;
	while(1)
	{
		tag=0;
		do{
			if(tag!=0)
				cout<<"Your choice is illegal!Please input again!"<<endl;
			tag++;
			cout<<"              =============Menu============="<<endl;
			cout<<"              ||  1.Bisection||            ||"<<endl;
			cout<<"              ||  2.linearinterpolation    ||"<<endl;
			cout<<"              ||  3.Nowton Raphson         ||"<<endl;
			cout<<"              ||  4.Secant                 ||"<<endl;
			cout<<"              ||  5.Direct iteration1      ||"<<endl;
			cout<<"              ||  6.Direct iteration2      ||"<<endl;
			cout<<"              ||  7.Direct iteration3      ||"<<endl;
			cout<<"              ||  8.all of seven           ||"<<endl;
			cout<<"              ||  9.return                 ||"<<endl;
			cout<<"              ==============================="<<endl;
			cout<<"              Please input your choice[ ]\b\b";
			cin>>choice;
			cout<<endl<<endl;
		}while(choice<1||choice>9);
		if(1==choice||8==choice)Bisection();
		if(2==choice||8==choice)linearinterpolation();
		if(3==choice||8==choice)NowtonRaphson();
		if(4==choice||8==choice)Secant();
		if(5==choice||8==choice)Directiteration1();
		if(6==choice||8==choice)Directiteration2();
		if(7==choice||8==choice)Directiteration3();
		if(9==choice)exit(0);
	}
	return 0;
}


以上代码是大二写的，有很多错误及不合理之处，望斧正！

晓风残月xj
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数值计算大作业：求解一元二次方程的根
01-07
数值计算大作业：求解一元二次方程的根数值计算大作业：求解一元二次方程的根数值计算大作业：求解一元二次方程的根数值计算大作业：求解一元二次方程的根数值计算大作业：求解一元二次方程的根数值计算大作业：求解...
数学体操之牛顿数值法解方程的程序和图解
tugouxp的专栏
04-16 818
牛顿法的主要优点是，它在每次迭代中都收敛在的非常快，在实践中被证明比其他迭代方法更快，但是它也有缺点:1,就像例子中看到的，当函数具有多个局部零点时，算法的初始值可能导致收敛到错误的根。2.算法需要有解析式表达的导数计算方法。3.可能会发生根跳转，得不到预期的结果。4.在局部极值附近可能会发生振荡导致收敛变慢，无法跳脱。5.拐点可能导致算法实效。解方程是一种近似数学，虽然有的时候能够获得方程的解析式，但大多数的时候（5次及以上的普通方程）是没有解析式的，这个时候只能通过数值解法得到近似解。
C语言--三次方程数值求解
qq_37067580的博客
10-27 3952
三次方程计算器 一元三次方程的解析解法早在500年前就已经被意大利数学家攻克了： 我们可以看到，相比于二次方程，三次方程求根公式表达式要复杂的多，包含了一个二重根号，计算量庞大，而且大多数情况下会出现一对复数解，C语言不太好操作；在判别式小于0时，即使三个解都是实数，我们仍然需要对一个复数开立方，这样的一个公式显然是不适合人工计算和计算器编程的。 由于三次方程至少有一个实根，因此我们可以通过常规的数值方法找出这个实数解。本程序先用二分法估算方程零点的大致位置，再通过牛顿迭代法获得最大实数根的数值解，最后通
数值计算（迭代法解方程组）
cbf的博客
11-25 3452
1.主要思想： AX=bAX=b 经过一定的变换成X=BX+fX=BX+f，然后从初始向量出发，计算Xk+1=BXk+fX^{k+1}=BX^{k}+f，经过一定的次数后得到Xk+1X^{k+1}会收敛于真正的值。问题来了？如何得到X=BX+f这种形式？如何证明收敛？接下来的几个算法都是围绕这个问题。 2.雅可比迭代法
matlab方程和数值计算
bigdataZLB的博客
06-13 1839
1.sym2poly(s) 返回一个包含符号多项式的数值系数的行向量。系数是按照多项式中独立变量幂值的降序来排列的。换句话说，向量c首先包含多项式最高项的系数，然后是次高项系数，以此类推。 syms x sym2poly(x^3 - 2*x - 5) 返回： ans = 1 0 -2 -5 2.poly2sym( c ) 按降幂排列的多项式系数向量转化为符号多项式 返回一个符号多项式，多项式系数在数值向量c中。默认的符号变量是x。变量v可以被指定作为第二个输入参数。 3.y = polyval(p,x)
微分方程数值解法的matlab程序
py753159123456的博客
09-24 1485
微分方程数值解法的matlab程序 欧拉法 clear clc syms x y f=2*x; a=0; b=10; y0=0; h=0.1; n=(b-a)/h+1; xx=zeros(n,1); yy=zeros(n,1); for i=1:n xx(i)=a+h*(i-1); end yy=zeros(n,1); yy(1)=y0; for i=2:n yy(i)=yy(i-1)+h*subs(f,{x,y},{xx(i-1),yy(i-1)}); end ff1=[xx,yy];
matlab_雷诺方程_有限差分法_数值计算_
10-01
在数值计算领域，雷诺方程（Reynolds equations）是一种描述流体动力学中惯性力和粘性力之间关系的重要方程。本主题主要关注如何使用MATLAB编程实现雷诺方程的有限差分法求解。有限差分法是数值分析中的基本方法，...
非线性方程求根 二分法 牛顿法 数值计算 计算方法作业
12-15
二分法和牛顿法是两种常用的非线性方程求解算法，它们各有特点，适用于不同的情况。 首先，我们来看二分法。二分法（也称为折半查找法）是一种简单而有效的数值求解方法，适用于函数在其定义域内连续且单峰的情况。...
python计算方程式根的方法
09-22
对于某些特定类型的多项式，可能存在更高效的求根算法。此外，也可以考虑使用并行化技术来加速计算过程。 - **应用场景** 多项式根的求解在科学计算、工程设计、数据分析等多个领域都有广泛的应用。例如，在控制...
MATLAB实现偏微分方程求解【数学建模、科学计算算法】
04-14
“MATLAB实现偏微分方程求解【数学建模、科学计算算法】”可能是具体的代码示例或教程，可以帮助读者深入理解如何在实际问题中运用MATLAB的PDE Toolbox。 总的来说，掌握MATLAB在偏微分方程求解中的应用，不仅可以...
数值计算之割线法方程求根
11-09
数值计算之割线法方程求根，调试运行成功，供大家使用。
数值计算，插值，解方程(C语言实现)
03-23
NULL 博文链接：https://touch-2011.iteye.com/blog/1038942
数值分析每章编程题（matlab实现）
10-08
主要包含数值分析第二章至第七章课后编程实践。全部采用matlab实现，内附详细代码及注释，即可作为作业资料，也可作为matlab编程练习，同时包含丰富的图像，以便观察理解。
数值计算方法-线性方程组求解
weixin_46837674的博客
01-23 1600
要求： ①编写一个function，求解AX=b，即输入为A，b，但A只能是上三角或下三角矩阵。 ②编写一个function，求解AX=b，利用高斯消去法（包括选主元和不选主元），调用①function求解X。 ③编写一个function，对矩阵A进行doolittle分解，输出单位下三角矩阵L和上三角矩阵U；若选主元，同时输出置换矩阵P。 ④编写一个function对正定矩阵A进行cholesky分解，输出下三角矩阵L； 理论： ①求解线性方程组一般的求解方法有俩种，一个是直接求解法，一个是迭代法。 ②直
几种求解线性方程组的算法
qq_53019168的博客
06-24 1191
本文简要介绍了高斯消元法、jacobi迭代法、gauss_seidel迭代法以及SOR迭代法
数值方法求解微分方程
Sunsky0504的博客
03-11 5178
文章目录前言一、欧拉法1.一阶微分方程2.二阶微分方程相空间总结：未完待续！ 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 一、欧拉法 欧拉法：是一种微分方程的数值计算方法，其基本思想是迭代。所谓迭代，就是逐次替代，最后求出所要求的解，并达到一定的精度。误差可以很容易地计算出来。下面分别介绍欧拉法求解一阶微分方程，二阶微分方程的matlab程序实现。 1.一阶微分方程 {dy(t)d
方程根求解数值方法matlab实现二分法、牛顿法、斜截法，代码程序，手写思路，理论分析，最基本的操作
weixin_48700185的博客
11-27 7508
方程根求解数值方法matlab实现二分法、牛顿法、斜截法 方程根求解数值方法matlab实现二分法、牛顿法、斜截法，代码程序，手写思路，理论分析，最基本的操作 实验内容： 理论手写思路 实验代码程序 1、二分法： 主函数： clear; clc; syms U L; %将区间上下限定为变量 f=@(x)x^3-3*x-1; %求给定的函数，可以直接在本行中修改后面代码为其他函数 U=3('输入求根区域上限upper,U='); L=1('输入求根区域下限lower,L='); whil
偏微分方程数值解程序设计与实现——数学基础
weixin_44783002的博客
08-12 1801
常用算子符号 梯度算子 Rd\mathbb{R}^dRd空间中标量函数u(x)u(\bf{x})u(x)，其梯度算子定义如下： gradu(x)=∇u(x)=[∂u∂x0∂u∂x1⋮∂u∂xd−1] grad u(\mathbf{x})=\nabla u(\mathbf{x})= \begin{bmatrix} \frac{\partial u}{\partial x_0} \\ \frac{\partial u}{\partial x_1} \\ \vdots \\ \frac{\partial u}{
数值计算—方程求根（C语言+二分法、牛顿法）
weixin_43894690的博客
06-07 4190
求解方程：x3-0.2x2-0.2x-1.2=0的根 编写二分法、牛顿法程序，分析运行结果。 思想： 二分法 给定区间，并设f(a)与f(b)符号相反，取Ɛ1为根的允许误差，Ɛ2为｜f(x)｜的允许误差。 1）c=（a+b）/ 2； 2）如果（c-a）< Ɛ1或｜f( c )｜< Ɛ2，则输出 c，结束；否则执行3）； 3）如果 f( a )·f( b ) > 0，则令 a=c，否则令 b=c，重复以上步骤。 牛顿迭代法 给定初值x0，取Ɛ1为根的允许误差，Ɛ2为｜f(x)｜的允许误差，N
数值计算方程求根 python 二分法 牛顿法
最新发布
12-16
在Python编程语言中，可以利用二分法和牛顿法来进行数值计算方程的求根。 首先，使用二分法求解方程的根。二分法是一种迭代的方法，通过不断地缩小区间范围来逼近方程的根。我们首先定义一个初始的区间范围，然后...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值