数值计算-

已于 2024-04-29 13:41:06 修改
阅读量557 收藏 11
点赞数 24
文章标签： c++ 算法
于 2024-04-29 13:40:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/et0304/article/details/137569693
版权

18957 计算自然对数ln(x)的导数

求自然对数ln(x)的导数，输入双精度实数x>=1，输出自然对数ln(x)的导数（精确到小数点后2位有效数，小数点后第2位四舍五入所得）。

输入格式

m(整数，实验数据总数)
x1(实数，自然对数ln(x)的自变量)
X2实数，自然对数ln(x)的自变量)
...
xm(实数，自然对数ln(x)的自变量)

输出格式

y1(实数，自然对数ln(x1)的导数)
y2实数，自然对数ln(x2)的导数)
...
ym(实数，自然对数ln(xm)的导数)

输入样例

3
1.0
2.0
3.0

输出样例

1.00
0.50
0.33


#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
using namespace std;
double ln(int x){
    double h=0.32;
    for(int i=0;i<20;i++){
        h/=2.0;
    }
    return log((x+h)/x)/h;

}
int main()
{
    int m;
    scanf("%d",&m);
    double x[100];
    for(int i=0;i<m;i++){
        scanf("%lf",&x[i]);
    }
    for(int i=0;i<m;i++){
        printf("%.2f\n",ln(x[i]));
    }
    return 0;
}

18991 实验1.2 调和级数求和

求调和级数前k项之和（1+1/2+1/3+...+1/k），输入整数k>0，输出两种调和级数前k项和，
前一种是从左到右求和；后一种是从右到左求和（使用双精度double类型精确到小数点后14位）。

输入格式

实验输入数据格式
m(整数，实验数据总数)
k1(整数，调和级数项数)
k2(整数，调和级数项数)
...
km(整数，调和级数项数)

输出格式

实验输出数据格式
x1(实数，k1项调和级数从左到右求和)  y1(实数，k1项调和级数从右到左求和) 
x2(实数，k2项调和级数从左到右求和)  y2(实数，k2项调和级数从右到左求和)
...
xm(实数，km项调和级数从左到右求和)  ym(实数，km项调和级数从右到左求和)

输入样例

3
10
100
1000

输出样例

2.92896825396825 2.92896825396825
5.18737751763962 5.18737751763962
7.48547086055034 7.48547086055034
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
using namespace std;
double sumHSDL(int h){
    double sum=0;
    for(int i=1;i<=h;i++){
        sum+=1.0/i;
    }
    return sum;
}
double sumHSDR(int h){
    double sum=0;
    for(int i=h;i>=1;i--){
        sum+=1.0/i;
    }
    return sum;
}

int main()
{
   int m;
   cin>>m;
   vector<int> k;
    int a;
   for(int i=0;i<m;i++){
    cin>>a;
    k.push_back(a);
   }
   for(int i=0;i<m;i++){
        printf("%.14f ",sumHSDL(k[i]));
        printf("%.14f\n",sumHSDR(k[i]));
   }
   return 0;

}

18996 求正弦函数值

求正弦函数值，输入实数x(弧度，0到π) ，输出x对应的正弦函数值（使用双精度double类型精确到小数点后14位有效数）。

输入格式

m(整数，实验数据总数)
x1(弧度，0到π)
x2(弧度，0到π)
...
xm(弧度，0到π)

输出格式

实验输出数据格式
y1(实数，x1的正弦函数值)  
y2(实数，x2的正弦函数值)
...
ym(实数，xm的正弦函数值)

输入样例

3
0.0
0.5
1.0

输出样例

0.00000000000000
0.47942553860420
0.84147098480790
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
using namespace std;
#define PI 3.1415926535897932l
int GetSinItemNumber(double x)
{ int N;
  if(x<0)x=-x;
       if(x<=PI/8)    N=6;
  else if(x<=PI/4)    N=8;
  else if(x<=PI/2)    N=10;
  else if(x<=3*PI/4)  N=12;
  else                N=14;
  return N;
}
double SINTV(double x)
{ int K,N;
  double y=1.0,xx=0.0,temp;
  N=GetSinItemNumber(x);
  K=N*2;
  xx=x*x;
  while(K>0)
  { y=1.0-y*xx/K/(K+1);
    K-=2;
  }
  return y*x;
}

int main()
{
    int m;
    scanf("%d",&m);
    double x[100];
    for(int i=0;i<m;i++){
        scanf("%lf",&x[i]);
    }
    for(int i=0;i<m;i++){
        printf("%.14lf\n",SINTV(x[i]));
    }
    return 0;
}

18997 求余弦函数值

求余弦函数值，输入实数x(弧度，0到π) ，输出x对应的余弦函数值（使用双精度double类型精确到小数点后14位有效数）。

输入格式

实验输入数据格式
m(整数，实验数据总数)
x1(弧度，0到π)
x2(弧度，0到π)
...
xm(弧度，0到π)

输出格式

实验输出数据格式
y1(实数，x1的余弦函数值)  
y2(实数，x2的余弦函数值)
...
ym(实数，x2的余弦函数值)

输入样例

3
0.0
0.5
1.0

输出样例

1.00000000000000
0.87758256189037
0.54030230586814
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
using namespace std;
#define PI 3.1415926535897932l
int GetSinItemNumber(double x)
{ int N;
  if(x<0)x=-x;
       if(x<=PI/8)    N=6;
  else if(x<=PI/4)    N=8;
  else if(x<=PI/2)    N=10;
  else if(x<=3*PI/4)  N=12;
  else                N=14;
  return N;
}
double COSTV(double x)
{ int K,N;
  double y=1.0,xx;
  N=GetSinItemNumber(x)+1;
  K=N*2;
  xx=x*x;
  while(K>0)
  { y=1.0-y*xx/K/(K-1);
    K-=2;
  }
  return y;
}


int main()
{
    int m;
    scanf("%d",&m);
    double x[100];
    for(int i=0;i<m;i++){
        scanf("%lf",&x[i]);
    }
    for(int i=0;i<m;i++){
        printf("%.14lf\n",COSTV(x[i]));
    }
    return 0;
}

18998 求对数函数值ln(x)

求对数函数值，输入实数x>0 ，输出x对应的对数函数值ln(x)（使用双精度double类型精确到小数点后14位有效数）。
格式
实验输入数据格式
m(整数，实验数据总数)
x1(实数>0)
x2(实数>0)
...
xm(实数>0)

输出格式
实验输出数据格式
y1(实数，x1的对数函数值)  
y2(实数，x2的对数函数值)
...
ym(实数，xm的对数函数值)

输入样例

3
1.5
3.5
8.5

输出样例

0.40546510810816
1.25276296849537
2.14006616349627
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#define MATHLOG 1
#define LOGTWO   0.69314718055994531
#define LOGTEN   2.3025850929940457
#ifndef ZERO
  #define ZERO 0.5E-100
#endif
using namespace std;
int GetLogItemNumber(double a)
{ int N;
       if(a<=1)   N=-1;
  else if(a<=1.2) N=7;
  else if(a<=1.5) N=10;
  else if(a<=2.0) N=15;
  else if(a<=3.0) N=24;
  else if(a<=10)  N=84;
  else  N=84*(int)(a/10);
  return N;
}
double LOGTV(double a)
{ int N=0,K,NK;
  double x,xx,y;
  x=(a-1)/(a+1);
  xx=x*x;
  N=GetLogItemNumber(a);
  NK=N*2+1;
  y=1.0/NK;
  for(K=N;K>0;K--)
  { NK-=2;
    y =1.0/NK+xx*y;
  }
  return 2.0*x*y;
}
double LOG(double a)
{ int TYPE=0,K=0;
  double x0,x,y,power=2.0;
  x=a;
   if(x<ZERO) return -100;
   if(x<1){x=1.0/x,TYPE=1;}
   while(power<x){ power*=2.0;K++;}
   y=LOGTV(2.0*x/power)+K*LOGTWO;
   if(TYPE==1)y=-y;
   return y;
}

int main()
{
    int m;
    scanf("%d",&m);
    double x[100];
    for(int i=0;i<m;i++){
        scanf("%lf",&x[i]);
    }
    for(int i=0;i<m;i++){
        printf("%.14lf\n",LOG(x[i]));
    }
    return 0;
}

18999 求指数函数值

求指数函数值，输入实数x ，输出x对应的指数函数值exp(x)
（使用双精度double类型精确到小数点后14位有效数）。

输入格式

实验输入数据格式
m(整数，实验数据总数)
x1(实数)
x2(实数)
...
xm(实数)

输出格式

实验输出数据格式
y1(实数，x1的指数函数值)  
y2(实数，x2的指数函数值)
...
ym(实数，xm的指数函数值)

输入样例

3
-1.0
0
1.5

输出样例

0.36787944117144
1.00000000000000
4.48168907033806
#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#define MATHEXP 1

#define EPOW01  2.7182818284590452
#define EPOW02  7.3890560989306502
#define EPOW10  22026.465794806717

double EXPTV(double x)
{ int N=23;
  int K=0;
  double y=1.0;
  if(x<=0.5) N=14; /*See Ch3 Table 7.1*/
  else if(x<=1.0) N=18;
  else            N=23;
  for(K=N;K>0;K--)
    y=1.0+y*x/K;
  return y;
}

double EXP(double x)
{ int TYPE=0;
  double y0=1.0;
  if(x<0){TYPE=1;x=-x;}
  while(1)
  {      if(x>10) {x-=10;y0*=EPOW10;}
    else if(x>2)  {x-=2; y0*=EXPTV(2);}
    else          break;
  }
  y0 *=EXPTV(x);
  if(TYPE==1) return 1.0/y0;
  else        return y0;
}

int main()
{
    int m;
    scanf("%d",&m);
    double x[100];
    for(int i=0;i<m;i++){
        scanf("%lf",&x[i]);
    }
    for(int i=0;i<m;i++){
        printf("%.14lf\n",EXP(x[i]));
    }
    return 0;
}

19000 二分法解非线性方程

二分法解非线性方程：给定非线性方程(x*x*x-2.0*x-2=0)，输入区间起点实数A和终点实数B ，
输出满足最大误差（EPS=0.4E-14）时，最后的区间起点，区间终点，非线性方程根的近似值
（使用双精度double类型精确到小数点后15位有效数）。

输入格式

m(整数，实验数据总数)
A1 B1(实数，区间起点与终点)
A2 B2(实数，区间起点与终点)
...
Am Bm(实数，区间起点与终点)

输出格式

A B X(输出满足最大误差（EPS=0.4E-14）时，最后的区间起点，区间终点，非线性方程根的近似值)
  
A B X(输出满足最大误差（EPS=0.4E-14）时，最后的区间起点，区间终点，非线性方程根的近似值)
...
A B X(输出满足最大误差（EPS=0.4E-14）时，最后的区间起点，区间终点，非线性方程根的近似值)

输入样例

3
1.0 2.0
0.0 2.5
1.5 3.0
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define  MN 51
int      RN=1;
double   ANS,ERR,EPS=0.4E-14;
double   A[MN],B[MN],X[MN],Y[MN],E[MN];
double f(double x){return x*x*x-2.0*x-2;}
// double   A0=0.0,B0=2.5;
double   A0,B0;

 int BISECTION(double A0,double B0)
{ double FA;
  int K;
  FA=f(A0);
  A[0]=A0;
  B[0]=B0;
  X[0]=(A0+B0)/2.0;
  Y[0]=f(X[0]);
  E[0]=(B0-A0)/2;
  for(K=1;K<MN;K++)
  { if(Y[K-1]*FA>0) {A[K]=X[K-1];B[K]=B[K-1];}
     else           {A[K]=A[K-1];B[K]=X[K-1];}
     X[K]=(A[K]+B[K])/2.0;
     Y[K]=f(X[K]);
     E[K]=(B[K]-A[K])/2;
     if(E[K]<EPS) break;
  }
  int k;
  if(K<MN)K++;
  RN=K;
  ANS=X[RN-1];
  ERR=E[RN-1];
  for(k=0;k<RN;k++)
  {  
      if(k==RN-1)
      printf("%.15f %.15f %.15f\n",A[k],B[k],X[k]);

 }
  return 0;
}
int main()
{ 
     int m = 1;
    scanf("%d", &m);
    double x[m], y[m];
    for (int i = 0; i < m; i++) {
   
        scanf("%lf %lf", &x[i],&y[i]);
    }
    for (int i = 0; i < m; i++) {
   
         BISECTION(x[i],y[i]);
    }

}

19001 黄金分割求函数最小值

黄金分割求函数最小值（GOLDEN=0.6180339887498948l）：
给定非线性方程(exp(x)-2*x*x)，输入区间起点实数A和终点实数B ，输出满足最大误差（EPS=0.4E-8）时，
最后的区间起点，黄金分割近点，黄金分割远点，区间终点，近点对应函数值，远点对应函数值
（使用双精度double类型精确到小数点后9位有效数）。

输入格式
m(整数，实验数据总数)
A1 B1(实数，区间起点与终点)
A2 B2(实数，区间起点与终点)
...
Am Bm(实数，区间起点与终点)

输出格式

A X1 X2 B Y1 Y2(输出满足最大误差（EPS=0.4E-8）时，
的区间起点，黄金分割近点，黄金分割远点，区间终点，近点对应函数值，远点对应函数值)
  
A X1 X2 B Y1 Y2(输出满足最大误差（EPS=0.4E-8）时，
最后的区间起点，黄金分割近点，黄金分割远点，区间终点，近点对应函数值，远点对应函数值)
...
A X1 X2 B Y1 Y2(输出满足最大误差（EPS=0.4E-8）时，
最后的区间起点，黄金分割近点，黄金分割远点，区间终点，近点对应函数值，远点对应函数值)

输入样例

3
1.5 3.5 
1.4 3.7 
1.3 3.9

输出样例

2.153292379 2.153292382 2.153292385 2.153292388 -0.660166554 -0.660166554
2.153292366 2.153292370 2.153292372 2.153292376 -0.660166554 -0.660166554
2.153292391 2.153292394 2.153292395 2.153292398 -0.660166554 -0.660166554
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define  MN   51
int      RN=1;
double  OPTX,OPTY,ERR;
double  GOLDEN=0.6180339887498948l;
double  A[MN],B[MN],AX[MN],BX[MN];
double  X1[MN],X2[MN],Y1[MN],Y2[MN];

/*  Exam 3.1 */
double  EPS=0.4E-8;
double f(double x){return exp(x)-2*x*x;}
int GoldenSection(double A0,double B0)
{ 
    int K;
  A[0]=A0;
  B[0]=B0;
  BX[0]=(B[0]-A[0])*GOLDEN;
  AX[0]=BX[0]*GOLDEN;
  X2[0]=A[0]+BX[0];
  Y2[0]=f(X2[0]);
  X1[0]=A[0]+AX[0];
  Y1[0]=f(X1[0]);
  for(K=1;K<MN;K++)
  { BX[K]=AX[K-1];
    AX[K]=BX[K]*GOLDEN;
    if(Y1[K-1]<Y2[K-1])
      { A[K]=A[K-1];B[K]=X2[K-1];
	X2[K]=X1[K-1];
	Y2[K]=Y1[K-1];
	X1[K]=A[K]+AX[K];
	Y1[K]=f(X1[K]);
      }
    else
      { A[K]=X1[K-1];B[K]=B[K-1];
	X1[K]=X2[K-1];
	Y1[K]=Y2[K-1];
	X2[K]=A[K]+BX[K];
	Y2[K]=f(X2[K]);
      }
   if(AX[K]<EPS) break;
  }
  if(K<MN)K++;
  RN=K;
  ERR=AX[RN-1];
  if(Y1[RN-1]<Y2[RN-1])
	 { OPTX=X1[RN-1];OPTY=Y1[RN-1];}
  else   { OPTX=X2[RN-1];OPTY=Y2[RN-1];}
    for(K=0;K<RN;K++)
  {  
      if(K==RN-1)
      printf("%.9f %.9f %.9f %.9f %.9f %.9f\n",A[K],X1[K],X2[K],B[K],Y1[K],Y2[K]);
    //   printf("%.9f %.9f %.9f\n",Y1[K],Y2[K],AX[K]);
 }
//   printf("%.9f %.9f %.9f\n\n",OPTX,OPTY,ERR);
  return 0;
}

int main()
{ 
     int m = 1;
    scanf("%d", &m);
    double x[m], y[m];
    for (int i = 0; i < m; i++) {
   
        scanf("%lf %lf", &x[i],&y[i]);
    }
    for (int i = 0; i < m; i++) {
   
         GoldenSection(x[i],y[i]);
    }

}

19020 选列主元约当消元法求线性方程组唯一解

选列主元约当消元法求线性方程组唯一解：
输入4*5的线性方程组的满秩增广矩阵，
输出方程组的解（使用双精度double类型精确到小数点后9位有效数）。

输入格式

m(整数，实验数据总数)
a11 a12 a13 a14 a15(实数，第1个增广矩阵的第1行5个数据)
a21 a22 a23 a24 a25(实数，第1个增广矩阵的第2行5个数据)
a31 a32 a33 a34 a35(实数，第1个增广矩阵的第3行5个数据)
a41 a42 a43 a44 a45(实数，第1个增广矩阵的第4行5个数据)
...

输出格式

 x1 x2 x3 x4(输出第1个方程组的解，精确到小数点后9位有效数)
 x1 x2 x3 x4(输出第2个方程组的解，精确到小数点后9位有效数)
...
 x1 x2 x3 x4(输出第m个方程组的解，精确到小数点后9位有效数)

输入样例

2
5.96912 -2.83547 -9.63744 8.13715 -0.46236
-9.31394 -7.37968 -3.62896 -0.62227 8.82260
-8.62545 2.22327 -9.32371 2.77932 2.70363
-1.63610 2.69204 -7.04398 -9.11191 5.51378
-9.97497 1.27171 -6.13392 6.17481 1.70019
-0.40254 -2.99417 7.91925 6.45680 4.93210
-6.51784 7.17887 4.21003 0.27070 -3.92010
-9.70031 -8.17194 -2.71096 -7.05374 -6.68203

输出样例

-0.270161097 -0.646876229 -0.339053371 -0.485617280
0.333728832 -0.224830010 -0.081245121 0.780055190

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
double b[4][5];
 
void getm(int k)//选取最大主列
{
    double temp;
    for(int i=k+1; i<4; i++)
    {
        if(fabs(b[k][k])<fabs(b[i][k]))
        {
            for(int a=k; a<5; a++)
            {
                temp = b[k][a];
                b[k][a] = b[i][a];
                b[i][a] = temp;
            }
        }
    }
  return ;
}
 
 
void Uppertriangle()//化上三角就是把对角线下面变成0
{
    double x;
    for(int i=0; i<3; i++)
    {
        getm(i);
        x = b[i][i];
        for(int a=i; a<5; a++)
        {
 
            b[i][a] = b[i][a]/x;//化1
        }
        for(int j=i+1; j<4; j++)
        {
            x = b[j][i];
            for(int a=i; a<5; a++)
            {
                b[j][a] = b[j][a]-b[i][a]*x;//化0
            }
 
        }
    }
}
 
void Lowertriangle()//化下三角就是把对角线上面变成0
{
    double x;
    for(int i=3; i>0; i--)
    {
        x = b[i][i];
        for(int a=i; a<5; a++)
        {
            b[i][a] = b[i][a]/x;//把对角线上值系数变成1
        }
        for(int j=i-1; j>=0; j--)
        {
            x = b[j][i];
            for(int a=j; a<5; a++)
            {
                b[j][a] = b[j][a]-b[i][a]*x;//在上三角基础上把第i列的第i项之外其他变成0
            }
        }
    }
}
 
 
int main()
{
    int n;
    scanf("%d",&n);
    while(n>0)
    {
        for(int i=0; i<4; i++)
        {
            for(int j=0; j<5; j++)
            {
                scanf("%lf",&b[i][j]);
            }
        }
        Uppertriangle();
        Lowertriangle();
printf("%0.9lf %0.9lf %0.9lf %0.9lf \n",
       b[0][4],b[1][4],b[2][4],b[3][4]);
        n--;
    }
    return 0;
}

et0304
关注
  • 24
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
matlab数值计算习题解析,第3章MATLAB数值计算-习题
weixin_33188115的博客
04-15 2087
《第3章MATLAB数值计算-习题》由会员分享，可在线阅读，更多相关《第3章MATLAB数值计算-习题(4页珍藏版)》请在人人文库网上搜索。1、1. 用函数roots求方程x2-x-1=0的根roots(1 -1 -1)2. y=sinx, 0x2，在n个节点(n不要太大，如取511)上用分段线性、三次方、样条插值方法，计算m个插值点(m可取50100)的函数值。(注，n取10，m取100)x=l...
[数值计算-1]：数学建模、科学计算、数值计算的关系
文火冰糖（王文兵）的博客
08-18 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 前言：数学建模与数值计算的意义 数学建模与数值计是利用数学来解决实际理论和工程问题必须的两种工具。 深度学习算法和传统的机器学习算法，本质是就是数学建模与数值计算在人工智能领域的应用，数学建模与数值计算能够为理解深度学习的算法提供理论的基础和思维模型的框架。理解深度学习过程与算法原理背后更加通用的力量模型。 https://blog.csdn.net/HiWangWenBing/
c语言计算级数,C语言之数值计算--级数算法
weixin_39861823的博客
05-20 3350
在编程语言的学习中，我们学习过不少的算法，比如累加，累乘，数值交换，排序等等。在一些软件比赛和面试题中，有一类算法不容忽视，属于高频题目，我之前去企业面试的时候就遇到这样的一类题目，题目不算难，掌握方法，很快可以做出来。这类算法叫做----级数算法。 级数计算的关键是“描述出通项”，而通项的描述法有两种：一为直接法、二为间接法又称递推法。直接法的要领是：利用项次直接写出通项式；递推法的要领是：利用...
[数值计算-2]：数值计算算法好坏的判断标准
文火冰糖（王文兵）的博客
08-18 1万+
数值计算的误差与误差分析
[数值计算-19]：万能的任意函数的数值求导数方法
文火冰糖（王文兵）的博客
09-19 3188
作者主页(文火冰糖的硅基工坊)：文火冰糖（王文兵）的博客_文火冰糖的硅基工坊_CSDN博客 本文网址： 目录 第1章 前言 第2章 导数的数值定义 第3章 导数的数值计算 3.1 定义支持任意一元函数的求导的函数 3.2案例1：一元函数1 3.3案例2：一元函数2 3.3 多元函数求偏导 第1章 前言 张量运算的前向运算与参数的自动反向求导都是深度学习最核心的基础。 前向运算其实直观，因为有前向运算的函数，一次带入函数的参数，就可以获得前向运算的数值。 如 loss =(f(x..
Matlab 数值计算----牛顿迭代法
热门推荐
汉南最後の読書人
04-09 5万+
Newton.m函数 function [x_star,index,it] = Newton(fun,x,ep,it_max) %求解非线性方程的牛顿法 %第一个分量是函数值，第二个分量是导数值 % x为初始点 % ep为精度,当 | x(k)-x(k-1) |<ep时，终止计算,缺省值为1e-5 % it_max为最大迭代次数,缺省值为100 % x_star为当迭代成功时，输出方程的根 %
[数值计算-9]：一元非线性函数求导数（数值微分）- 解析法与迭代法&Python法代码示例
文火冰糖（王文兵）的博客
08-20 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址：https://blog.csdn.net/HiWangWenBing/article/details/119813740 目录 1.一元n次非线性方程 1.1非线性函数 1.2 非线性函数案例 1.3 非线性函数的几何图形 2. 导数与解析法求导数 2.1 导数的源头和初心 2.2什么导数 2.3导函数 2.4 解析法求导数 3. 迭代法求导数的基本原理 ...
数值计算--欧拉法--RK法
--- 自由在高处
04-24 3476
今天上午主要学习了数值分析里面的微分方程求解法则，并且用matlab进行仿真，我感觉最近一直在用matlab，好久没在呢么用C了，听想念的。 不多说，今天主要学习了欧拉角法和龙格库塔法，上图，都是干货； 感觉不是很难，主要用的是中值定理，遗憾的是没看到怎么在惯导里面使用，会有机会的；
Matlab 数值计算----斯特芬森加速迭代法
汉南最後の読書人
04-09 9701
steffensen.m函数 function[x_star,index,it]=steffensen(phi,x,ep,it_max) %斯特芬森加速迭代方法 % x为初始点 % ep为精度，当| x(k)-x(k-1) |<ep时，终止计算，缺省值为1e-5 % it_max为最大迭代次数 % x_star为当迭代成功时，输出方程的根 % 当迭代失败时，输出最后的迭代值; % index
[数值计算-10]：一元非线性函数求最小值 - 导数与梯度下降法&Python法代码示例
文火冰糖（王文兵）的博客
08-22 1万+
作者主页(文火冰糖的硅基工坊)：https://blog.csdn.net/HiWangWenBing 本文网址： 目录 第1章 一元非线性函数 1.1 什么是函数的元 1.2什么是非线性函数 1.3非线性函数案例 1.4非线性函数的几何图形示意图 第2章 函数的导数 2.1什么是函数的导数 2.2 导数的几何意义 2.3导函数 2.4函数的凹凸性：什么是凸函数和凹函数? 第3章 极大与最值 3.1 什么是函数的最小值、极小值? 3.2 求极值的重要意义 3.3...
常用数值算法--C语言 (2)_常用数值计算-c语言_
10-04
数学建模中常用的数值算法，适合新手使用，需要的可以使用
MATLAB数值计算-教程与笔记习题
05-19
MATLAB数值计算的指导
数值计算-最小二乘问题
06-05
最小二乘问题 最小二乘法与数据拟合 列满秩与秩亏损 加权最小二乘问题 正则化 等式约束最小二乘问题
BAT批处理脚本-数值计算-23个.zip
01-15
BAT批处理脚本-数值计算-23个 BAT批处理脚本-文件相关操作-92个 BAT批处理脚本-文本操作-52个 BAT批处理脚本-格式转换-9个 BAT批处理脚本-清理-清除-垃圾-28个 BAT批处理脚本-系统设置查询修改-硬件相关-139个 BAT...
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 107
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C++ shared_ptr
qq_40135848的博客
06-15 1534
C++ shared_ptr
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1173
Deque（双端队列）是C++ STL中的一种序列容器
C的I/O操作
最新发布
weidl001的博客
06-17 727
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
建造者模式(大话设计模式)C/C++版本
m0_47104421的博客
06-15 269
创建者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式；使得建造代码与表示代码分离，隐藏了该产品是如何组装的，多疑若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值