检查我的程序计算应该是什么。

1视图(30天)

显示旧的评论

罗德里戈·佩纳 2020年12月1日

0
链接

这个问题直接联系

//www.tatmou.com/matlabcentral/answers/671823-checking-if-my-program-calculates-what-is-supposed-to

评论道: 马修•诺伊 2020年12月11日

答:接受马修•诺伊

你好,你好吗?

我试图编写一个程序,计算aeroelasticiy东西。我不知道程序是计算应该是什么。

这个计划是:

1 -猜k的值在0和1之间

2 -计算Ck

3 -计算到

4 - f12计算

5 -计算f21

6 -计算——f22

7 -计算多项式的根(p)

8 -选择一个多项式的根的p(例如让´s说第一个)

9 - k等于新值的多项式的根的实部p(第一根)

10 -返回到步骤2 k计算一切,直到收敛。

> > %输入

= -1/5;

μ= 2;% 2≤µ≤20

rs = 1/4;

σ= 1 /√(10);

xtheta = 0;% xtheta = 0.0和0.2

V = 0.05;

%方程,根据向量矩阵

k = 0:0.01:1;

r1 = 0 (1101);

r2 = 0 (1101);

r3 = 0 (1101);

r4 = 0 (1101);

j = 2: 101;

k (j);

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p);

r1 (j) = rts (1);

r2 (j) = rts (2);

r3 (j) = rts (3);

r4 (j) = rts (4);

k =图像放大(r1)

γ=实际(r1)。/ k;

结束

情节(k,γ);

抓住;

ylabel(γ);

包含(“k”);

推迟;

这是正确的吗?

0评论
显示1年长的评论藏1年长的评论

登录置评。

在回答这个问题。

接受的答案

马修•诺伊 2020年12月2日

0
链接

直接链接到这个答案

//www.tatmou.com/matlabcentral/answers/671823-checking-if-my-program-calculates-what-is-supposed-to answer_563233

你好

是的你的代码需要一些修正

至少我相信我有固定循环递归问题

现在还有其他的问题,例如

你说:9 - k等于新值的多项式的根的实部p(第一根)

在您的代码你iamginary部分,不是真正的一部分

如果我用真正的k往往不管初始值收敛到零

如果我和图像放大,k跳两个值之间

我认为这些行为是好的

                             % > > %输入
                            
                             = -1/5;
                            
                             μ= 2;% 2≤µ≤20
                            
                             rs = 1/4;
                            
                             σ= 1 /√(10);
                            
                             xtheta = 0;% xtheta = 0.0和0.2
                            
                             V = 0.05;
                            
                             %方程,根据向量矩阵
                            
                             k = 0.75;
                            
                             k_visu (1) = k;
                            
                             n = 10;% nb的循环
                            
                             % r1 = 0 (1, n);
                            
                             % r2 = 0 (1, n);
                            
                             % r3 = 0 (1, n);
                            
                             % r4 = 0 (1, n);
                            
                             为j = 2: n;
                            
                             Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                            
                             季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                            
                             f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                            
                             f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                            
                             ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                            
                             p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                            
                             rts =根(p);
                            
                             % r1 (j) = rts (1);
                            
                             % r2 (j) = rts (2);
                            
                             % r3 (j) = rts (3);
                            
                             % r4 (j) = rts (4);
                            
                             k =实际(rts (1));
                            
                             k_visu (j) = k;
                            
                             %γ(j) = (rts (1))。/ k;
                            
                             结束
                            
                             阴谋(1:n, k_visu);

42岁的评论
显示41年长的评论隐藏41年长的评论

马修•诺伊 2020年12月3日

你好似乎tyhe想法是工作

现在我们有k收敛对:-0.0688

代码:

                                  % > > %输入
                                 
                                  = -1/5;
                                 
                                  μ= 2;% 2≤µ≤20
                                 
                                  rs = 1/4;
                                 
                                  σ= 1 /√(10);
                                 
                                  xtheta = 0;% xtheta = 0.0和0.2
                                 
                                  V = 0.05;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = 0.5;
                                 
                                  k_visu (1) = k;
                                 
                                  n = 10;% nb的循环
                                 
                                  为j = 2: n;
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  rts_real_sorted =排序(真实(rts));
                                 
                                  k = rts_real_sorted (1);
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (1))。/ k;
                                 
                                  结束
                                 
                                  阴谋(1:n, k_visu);

罗德里戈·佩纳 2020年12月3日

Yaay !谢谢你!

我也有相同的结果。

我扩大相同的理论根源。

现在的挑战是存储这些聚合值。

%的输入

= -1/5;

μ= 2;% 2≤µ≤20

rs = 1/4;

σ= 1 /√(10);

xtheta = 0;% xtheta = 0.0和0.2

V = 0.05;

%方程,根据向量矩阵

k = 0.1;

k1_visu (1) = k

n = 10;% nb的循环

j = 2: n;

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p)

K =排序(rts,“ComparisonMethod”,“真正的”)

k1 =实际(K (1))

k1_visu (j) = k1

结束

k = 0.1;

k2_visu (1) = k

j = 2: n;

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p)

K =排序(rts,“ComparisonMethod”,“真正的”)

k2 =实际(K (2))

k2_visu (j) = k2

结束

k = 0.1;

k3_visu (1) = k

j = 2: n;

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p)

K =排序(rts,“ComparisonMethod”,“真正的”)

k3 =实际(K (3))

k3_visu (j) = k3

结束

k = 0.1;

k4_visu (1) = k

j = 2: n;

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p)

K =排序(rts,“ComparisonMethod”,“真正的”)

k4 =实际(K (4))

k4_visu (j) = k4

结束

阴谋(1:n, k1_visu) %第一根

抓住;

阴谋(1:n, k2_visu) %第二根

阴谋(1:n, k3_visu) %第三根

阴谋(1:n, k4_visu) %第四根

推迟;

马修•诺伊 2020年12月3日

在这里我的代码的建议

当你重用相同的循环,我把它放在一个函数与参数作为参数

                                  
                                  % % > > %输入
                                 
                                  参数个数。= -1/5;
                                 
                                  参数个数。μ= 2;% 2≤µ≤20
                                 
                                  参数个数。rs = 1/4;
                                 
                                  参数个数。σ= 1 /√(10);
                                 
                                  参数个数。xtheta = 0;% xtheta = 0.0和0.2;
                                 
                                  参数个数。V = 0.05;
                                 
                                  %方程,根据向量矩阵
                                 
                                  参数个数。k = 0.5;
                                 
                                  参数个数。循环= 10;% nb循环;% nb的循环
                                 
                                  根= 4;
                                 
                                  k_visu = 0(根,params.loops);
                                 
                                  %主循环/代码
                                 
                                  为ck = 1:根源
                                 
                                  循环:k_visu (ck) = (params, ck);
                                 
                                  legend_str {ck} = ((“根#:”num2str (ck)]);
                                 
                                  结束
                                 
                                  阴谋(1:params.loops, k_visu);网格
                                 
                                  传奇(legend_str)
                                 
                                  包含(“迭代”);
                                 
                                  % %
                                 
                                  函数root_index k_visu =循环(params)
                                 
                                  一个= params.a;
                                 
                                  μ= params.mu;% 2≤µ≤20
                                 
                                  rs = params.rs;
                                 
                                  σ= params.sigma;
                                 
                                  xtheta = params.xtheta;% xtheta = 0.0和0.2
                                 
                                  V = params.V;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = params.k;
                                 
                                  循环= params.loops;% nb的循环
                                 
                                  k_visu = 0(1、循环);
                                 
                                  为j = 2:循环
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  rts_real_sorted =排序(真实(rts));
                                 
                                  k = rts_real_sorted (root_index);
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (1))。/ k;
                                 
                                  结束
                                 
                                  结束

罗德里戈·佩纳 2020年12月3日

我只是实现γ,我犯了一些错误,k =图像放大(rts(1))不是k =实际(rts (1))。

我只需要做一件事……上面的代码是给聚合k和γ的值。现在我想阴谋k的变化和伽马函数V (= 0.05)。从0.05到5 V都有增量为0.05。

你能帮我吗?

%的输入

= -1/5;

μ= 2;% 2≤µ≤20

rs = 1/4;

σ= 1 /√(10);

xtheta = 0;% xtheta = 0.0和0.2

V = 0.05;

%方程,根据向量矩阵

k = 0.1;

k1_visu (1) = k;

gamma1_visu (1) = k;

n = 10;% nb的循环

j = 2: n

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p);

K =排序(rts,“ComparisonMethod”,“真正的”);

k1 =图像放大(K (1));

k1_visu (j) = k1

γ=实际(K (1)) / k1;

gamma1_visu (j)γ=

结束

k = 0.1;

k2_visu (1) = k;

gamma2_visu (1) = k;

j = 2: n

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p);

K =排序(rts,“ComparisonMethod”,“真正的”);

k2 =图像放大(K (2));

k2_visu (j) = k2

γ₂=实际(K (2)) / k2;

γ₂gamma2_visu (j) =

结束

k = 0.1;

k3_visu (1) = k;

gamma3_visu (1) = k;

j = 2: n

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p);

K =排序(rts,“ComparisonMethod”,“真正的”);

k3 =图像放大(K (3));

k3_visu (j) = k3

γ₃=实际(K (3)) / k3;

gamma3_visu (j) =γ₃

结束

k = 0.1;

k4_visu (1) = k;

gamma4_visu (1) = k;

j = 2: n

Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);

季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;

f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;

f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;

——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;

p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];

rts =根(p);

K =排序(rts,“ComparisonMethod”,“真正的”);

k4 =图像放大(K (4));

k4_visu (j) = k4

gamma4 =实际(K (4)) / k4;

gamma4_visu (j) = gamma4

结束

k_converged = [k1_visu (10), k2_visu (10), k3_visu (10), k4_visu (10))

gamma_converged = [gamma1_visu (10), gamma2_visu (10), gamma3_visu (10), gamma4_visu (10))

图(1)

阴谋(1:n, k1_visu) %第一个虚根

抓住;

阴谋(1:n, k2_visu) %第二虚根

阴谋(1:n, k3_visu) %第三虚根

阴谋(1:n, k4_visu) %第四虚根

网格;

推迟;

图(2)

阴谋(1:n, gamma1_visu)

抓住;

阴谋(1:n, gamma2_visu)

阴谋(1:n, gamma3_visu)

阴谋(1:n, gamma4_visu)

网格;

推迟;

马修•诺伊 2020年12月3日

嗨

在一个迭代之前,我惊讶于代码的输出。

我相信有一个错误时,您已经创建了k1、k2、k3, k4变量,因为这些变量并不在for循环中使用更新方程:它只使用“k”而不是k1, k2, k3, k4

看到线我有评论,我只是纠正

这是我修正之后,我们将看到如何继续。

                                  clc
                                 
                                  清晰的所有
                                 
                                  %的输入
                                 
                                  = -1/5;
                                 
                                  μ= 2;% 2≤µ≤20
                                 
                                  rs = 1/4;
                                 
                                  σ= 1 /√(10);
                                 
                                  xtheta = 0;% xtheta = 0.0和0.2
                                 
                                  V = 0.05;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = 0.1;
                                 
                                  k1_visu (1) = k;
                                 
                                  gamma1_visu (1) = k;
                                 
                                  n = 10;% nb的循环
                                 
                                  为j = 2: n
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  % k1 =图像放大(K (1));%不能k1因为这个循环
                                 
                                  %“k”,而非k1(否则没有递归k值
                                 
                                  % k1_visu (j) = k1
                                 
                                  %γ=实际(K (1)) / k1;
                                 
                                  k =图像放大(k (1));%我修正
                                 
                                  k1_visu (j) = k;%我修正
                                 
                                  γ=实际/ K (K (1));%我修正
                                 
                                  gamma1_visu (j)γ=;
                                 
                                  结束
                                 
                                  k = 0.1;
                                 
                                  k2_visu (1) = k;
                                 
                                  gamma2_visu (1) = k;
                                 
                                  为j = 2: n
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  % k2 =图像放大(K (2));%以上评论一样
                                 
                                  % k2_visu (j) = k2
                                 
                                  γ₂% =实际(K (2)) / k2;
                                 
                                  k =图像放大(k (2));%我修正
                                 
                                  k2_visu (j) = k;%我修正
                                 
                                  γ₂=实际/ K (K (2));%我修正
                                 
                                  γ₂gamma2_visu (j) =;
                                 
                                  结束
                                 
                                  k = 0.1;
                                 
                                  k3_visu (1) = k;
                                 
                                  gamma3_visu (1) = k;
                                 
                                  为j = 2: n
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  % k3 =图像放大(K (3));%以上评论一样
                                 
                                  % k3_visu (j) = k3
                                 
                                  %γ₃=实际(K (3)) / k3;
                                 
                                  k =图像放大(k (3));%我修正
                                 
                                  k3_visu (j) = k%我修正
                                 
                                  γ₃=实际/ K (K (3));%我修正
                                 
                                  gamma3_visu (j) =γ₃;
                                 
                                  结束
                                 
                                  k = 0.1;
                                 
                                  k4_visu (1) = k;
                                 
                                  gamma4_visu (1) = k;
                                 
                                  为j = 2: n
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  % k4 =图像放大(K (4));%以上评论一样
                                 
                                  % k4_visu (j) = k4
                                 
                                  % gamma4 =实际(K (4)) / k4;
                                 
                                  k =图像放大(k (4));%我修正
                                 
                                  k4_visu (j) = k;%我修正
                                 
                                  gamma4 =实际/ K (K (4));%我修正
                                 
                                  gamma4_visu (j) = gamma4
                                 
                                  结束
                                 
                                  k_converged = [k1_visu (10), k2_visu (10), k3_visu (10), k4_visu (10))
                                 
                                  gamma_converged = [gamma1_visu (10), gamma2_visu (10), gamma3_visu (10), gamma4_visu (10))
                                 
                                  图(1)
                                 
                                  阴谋(1:n, k1_visu)%的第一个虚根
                                 
                                  持有在;
                                 
                                  阴谋(1:n, k2_visu)%的第二个虚根
                                 
                                  阴谋(1:n, k3_visu)%第三虚根
                                 
                                  阴谋(1:n, k4_visu)%第四虚根
                                 
                                  网格在;
                                 
                                  持有从;
                                 
                                  图(2)
                                 
                                  阴谋(1:n, gamma1_visu)
                                 
                                  持有在;
                                 
                                  阴谋(1:n, gamma2_visu)
                                 
                                  阴谋(1:n, gamma3_visu)
                                 
                                  阴谋(1:n, gamma4_visu)
                                 
                                  网格在;
                                 
                                  持有从;

马修•诺伊 2020年12月3日

校正后,你的代码和我的版本是等价的

第一个图是相同的,但没有对所有4根全局收敛性

那么我们该怎么做呢?

我的代码如下:

                                  %我试图编写一个程序,计算aeroelasticiy东西。我不知道程序是计算应该是什么。
                                 
                                  %的计划是:
                                 
                                  % 1 -猜k的值在0和1之间
                                 
                                  % 2 -计算Ck
                                 
                                  % 3 -计算到
                                 
                                  % 4 -计算f12
                                 
                                  % 5 -计算f21
                                 
                                  % 6 -计算——f22
                                 
                                  % 7 -计算多项式的根(p)
                                 
                                  % 8 -选择一个多项式的根的p(例如让´s说第一个)
                                 
                                  % 9 - k等于新值的多项式的根的实部p(第一根)
                                 
                                  % 10 -回到步骤2 k计算一切,直到收敛。
                                 
                                  clc
                                 
                                  清晰的所有
                                 
                                  % %的输入
                                 
                                  % = -1/5;
                                 
                                  %μ= 2;% 2≤µ≤20
                                 
                                  % rs = 1/4;
                                 
                                  %σ= 1 /√(10);
                                 
                                  % xtheta = 0;% xtheta = 0.0和0.2
                                 
                                  % V = 0.05;
                                 
                                  % %方程,根据向量矩阵
                                 
                                  % k = 0.1;
                                 
                                  % k1_visu (1) = k;
                                 
                                  % gamma1_visu (1) = k;
                                 
                                  n = 10;% nb的循环
                                 
                                  % % > > %输入
                                 
                                  参数个数。= -1/5;
                                 
                                  参数个数。μ= 2;% 2≤µ≤20
                                 
                                  参数个数。rs = 1/4;
                                 
                                  参数个数。σ= 1 /√(10);
                                 
                                  参数个数。xtheta = 0;% xtheta = 0.0和0.2;
                                 
                                  参数个数。V = 0.05;
                                 
                                  %方程,根据向量矩阵
                                 
                                  参数个数。k = 0.1;
                                 
                                  参数个数。循环= 10;% nb循环;% nb的循环
                                 
                                  根= 4;
                                 
                                  k_visu = 0(根,params.loops);
                                 
                                  %主循环/代码
                                 
                                  为ck = 1:根源
                                 
                                  :k_visu (ck) = mainloop (params, ck);
                                 
                                  legend_str {ck} = ((“根#:”num2str (ck)]);
                                 
                                  结束
                                 
                                  阴谋(1:params.loops, k_visu);网格
                                 
                                  传奇(legend_str)
                                 
                                  包含(“迭代”);
                                 
                                  % %
                                 
                                  函数root_index k_visu = mainloop (params)
                                 
                                  一个= params.a;
                                 
                                  μ= params.mu;% 2≤µ≤20
                                 
                                  rs = params.rs;
                                 
                                  σ= params.sigma;
                                 
                                  xtheta = params.xtheta;% xtheta = 0.0和0.2
                                 
                                  V = params.V;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = params.k;
                                 
                                  循环= params.loops;% nb的循环
                                 
                                  k_visu = 0(1、循环);
                                 
                                  为j = 2:循环
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  k =图像放大(k (root_index));
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (1))。/ k;
                                 
                                  结束
                                 
                                  结束

马修•诺伊 2020年12月3日

这是循环的代码/ V

                                  %我试图编写一个程序,计算aeroelasticiy东西。我不知道程序是计算应该是什么。
                                 
                                  %的计划是:
                                 
                                  % 1 -猜k的值在0和1之间
                                 
                                  % 2 -计算Ck
                                 
                                  % 3 -计算到
                                 
                                  % 4 -计算f12
                                 
                                  % 5 -计算f21
                                 
                                  % 6 -计算——f22
                                 
                                  % 7 -计算多项式的根(p)
                                 
                                  % 8 -选择一个多项式的根的p(例如让´s说第一个)
                                 
                                  % 9 - k等于新值的多项式的根的实部p(第一根)
                                 
                                  % 10 -回到步骤2 k计算一切,直到收敛。
                                 
                                  clc
                                 
                                  清晰的所有
                                 
                                  n = 10;% nb的循环
                                 
                                  % % > > %输入
                                 
                                  参数个数。= -1/5;
                                 
                                  参数个数。μ= 2;% 2≤µ≤20
                                 
                                  参数个数。rs = 1/4;
                                 
                                  参数个数。σ= 1 /√(10);
                                 
                                  参数个数。xtheta = 0;% xtheta = 0.0和0.2;
                                 
                                  参数个数。V = 0.05;
                                 
                                  %方程,根据向量矩阵
                                 
                                  参数个数。k = 0.1;
                                 
                                  参数个数。循环= 10;% nb循环;% nb的循环
                                 
                                  根= 4;
                                 
                                  % % %循环与根数% % % %
                                 
                                  % k_visu = 0(根,params.loops);
                                 
                                  %
                                 
                                  % %主循环/代码
                                 
                                  % ck = 1:根源
                                 
                                  :% k_visu (ck) = mainloop (params, ck);
                                 
                                  % legend_str {ck} =(['根#:“num2str (ck)));
                                 
                                  %结束
                                 
                                  %
                                 
                                  %的阴谋(1:params.loops, k_visu);网格
                                 
                                  %的传说(legend_str)
                                 
                                  %包含(“迭代”);
                                 
                                  % % % % V循环与参数
                                 
                                  % V在增量变化从0.05到5 0.05。
                                 
                                  V = (0.05:0.05:5);
                                 
                                  k1_converged_visu = 0(长度(V), 1);
                                 
                                  k2_converged_visu = 0(长度(V), 1);
                                 
                                  k3_converged_visu = 0(长度(V), 1);
                                 
                                  k4_converged_visu = 0(长度(V), 1);
                                 
                                  %主循环/代码
                                 
                                  为ck = 1:长度(V)
                                 
                                  参数个数。V = V (ck);
                                 
                                  k1_visu = mainloop (params, 1);
                                 
                                  k1_converged_visu (ck) = k1_visu(结束);
                                 
                                  k2_visu = mainloop (params, 2);
                                 
                                  k2_converged_visu (ck) = k2_visu(结束);
                                 
                                  k3_visu = mainloop (params, 3);
                                 
                                  k3_converged_visu (ck) = k3_visu(结束);
                                 
                                  k4_visu = mainloop (params, 4);
                                 
                                  k4_converged_visu (ck) = k4_visu(结束);
                                 
                                  结束
                                 
                                  xaxis_data = 1:长度(V);
                                 
                                  情节(xaxis_data [k1_converged_visu k2_converged_visu k3_converged_visu k4_converged_visu]);网格
                                 
                                  包含(“V”);
                                 
                                  % %
                                 
                                  函数root_index k_visu = mainloop (params)
                                 
                                  一个= params.a;
                                 
                                  μ= params.mu;% 2≤µ≤20
                                 
                                  rs = params.rs;
                                 
                                  σ= params.sigma;
                                 
                                  xtheta = params.xtheta;% xtheta = 0.0和0.2
                                 
                                  V = params.V;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = params.k;
                                 
                                  循环= params.loops;% nb的循环
                                 
                                  k_visu = 0(1、循环);
                                 
                                  为j = 2:循环
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  k =图像放大(k (root_index));
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (1))。/ k;
                                 
                                  结束
                                 
                                  结束

马修•诺伊 2020年12月4日

如果这是验证,最后绘制k vs V将代码:

                                  %我试图编写一个程序,计算aeroelasticiy东西。我不知道程序是计算应该是什么。
                                 
                                  %的计划是:
                                 
                                  % 1 -猜k的值在0和1之间
                                 
                                  % 2 -计算Ck
                                 
                                  % 3 -计算到
                                 
                                  % 4 -计算f12
                                 
                                  % 5 -计算f21
                                 
                                  % 6 -计算——f22
                                 
                                  % 7 -计算多项式的根(p)
                                 
                                  % 8 -选择一个多项式的根的p(例如让´s说第一个)
                                 
                                  % 9 - k等于新值的多项式的根的实部p(第一根)
                                 
                                  % 10 -回到步骤2 k计算一切,直到收敛。
                                 
                                  clc
                                 
                                  清晰的所有
                                 
                                  % % > > %输入
                                 
                                  参数个数。= -1/5;
                                 
                                  参数个数。μ= 2;% 2≤µ≤20
                                 
                                  参数个数。rs = 1/4;
                                 
                                  参数个数。σ= 1 /√(10);
                                 
                                  参数个数。xtheta = 0;% xtheta = 0.0和0.2;
                                 
                                  %方程,根据向量矩阵
                                 
                                  参数个数。k = 0.1;
                                 
                                  参数个数。循环= 15;% nb循环;% nb的循环
                                 
                                  % % % % V循环与参数
                                 
                                  % V在增量变化从0.52到5 0.05。
                                 
                                  V = (0.52:0.05:5);
                                 
                                  k1_converged_visu = 0(长度(V), 1);
                                 
                                  % k2_converged_visu = 0(长度(V), 1);
                                 
                                  % k3_converged_visu = 0(长度(V), 1);
                                 
                                  % k4_converged_visu = 0(长度(V), 1);
                                 
                                  %主循环/代码
                                 
                                  为ck = 1:长度(V)
                                 
                                  参数个数。V = V (ck);
                                 
                                  k1_visu = mainloop (params, 1);% 1是指1根计算
                                 
                                  k1_converged_visu (ck) = k1_visu(结束);
                                 
                                  % k2_visu = mainloop (params, 2);
                                 
                                  % k2_converged_visu (ck) = k2_visu(结束);
                                 
                                  %
                                 
                                  % k3_visu = mainloop (params, 3);
                                 
                                  % k3_converged_visu (ck) = k3_visu(结束);
                                 
                                  %
                                 
                                  % k4_visu = mainloop (params, 4);
                                 
                                  % k4_converged_visu (ck) = k4_visu(结束);
                                 
                                  结束
                                 
                                  %的阴谋(V, [k1_converged_visu k2_converged_visu k3_converged_visu k4_converged_visu]);网格
                                 
                                  情节(V, k1_converged_visu);网格
                                 
                                  标题(“k vs V”);
                                 
                                  ylabel (“k(1根));
                                 
                                  包含(“V”);
                                 
                                  % %
                                 
                                  函数root_index k_visu = mainloop (params)
                                 
                                  一个= params.a;
                                 
                                  μ= params.mu;% 2≤µ≤20
                                 
                                  rs = params.rs;
                                 
                                  σ= params.sigma;
                                 
                                  xtheta = params.xtheta;% xtheta = 0.0和0.2
                                 
                                  V = params.V;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = params.k;
                                 
                                  循环= params.loops;% nb的循环
                                 
                                  k_visu = 0(1、循环);
                                 
                                  为j = 2:循环
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真实”的);
                                 
                                  k =图像放大(k (root_index));
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (1))。/ k;
                                 
                                  结束
                                 
                                  结束

这是情节我了:

马修•诺伊 2020年12月11日

你好罗德里戈

给你:

                                  %我试图编写一个程序,计算aeroelasticiy东西。我不知道程序是计算应该是什么。
                                 
                                  %的计划是:
                                 
                                  % 1 -猜k的值在0和1之间
                                 
                                  % 2 -计算Ck
                                 
                                  % 3 -计算到
                                 
                                  % 4 -计算f12
                                 
                                  % 5 -计算f21
                                 
                                  % 6 -计算——f22
                                 
                                  % 7 -计算多项式的根(p)
                                 
                                  % 8 -选择一个多项式的根的p(例如让´s说第一个)
                                 
                                  % 9 - k等于新值的多项式的根的实部p(第一根)
                                 
                                  % 10 -回到步骤2 k计算一切,直到收敛。
                                 
                                  clc
                                 
                                  清除所有
                                 
                                  % % > > %输入
                                 
                                  参数个数。= -1/5;
                                 
                                  参数个数。μ= 2;% 2≤µ≤20
                                 
                                  参数个数。rs = 1/4;%注:rs r的平方(不需要把^ 2根方程
                                 
                                  参数个数。σ= 1 /√(10);
                                 
                                  参数个数。xtheta = 0;% xtheta = 0.0和0.2;
                                 
                                  %方程,根据向量矩阵
                                 
                                  参数个数。k = 0.1;
                                 
                                  参数个数。循环= 15;% nb of loops;% nb of loops
                                 
                                  root_index = 1:4;% 1:4;%的根
                                 
                                  % % % % V循环与参数
                                 
                                  % V在增量变化从0.52到5 0.05。
                                 
                                  V = (0.52:0.05:5);
                                 
                                  ci = 1:长度(root_index)
                                 
                                  %主循环/代码
                                 
                                  ck = 1:长度(V)
                                 
                                  参数个数。V = V (ck);
                                 
                                  [k_visuγ]= mainloop (params root_index (ci));
                                 
                                  k_converged_visu (ci, ck) = k_visu(结束);
                                 
                                  gamma_converged_visu (ci, ck) =γ(结束);
                                 
                                  结束
                                 
                                  结束
                                 
                                  图(1)中,情节(V, k_converged_visu);网格
                                 
                                  标题(“k vs V”);
                                 
                                  ylabel (k(1根));
                                 
                                  包含(' V ');
                                 
                                  图(2),图(V, gamma_converged_visu);网格
                                 
                                  标题(“伽马vs V”);
                                 
                                  ylabel(γ(1根));
                                 
                                  包含(' V ');
                                 
                                  % %
                                 
                                  函数[k_visuγ]= mainloop (params root_index)
                                 
                                  一个= params.a;
                                 
                                  μ= params.mu;% 2≤µ≤20
                                 
                                  rs = params.rs;
                                 
                                  σ= params.sigma;
                                 
                                  xtheta = params.xtheta;% xtheta = 0.0和0.2
                                 
                                  V = params.V;
                                 
                                  %方程,根据向量矩阵
                                 
                                  k = params.k;
                                 
                                  循环= params.loops; % nb的循环
                                 
                                  k_visu = 0(1、循环);
                                 
                                  j = 2:循环
                                 
                                  Ck = (0.01365 + 0.2808 * 1 i (k * k。^ 2. / 2) / (0.01365 + 0.3455 * 1 i (k * k。^ 2);
                                 
                                  季=σ^ 2. / V。^ 2 - k。^ 2。/μ+(2 * 1我。* Ck) /亩;%好
                                 
                                  f12 = (k。*(1 +一个。* k) +(2 + 1我。* k。* (1 - 2)) * Ck) /亩;%好
                                 
                                  f21 = (. * k。^ 2 - 1我。* k。* (1 + 2 *)* Ck) /亩;%好
                                 
                                  %——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) / 8 *亩;%不可以,分母是失踪()
                                 
                                  ——f22 =((8 *μ* rs)。/ V ^ 2 + 4 * 1 * (1 + 2 *) * (2 * 1 i - k。* (1 - 2 *))。* Ck - k。* (k - 4 * 1 + 8 * *(1 +一个。* k))) /(8 *亩);%好
                                 
                                  p = [(rs-xtheta ^ 2) 0 (——f22 + f11。* rs - f21。* xtheta - f12。* xtheta) 0(季。*——f22 - f12。* f21)];%好
                                 
                                  rts =根(p);
                                 
                                  K =排序(rts,“ComparisonMethod”,“真正的”);
                                 
                                  k =图像放大(k (root_index));
                                 
                                  k_visu (j) = k;
                                 
                                  %γ(j) = (rts (root_index)。/ k;
                                 
                                  γ(j) = (K (root_index)。/ K;
                                 
                                  结束
                                 
                                  结束

登录置评。

类别

图像处理和计算机视觉图像处理工具箱开始使用图像处理工具箱

找到更多的在开始使用图像处理工具箱在帮助中心和文件交换

下载188bet金宝搏

MATLAB

释放

R2020b

社区寻宝

找到宝藏在MATLAB中央,发现社区如何帮助你!

开始狩猎!

检查我的程序计算应该是什么。

0评论
显示1年长的评论藏1年长的评论

接受的答案

42岁的评论
显示41年长的评论隐藏41年长的评论

更多的答案(0)

另请参阅

类别

标签

下载188bet金宝搏

释放

社区寻宝

检查我的程序计算应该是什么。

0评论 显示1年长的评论藏1年长的评论

接受的答案

42岁的评论 显示41年长的评论隐藏41年长的评论

更多的答案(0)

另请参阅

类别

标签

下载188bet金宝搏

释放

社区寻宝

0评论
显示1年长的评论藏1年长的评论

42岁的评论
显示41年长的评论隐藏41年长的评论