[0] はじめに
対話型数式処理プログラムMAXIMAは、次からフリーで入手できます。
http://sourceforge.net/projects/maxima/files/
次のフォントが必要な場合があります。
TeX-fonts-25

[1] 基礎
１）次のコマンドを与えます。最後にshift+enterを押してください。
–> a:1;
こうすると変数aに値1を与えたことになります。MAXIMAでは，「:」は「定義によって等しい」を意味します。確認のため，次のコマンドを与えてみます。
–> a;
また，最後の「;」はコマンド行の区切りを示し（つけない場合は自動的に付加されます），MAXIMAは対応する処理を実行後，その結果を返します。もし，処理結果の表示が不要な場合は，最後に「$」を置きます。次を確かめてください。
–> a:1$
もし，変数aやすべての変数を消去したい場合は，それぞれ次のコマンドを与えます。
–> kill(a);
–> kill(all);

２）さて，四則演算の記法については，通常の言語処理系と同じように，次が用いられます。
–> x+y;
–> x-y;
–> x*y;
–> x/y;
–> x^y;

３）関数を定義するには，次のコマンドを与えます。
–> y: a*x^2;
yの値を，x=2について計算するときは，次のコマンドを与えます。
–> ev(y,x:2);
または
–> y, x:2

４）一方，のように関数を明示的に定義するには，次のコマンドを与えます。
–> f(x):=a*x^2;
ここで、x=2のときの値は，次のように参照できます。
–> f(2);

[2] 関数のグラフ
１）関数のグラフを描くときは，たとえば次のコマンドを与えます。
–> y1: x^2;
–> plot2d(y1,[x,-2,2]);

２）２つのグラフを重ねて描くときは，続けて次のコマンドを与えます。
–> y2: 2*x;
–> plot2d([y1,y2],[x,-2,2]);

[3] リスト
１）MAXIMAの基本的なデータ構造は，「リスト」と呼ばれるものです。たとえば，次のコマンドを与えます。
–> a1:[a11,a12];
これにより，a1は，２つの要素a11とa12からなるリストとして定義されます。また，要素の区切りは「,」であることに注意してください。

２）ある変数がリストであるかどうかを調べるためには，次のコマンドを与えます。
–> listp(a1);
リストの長さを調べるには，次のコマンドを与えます。
–> length(a1);
リストの要素へのアクセス，たとえば，第１番目の要素を調べるには，次のコマンドを与えます。
–> a1[1];

３）さて，リスト自身を要素にもつリストも定義できます。
–> a2:[a21,a22];
を定義して，次のコマンドを与えてください。
–> A:[a1,a2];
これが，サイズ２×２の行列Ａを定義したことに相当します（行列データについては，あとで詳しく説明します）。たとえば，A[2]はa2を意味しますので，Aの（２，１）要素へのアクセスは次のようにします。
–> A[2][1];

[4] 関数
１）絶対値と平方根については，たとえば次のように得られます。
–> abs(-2);
–> sqrt(2);

２）円周率は，%piで参照することができます。
–> %pi;
–> %pi, numer;
三角関数の計算は，たとえば次の通り実行できます。
–> sin(%pi/4);
–> cos(%pi/4);
–> tan(%pi/4);

３）三角関数の逆関数の計算は，たとえば次の通り実行できます。
–> asin(1);
–> acos(-1);
–> atan(1);
–> atan2(1,-1);
ここで，x>0のときatan2(y,x)=atan(y/x)です。

４）次は，加法定理を示しています。
–> trigexpand(sin(x+y));
–> trigreduce(%)
–> trigexpand(cos(x+y));
–> trigreduce(%)
–> trigexpand(tan(x+y));
–> trigreduce(%)

５）指数関数の計算は，たとえば次の通り実行できます。
–> exp(0);

６） この逆関数(対数関数)の計算は，たとえば次の通り実行できます。
–> log(1);
この底はネイピア数eですが，10の場合は次の関数を定義して用います。
–> log10(x):=log(x)/log(10);
–> log10(1);

７）双曲線関数は，次式で定義されます。

これらの計算は，たとえば次の通り実行できます。
–> sinh(0);
–> cosh(0);
–> tanh(0);

８）双曲線関数の逆関数の計算は，たとえば次の通り実行できます。
–> asinh(0);
–> acosh(1);
–> atanh(0);

[5] 多項式
１）因数分解

を行うために，次のコマンドを与えてください。
–> factor(x^2-1);

２）また，式の展開

を行うために，次のコマンドを与えてください。
–> expand((a+1)*(x-1));
ここで，xだけについて整理して

としたいときには，次のコマンドを与えまず。
–> ratsimp(%,x);
ここで，「%」は直前の結果を参照しています。

３）さらに，部分分数展開

を行うために，次のコマンドを与えてみてください。
–> partfrac(1/(x^2+3*x+2),x);

[6] 方程式
１）２次方程式

を解くために，次のコマンドを与えてください。
–> solve(x^2+1=0,x);
ここで，出力結果における「%i」は虚数単位を表しています。解は2つの要素をもつリストとして得られていることに注意してください。第１番目の解は%[1]，第２番目の解は%[2]でアクセスできます。

２）それでは，２次方程式

の解の公式を求めてみましょう。
–> sol: solve(a*x^2+b*x+c=0,x)

３）次に，連立１次方程式

を解くために，次のコマンドを与えてください。
–> solve([x+y=1,x+2*y=1],[x,y])

４）それでは，連立１次方程式

の解を求めてください。
–> sol: solve([a*x+b*y=e,c*x+d*y=f],[x,y])
解はリストのリストとして得られています。したがって，第１番目の解はsol[1][1],第２番目の解はsol[1][2]でアクセスできることに注意してください。

５）ちなみに，複素数

の実部と虚部は，次のように得られます。
–> realpart(1-%i)
–> imagpart(1-%i)

[7] 論理演算
１）論理和，論理積，否定はそれぞれ



のように表されます。たとえば
–> true and false;
–> true or false;
–> not true;
これらは，論理式と呼ばれ，trueかfalseのどちらかの値をとります。

２）真理値表を作ってみましょう。
–> [true and true, true and false, false and true, false and false];
–> [true or true, true or false, false or true, false or false];
–> [not true, not false];

３）次の等価な関係は，さまざまな論理展開に有用です。

右辺の真理値表を作ってみましょう。
–> [true and not true, true and not false, false and not true, false and not false];

４）さて，次のように入力してみてください。
–> is(1=1);
–> is(1#1);
これらも論理式です。次も同様です。
–> is(1>1);
–> is(1>=1);
–> is(1<1);
–> is(1<=1);

[8] 微分積分
１）まず極限の例を，いくつか挙げます。
–> limit(exp(-x),x,inf);
–> limit(exp(x),x,inf);
–> limit((1+1/x)^x,x,0);
–> limit(sin(x)/x,x,0);

２）微分の例を，いくつか挙げます。
–> diff(x^2,x);
–> diff(1/x,x);
–> diff(exp(x),x);
–> diff(log(x),x);
–> diff(sin(x),x);
–> diff(atan(x),x)

２）２階微分は，たとえば次のように行います。
–> diff(x^2,x,2);

３） 積分の例を，いくつか挙げます。
–> integrate(2*x,x);
–> integrate(-1/x^2,x);
–> integrate(exp(x),x);
–> integrate(1/x,x);
–> integrate(cos(x),x);
–> integrate(1/(x^2+1),x);

４）次のようにtaylor展開を行うことができます。
–> taylor(exp(x),x,0,10);
–> taylor(sin(x),x,0,10);
–> taylor(cos(x),x,0,10);

５）微分方程式

を解くために，次のコマンドを与えてください。
–> sol:desolve(’diff(x(t),t)=-x(t),x(t));
ここで，「’diff(x(t),t)」は，

を表しています。また，注意しなければないのは，solがリストとなっていないことです。たとえば，x(0)=1のとき，この解のグラフを描くには，次のように，コマンドを与えます。
–> s1:rhs(sol), x(0)=1;
–> plot2d(s1,[t,0,5]);

６）さらに，微分方程式

の解の構成要素を調べるために，次のコマンドを与えてください。
–> sol:desolve(’diff(x(t),t)=-x(t)+sin(10*t),x(t));
–> s2:rhs(sol), x(0)=1;
–> s3:rhs(sol), x(0)=0;
–> plot2d([s1,s2,s3],[t,0,5]);

[9] 行列計算
１）次のコマンドを与えてみましょう。
–> A:matrix([a11,a12],[a21,a22]);
–> B:ident(2);
–> C:zeromatrix(2,2);
–> D:apply(matrix,makelist(ident(2)[i]*[d1,d2][i],i,1,2));
行列Aの（2,1）要素へのアクセスは,A[2][1]またはA[2,1]として行います。
–> A[2,1];

２）行列の結合は次のように行います。
–> addcol(A,B);
–> addrow(A,C);

３）まず，要素ごとの四則演算は，次のように行えます。
–> A+B;
–> A-B;
–> A*B;
–> B/A;
–> A^2;

４）次に，行列としての演算は，次のように行います。
–> A.B;
–> A.invert(A);
–> A^^2;
–> transpose(A);

５）行列の階数，行列式，特性多項式、余因子行列は，次のように求められます。
–> rank(A);
–> determinant(A);
–> charpoly(A,s);
–> adjoint(A);

６）固有値と固有ベクトルは，次のように求められます。
–> Q:matrix([q1,q3],[q3,q2]);
–> eigenvalues(Q);
–> V:eigenvectors(Q);
この固有ベクトルが直交することは、次のように確かめられます。
–> V[2][1][1].V[2][2][1],ratsimp;

[0] このページは、「SCILABによる倒立振子の特性解析」の続きです。以下では、物理定数を次のように仮定します。

[kg], [m], [m], [deg]

[1] まず，安定性を調べます。そのために，SCILABの関数specを用いて，行列の固有値を求めると，次のように得られます。

したがって，３つの固有値の実部が負ではなく，漸近安定性の条件（すべての固有値の実部が負）を満足していません。よって，倒立振子は不安定な制御対象であると判定します。
次に，可制御性の判定を行ないます。そのために，可制御性行列の階数が，制御対象の次数４に等しいか，すなわち

が成り立つかどうかを調べます。行列 の最小特異値を求めると，次のように得られます。

すべての最小特異値は正なので，倒立振子の可制御性は成り立つと判定します。

次に，可観測性の判定を行ないます。そのために，可観測性行列の階数が，制御対象の次数４に等しいか，すなわち

が成り立つかどうかを調べます。行列 の最小特異値を求めると，次のように得られます。

すべての最小特異値は正なので，倒立振子の可観測性は成り立つと判定します。

以上の計算を，SCILABで行うためのプログラムを，次に示します。

//cip.sce
M=0.94; m=0.23; ell=0.6413/2; g=9.8;
alpha=5/180*%pi
a32=-6*m*g/(8*M+(5-3*cos(2*alpha))*m);
b3=8/(8*M+(5-3*cos(2*alpha))*m);
a42=6*(M+m)*g/(8*M+(5-3*cos(2*alpha))*m)/ell;
b4=-6*cos(alpha)/(8*M+(5-3*cos(2*alpha))*m)/ell;
A=[0 0 1 0;0 0 0 1;0 a32 0 0;0 a42 0 0];
B=[0;0;b3;b4];
C=eye(2,4);
r=spec(A)
for i=1:4, min(svd([B A-r(i)*eye(4,4)])), end
for i=1:4, min(svd([C; A-r(i)*eye(4,4)])), end

[2] 不安定な倒立振子を安定化するための状態フィードバック

を決定することを考えます。そのために安定な閉ループ系

の応答に対して，２次形式評価関数

ただし、

を最小化するものを選ぶことを考えます。そのような安定化状態フードバックのゲイン行列は，リッカチ方程式CARE

ただし、

の解を用いて，次のように与えられます。

以上の計算を，SCILABで行うためのプログラムを，次に示します。

Mr=1; Tr=0.1; Mth=5/180*%pi;
Tth=(1/4)*(2*%pi*sqrt(4/3*ell/g)); Mu=5;
q1=1/Mr; q2=1/Mth; q3=Tr/Mr; q4=Tth/Mth; r1=1/Mu; rho=1;
Q=diag([q1^2,q2^2,q3^2,q4^2]); R=rho^2*r1^2;
//—–
function [F,p]=opt(A,B,C,Q,R)
w2=R\B’;
[v,p]=spec([A -B*w2;-C’*Q*C -A’]); p=diag(p);
[dummy,index]=sort(real(p));
n=size(A,1); j=index(n+1:n+n);
p=p(j); x=v(1:n,j); y=v(n+1:n+n,j);
X=real(y/x); F=w2*X;
endfunction
//—–
[F,p]=opt(A,B,eye(4,4),Q,R);
function dz=clps1(t,z),dz=(A-B*F)*z,endfunction
t0=0; t=0:0.01:10; x0=[0;3/180*%pi;0;0];
z=ode(x0,t0,t,clps1);
scf(0);
subplot(211),plot(t,diag([100 180/%pi])*C*z); mtlb_grid
subplot(212),plot(t,-F*z); mtlb_grid

計算工学演習第一レポート（２）

次の単振り子を考えます。

この運動方程式は

すなわち

となります。ここで、　と近似すると

となります。この解は、　を仮定すると

のように表されます。ここで、単振り子の周期は次式で与えられます。

この線形シミュレーションを行うために、次のプログラムを実行してみてください。

function dx=f(t,x),
dx=A*x,
endfunction
g=9.8; L=1;
A=[0 1;-g/L 0];
t0=0; t1=10; nt=100; td=(t1-t0)/nt; t=t0:td:t1;
x0=[-30/180*%pi;0];
x1=ode(x0,t0,t,f);
x0=[-177/180*%pi;0];
x2=ode(x0,t0,t,f);
clf(0),scf(0);
plot(t,180/%pi*x1(1,:),’b’,t,180/%pi*x2(1,:),’r’),
mtlb_grid

次のようなグラフが現れるでしょう。初期値は２通り設定しています。

次に、非線形シミュレーションを行うために、次のプログラムを実行してみてください。

function dx=f1(t,x)
th=x(1);
dth=x(2);
dx(1)=dth;
dx(2)=-g/ell*sin(th);
endfunction
g=9.8; ell=1; T=2*%pi*1/sqrt(g/ell)
t0=0; t1=10; nt=100; td=(t1-t0)/nt; t=t0:td:t1;
x=[-30/180*%pi;0];
for i=1:nt, x=[x ode(x(:,i),t(i),t(i+1),f1)]; end
x1=x;
x=[-177/180*%pi;0];
for i=1:nt, x=[x ode(x(:,i),t(i),t(i+1),f1)]; end
x2=x;
clf(0),scf(0);
plot(t,180/%pi*x1(1,:),’b’,t,180/%pi*x2(1,:),’r’),
mtlb_grid

次のようなグラフが現れるでしょう。初期値は２通り設定しています。

線形と非線形では、シミュレーション結果が全く違います！

それでは、これらをアニメーションで比較してみましょう。まず、線形シミュレーションの場合です。

function dx=f1(t,x),
dx=A*x,
endfunction
g=9.8; L=1;
A=[0 1;-g/L 0];
t0=0; t1=10; nt=2000; td=(t1-t0)/nt; t=t0:td:t1;
x0=[-30/180*%pi;0];
x1=ode(x0,t0,t,f1);
x0=[-177/180*%pi;0];
x2=ode(x0,t0,t,f1);
x=L*sin(x2(1,:)+%pi);
y=L*cos(x2(1,:)+%pi);
figure(1);
plot([0;x(1)],[0;y(1)],’o-‘);
h_compound = gce();
h_compound.children.thickness = 2
h_compound.children.mark_size = 10;
h_compound.children.mark_background = 2;
h_axes = gca();
h_axes.data_bounds = [-1.5,-1.5;1.5,1.5];
i = 1;
while i<=length(t)
drawlater();
h_compound.children.data = [0 0;x(i),y(i)];
drawnow();
i = i+1;
end

次に、非線形シミュレーションの場合です。

function dx=f2(t,x)
th=x(1);
dth=x(2);
dx(1)=dth;
dx(2)=-g/ell*sin(th);
endfunction
g=9.8; ell=0.5; T=2*%pi*1/sqrt(g/ell);
t0=0; t1=10; nt=2000; td=(t1-t0)/nt; t=t0:td:t1;
x0=[-30/180*%pi;0];
x1=ode(x0,t0,t,f2);
x0=[-177/180*%pi;0];
x2=ode(x0,t0,t,f2);
x=2*ell*sin(x2(1,:)+%pi);
y=2*ell*cos(x2(1,:)+%pi);
figure(1);
plot([0;x(1)],[0;y(1)],’o-‘);
h_compound = gce();
h_compound.children.thickness = 2
h_compound.children.mark_size = 10;
h_compound.children.mark_background = 2;
h_axes = gca();
h_axes.data_bounds = [-1.5,-1.5;1.5,1.5];
i = 1;
while i<=length(t)
drawlater();
h_compound.children.data = [0 0;x(i),y(i)];
drawnow();
i = i+1;
end

このアニメーションの作成には、次のサイトを参考にさせていただきました。

Scilabでアニメーション作成

【参考】　バネで拘束されている台車のアニメーションを以下に示します。

clear; xdel(winsid());
function dx=f(t,x),
dx=A*x,
endfunction
A=[0 1;-1 0];
t0=0; t1=10; nt=2000; td=(t1-t0)/nt; t=t0:td:t1;
x0=[0;1];
x1=ode(x0,t0,t,f);
x=0.2*[0 1 1 0 0]’;
y=0.2*[0 0 1 1 0]’;
figure(1);
plot(x,y);
mtlb_grid
h_compound = gce();
h_compound.children.thickness = 2
h_compound.children.mark_size = 10;
h_compound.children.mark_background = 2;
h_axes = gca();
h_axes.data_bounds = [-1.5,-1;1.5,1];
i = 1;
while i<=length(t)
drawlater();
h_compound.children.data = [x+x1(1,i) y];
drawnow();
i = i+1;
end

[1]自由系の時間応答
a) 次の１次自由系の時間応答を重ねて描け。


b) 次の２次自由系の時間応答を重ねて描け。

//resp1.sce
//—–
function dx=f(t,x),dx=a*x,endfunction
x0=1; t0=0;t=0:0.1:10;
a=-1/0.5;
x1=ode(x0,t0,t,f);
a=-1/1;
x2=ode(x0,t0,t,f);
a=-1/2;
x3=ode(x0,t0,t,f);
scf(1);
plot(t,x1,t,x2,t,x3)
mtlb_grid
//—–
function dx=f(t,x),dx=A*x,endfunction
x0=[1;0];t0=0;t=0:0.1:10;
A=[0 1;-1 -0.02]; C=[1 0];
x1=ode(x0,t0,t,f); y1=C*x1;
A=[0 1;-1 -sqrt(2)]; C=[1 0];
x2=ode(x0,t0,t,f); y2=C*x2;
A=[0 1;-1 -2]; C=[1 0];
x3=ode(x0,t0,t,f); y3=C*x3;
scf(2);
plot(t,y1,t,y2,t,y3)
mtlb_grid
//—–
//eof

[2]インパルス応答
a) 次の１次系のインパルス応答を重ねて描け。


b) 次の２次系のインパルス応答を重ねて描け。

//resp2.sce
//—–
function dx=f(t,x),dx=a*x,endfunction
t0=0; t=0:0.01:5;
a=-1/0.5; b=1/0.5;
x1=ode(b,t0,t,f);
a=-1; b=1;
x2=ode(b,t0,t,f);
a=-1/2; b=1/2;
x3=ode(b,t0,t,f);
scf(1);
plot(t,x1,t,x2,t,x3)
mtlb_grid
//—–
function dx=f(t,x),dx=A*x,endfunction
t0=0;t=0:0.1:10;
A=[0 1;-1 -0.02]; B=[0;1]; C=[1 0];
x1=ode(B,t0,t,f); y1=C*x1;
A=[0 1;-1 -sqrt(2)]; B=[0;1]; C=[1 0];
x2=ode(B,t0,t,f); y2=C*x2;
A=[0 1;-1 -2]; B=[0;1]; C=[1 0];
x3=ode(B,t0,t,f); y3=C*x3;
scf(2);
plot(t,y1,t,y2,t,y3,t,1)
mtlb_grid
//—–
//eof

[3]正弦波入力に対する時間応答
a) 次の１次自由系のに対する時間応答を，零入力応答と零状態応答と重ねて描け。


b) 次の２次自由系のに対する時間応答を，零入力応答と零状態応答と重ねて描け。

//resp3.sce
//—–
function dx=f1(t,x),dx=a*x,endfunction
function dx=f2(t,x),dx=a*x+b*u(t),endfunction
function ut=u(t),ut=sin(10*t),endfunction
a=-1; b=1;
x0=1; t0=0; t=0:0.01:5;
x1=ode(x0,t0,t,f1);
x0=0; t0=0; t=0:0.01:5;
x2=ode(x0,t0,t,f2);
x0=1; t0=0; t=0:0.01:5;
x3=ode(x0,t0,t,f2);
scf(1);
plot(t,x1,t,x2,t,x3)
mtlb_grid
//—–
function dx=f1(t,x),dx=A*x,endfunction
function dx=f2(t,x),dx=A*x+B*u(t),endfunction
function ut=u(t),ut=sin(10*t),endfunction
A=[0 1;-1 -sqrt(2)]; B=[0;1]; C=[1 0];
x0=[1;0]; t0=0; t=0:0.1:10;
x1=ode(x0,t0,t,f1); y1=C*x1;
x0=[0;0]; t0=0; t=0:0.1:10;
x2=ode(x0,t0,t,f2); y2=C*x2;
x0=[1;0]; t0=0; t=0:0.1:10;
x3=ode(x0,t0,t,f2); y3=C*x3;
scf(2);
plot(t,y1,t,y2,t,y3,t,1)
mtlb_grid
//—–
//eof

[4]ステップ応答
a) 次の１次系のステップ応答を重ねて描け。


b) 次の２次系のステップ応答を重ねて描け。

//resp4.sce
//—–
function dx=f(t,x),dx=a*x+b*u(t),endfunction
function ut=u(t),ut=1,endfunction
x0=0; t0=0; t=0:0.01:5;
a=-1/0.5; b=1/0.5;
x1=ode(x0,t0,t,f);
a=-1; b=1;
x2=ode(x0,t0,t,f);
a=-1/2; b=1/2;
x3=ode(x0,t0,t,f);
scf(1);
plot(t,x1,t,x2,t,x3,t,1-1/%e)
mtlb_grid
//—–
function dx=f(t,x),dx=A*x+B*u(t),endfunction
function ut=u(t),ut=1,endfunction
x0=[0;0];t0=0;t=0:0.1:10;
A=[0 1;-1 -0.02]; B=[0;1]; C=[1 0];
x1=ode(x0,t0,t,f); y1=C*x1;
A=[0 1;-1 -sqrt(2)]; B=[0;1]; C=[1 0];
x2=ode(x0,t0,t,f); y2=C*x2;
A=[0 1;-1 -2]; B=[0;1]; C=[1 0];
x3=ode(x0,t0,t,f); y3=C*x3;
scf(2);
plot(t,y1,t,y2,t,y3,t,1)
mtlb_grid
//—–
//eof

[5]周波数応答
a) 次の１次系の周波数応答を重ねて描け。


b) 次の２次系の周波数応答を重ねて描け。

//resp5.sce
//—–
function g=f(a,b,w), g=b./(%i*w-a), endfunction
w=logspace(-1,1);
a=-1/2; b=1/2; g=f(a,b,w); ga1=20*log10(abs(g));
ph1=180/%pi*atan(imag(g),real(g));
a=-1/1; b=1/1; g=f(a,b,w); ga2=20*log10(abs(g));
ph2=180/%pi*atan(imag(g),real(g));
a=-1/0.5; b=1/0.5; g=f(a,b,w); ga3=20*log10(abs(g));
ph3=180/%pi*atan(imag(g),real(g));
scf(1);
subplot(211),plot2d(w,ga1,logflag=’ln’),
plot2d(w,ga2,logflag=’ln’),
plot2d(w,ga3,logflag=’ln’),mtlb_grid
subplot(212),plot2d(w,ph1,logflag=’ln’),
plot2d(w,ph2,logflag=’ln’),
plot2d(w,ph3,logflag=’ln’),mtlb_grid
//—–
function g=f(A,B,C,w),
g=[]; N=length(w)
for i=1:N, g=[g C*((%i*w(i)*eye(A)-A)\B)]; end
endfunction
B=[0;1]; C=[1 0]; w=logspace(-1,1,200);
A=[0 1;-1 -2*0.01]; g=f(A,B,C,w); ga1=20*log10(abs(g));
ph1=180/%pi*atan(imag(g),real(g));
A=[0 1;-1 -2/sqrt(2)]; g=f(A,B,C,w); ga2=20*log10(abs(g));
ph2=180/%pi*atan(imag(g),real(g));
A=[0 1;-1 -2*1]; g=f(A,B,C,w); ga3=20*log10(abs(g));
ph3=180/%pi*atan(imag(g),real(g));
scf(2);
subplot(211),plot2d(w,ga1,logflag=’ln’),
plot2d(w,ga2,logflag=’ln’),
plot2d(w,ga3,logflag=’ln’),mtlb_grid
subplot(212),plot2d(w,ph1,logflag=’ln’),
plot2d(w,ph2,logflag=’ln’)
plot2d(w,ph3,logflag=’ln’),mtlb_grid
//—–
//eof

[1] 次の行列を定義せよ。

[2] 行列

に対して

行列Eの列ベクトルを逆順に並べよ。

行列Eの行ベクトルを逆順に並べよ。

行列Eの奇数番目の列ベクトルと偶数番目の行ベクトルからなる小行列を求めよ。

[3]

行列

の固有値分解 を求め，つぎを確かめよ。

行列

の特異値分解を求め，つぎを確かめよ。

x=[3 1 5 4 2] の要素を大きい順に並べよ。

[4] 平均，分散の正規分布密度関数

に対して

(1) ，,
(2) ，,
(3) ，

の場合のグラフを重ねて描け。

[5] 与えられた中心の座標 と半径 に対して，円を描く関数を作成し

(1) ，
(2) ，
(3) ，

の場合の円を重ねて描け。

[0] はじめに
SCILABは対話型数値計算プログラムで、次からフリーで入手できます。
http://www.scilab.org/products/scilab/download

[1] 行列データの入力
１）サイズ２×２の行列

を定義するために、次を入力してみます。
–> A=[1 2;3 4]
ここで、行列データは[ ]で囲み、要素の区切りはスペースまたはカンマ、行替えはセミコロン；を用いることに注意してください。次のように最後に；を置くと、出力が抑制されます。
–> A=[1 2;3 4];
すでに入力した行列データへのアクセスは、次のように行います。
–> A
また、特定の要素へのアクセスや修正は、次のように行います。
–> A(2,1)
–> A(2,1)=-5

２）２次の単位行列

は、次により入力できます。
–> B=eye(2,2)
便利なのは、次のように異なる行数と列数が許されることです。
–> B=eye(2,3)
これは、次のサイズ２×３の行列

の定義を意味します。

３）サイズ３×２の零行列

は、次により定義できます。
–> C=zeros(3,2)

４）３次の対角行列

は、次により定義できます。
–> D=diag([1 2 3])
すなわち、ベクトルにdiagを作用させているわけですが、行列にdiagを作用させ、対角成分を抽出することもできます。
–> d=diag(D)

５）行列A,B,C,Dを小行列としてもつブロック行列

を定義するためには、次のように入力します。
–> E=[A B;C D]

６）サイズ２×２の複素行列

も、次により定義できます。
–> F=[1+%i, 2+3*%i;3+2*%i, 4+4*%i]
ここで、%iは虚数単位を意味します。

７）SCILABでは、空行列を定義できます。
–> G=[]

８）すべての要素が1である行列

は、次により定義できます。
–> H=ones(2,2)

[2] 行列データの管理
１）現時点でどのような行列を定義したかを調べるためには、次のように入力します。
–> who_user
また、たとえば入力した行列データdを消去するためには、次のように入力します。
–> clear d
すべてのデータを消去するときは、次のように入力します。
–> clear

２）行列データEのサイズを調べるには、次のように入力します。
–> [m,n]=size(E)

３）浮動小数点表示を行うためには、次のように入力します。
–> format(’e’)
これを固定小数点表示に戻すためには、次のように入力します。
–> format(’v’)

４）カレントディレクトリのチェックを行うためには、次のコマンドが使えます
–> pwd
–> ls
カレントディレクトリの変更のためには、次のコマンドを与えます。
–> cd(’dname’)

５）メモリ上のデータのセーブとロードのためには、次のコマンドを与えます。
–> save(’fname’)
–> load(’fname’)

[3] コロン記法
１）まず、次を入力してみてください。
–> h=1:3
これは、「form 1 to 3」を意味します。すなわちサイズ1×5の行列h=[1 2 3]が生成されます。コロン「:」はtoの意味で使われ、colon notationと呼ばれています。

２）それでは、次はどうでしょう。
–> h=0:0.5:3
これは、「form 1 to 3 by 0.5」を意味します。すなわち、２つのコロンで挟まれた0.5は増分を意味し、サイズ1×5の行列h=[1 1.5 2 2.5 3]が生成されます。ちなみに、h=1:3はh=1:1:3と同じと考えておきましょう。

３）それでは、次はどうでしょう。
–> h=0:-2
これは、h=1:1:-2の意味になりますが、1から-2まで、増分1では到達できないので、空行列となります。

[4] 小行列の抽出
１）コロン記法の利点は，行列の添え字部分に適用できることにあります。たとえば，行列Eの(2,3)要素には
–> E(2,3)
でアクセスできるのですが，この2と3は，スカラーである必要はなく，ベクトルが使えます。たとえば，次を確かめてください。
–> E([1 3],: )
これは第１行と弟２行からなるサイズ2×5の小行列が取り出されることに注意してください。列を指定する「：」はすべての列を意味しています。

２）次はどうでしょう。
–> E(:,2:4 )
ここで、2:4は[2 3 4]というベクトルでしたよね。第2～4列からなるサイズ5×3の小行列が取り出されることに注意してください。行を指定する「：」はすべての行を意味しています。

３）それでは，次はどうでしょう。
–> E([1 3],2:4 )

[5] 行列の分割
１）いろいろな応用では、ある行列を分割する必要が出てきます。これは小行列の抽出の観点から、たとえば次のようにできます。
–> [m,n]=size(E); i=2; j=2;
–> A=E(1:i,1:j);
–> B=E(1:i,j+1:n);
–> C=E(i+1:m,1:j);
–> D=E(i+1:m,j+1:n);
ここで、i=0のときは1:i=[]、i=mのときはi+1:m=[]などに注意してください。

[6] 行列演算
いま、行列Aが次のように定義されていることを確認してください。

また、行列Bを新しく定義します。
–> B=eye(A)

１）行列A,Bの和、差、乗算は次のように計算できます。
–> X=A+B
–> X=A-B
–> X=A*B

２）行列Aが正則のとき、その逆行列は
–> X=inv(A)
で計算されます。しかし、これは逆行列の要素が欲しいとき以外は使わないようにしましょう。
多くの場合、逆行列は次の連立一次方程式

または

を解くときに用いますが、SCILABでは、次のように計算します。
–> X=A\B
–> X=B/A
それぞれ左からの割り算、右からの割り算と呼ばれます。
これは数値的に安定な数値計算アルゴリズムを得るためは直交行列だけの演算ですませることが必要だからです。

３）行列Aのべき乗と転置共役は次のように計算でされます。
–> X=A^2
–> X=A’

４）それでは、次の演算結果と比較してみましょう。
–> X=A.*B
–> X=A.\B
–> X=B./A
–> X=A.^2
–> X=A.’
すなわち、演算子の前に「ドット．」をおくと、要素ごとの演算やただの転置になります。

５）次に、組み込み関数としては、次が使えます。
sin,cos,tan
asin,acos,atan
sinh,cosh,tanh
asinh,acosh,atanh
sqrt
exp,log,log10
abs
real,imag

６）行列関数としては次が準備されています。
–> X=expm(A)
–> X=norm(A)
–> X=rank(A)
–> X=det(A)
ぞれぞれ、行列指数関数、ノルム、階数、行列式を計算します。

７）また、固有値問題を解くには次の関数を用います。
–> [V,R]=spec(A)
単に固有値だけを求めるのであれば
–> r=spec(A)
でＯＫです。

８）さらに、特異値問題を解くには次の関数を用います。
–> [U,S,V]=svd(A)
単に特異値だけを求めるのであれば
–> s=svd(A)
でＯＫです。

９） 多項式との掛け算は、次のように行います。
–> r=convol([1 1],[1 2])

１０）いま、次のベクトルを定義します。
–> x=[3 1 5 4 2]
このとき、次はxの要素を大きい順番に並べ替えます。
–> [y,i]=gsort(x)
yがソーティングされた結果、iが元のどの位置にあったかを示すインデックスです。たとえば
–> x（i)
としてみるとyと同じ結果が出ます。

１１）次は、ベクトルの要素和、最大値、最小値を求める関数です。
–> y=sum(x)
–> y=max(x)
–> y=min(x)

[7] 関数のグラフ
１）次の関数のグラフを描いてみます。

次のコマンドを与えてください。
–> x=-3:0.1:3;
–> y=1/sqrt(2*%pi)*exp(-x.*x/2)；
–> plot(x,y)
ここで，なぜx*xでなく，x.*xとしているか考えてみてください。

２）描画範囲（-3<=x<=3, 0<=ｙ<=0.4）を指定し，グリッドを描画するには，次のようなコマンドを追加します。
–> mtlb_grid
–> mtlb_axis([-3 3 0 0.5])
–> xtitle(’N(0,1)’)
ここで，「mtlb_」はMATLABのコマンド相当という意味です。

３）次の１次系の周波数応答を片対数グラフを描いてみましょう。

次のコマンドを与えてください。
–> w=logspace(-1,1);
–> ga=20*log10(sqrt(1+w.^2).^(-1));
–> plot2d(w,ga,logflag=’ln’)
–> mtlb_grid

[8] プログラミング
これまでは対話型入力を行ってきましたが，一連のコマンドをエディタを用いてあらかじめ編集しておいて一括処理する，すなわちscilabでのプログラミングについて学びます。まず，白紙を示すアイコンをクリックして，エディタscipadを起動してください。

１） 1から9までの奇数の和を求める次のプログラムを入力し，ファイル名ex1.sceでセーブします。
//ex1.sce
//—–
s=0;
for i=1:2:9, s=s+i; end
disp(s,’sum=’)
//—–
//eof
scipadのexecuteコマンドをクリックして実行します。答えは25のはずです。

２）マシンイプシロン(machine epsilon)と呼ばれる特別な定数を求めてみましょう。次のプログラムをファイル名ex2.sceでセーブします。
//ex2.sce
//—–
s=1;
while 1+s>1, s=s/2; end
s=s*2;
disp(s,’eps=’),
//—–
//eof
scipadのexecuteコマンドをクリックして実行します。epsは次の%epsと等しくなります。
–-> %eps
次を実行してみてください。
–> 1+%eps/2==1
すなわち，
マシンイプシロン%eps=2^{-k}は，1+2^{-k-1}>1が成り立たなくなる最小のkを用いて定義されます。浮動小数点による数値計算では，1+%eps=1となる正数が存在することに注意してください。

３）次は，if文を使った例です。次のプログラムをファイル名ex3.sceでセーブします。
//ex3.sce
//—–
x=input(’x= ‘);
if imag(x)~=0, disp(’complex number’)
elseif x>0, disp(’positive real number’)
elseif x<0, disp(’negative real number’)
else disp(’zero’)
end
//—–
//eof
scipadのexecuteコマンドをクリックして実行します。

４）関数の例として，行列の階数を計算するものを示しましょう。次のプログラムをファイル名rank2.sceでセーブします。
//rank2.sce
//—–
function r=rank2(A)
s=svd(A); tol=max(size(A))*s(1)*%eps; r=sum(s>tol);
endfunction
//—–
//eof
このとき，次を入力してください。
–> exec(‘rank2.sce’)
–> r=rank2([1 2;3 4])

５） 次の微分方程式の解を求めることを考えます。

次のプログラムをファイル名ex4.sceでセーブします。
//ex4.sce
//—–
function dx=f(t,x), dx=-x+sin(10*t); endfunction
x0=1; t0=0; t=0:0.01:5;
x=ode(x0,t0,t,f);
plot(t,x), mtlb_grid
//—–
//eof
scipadのexecuteコマンドをクリックして実行します。

[1] 行列データの入力 　
１）サイズ２×２の行列

を定義するために、次を入力してみます。
>> A=[1 2;3 4]
ここで、行列データは[ ]で囲み、要素の区切りはスペースまたはカンマ、行替えはセミコロン；を用いることに注意してください。次のように最後に；を置くと、出力が抑制されます。
>> A=[1 2;3 4];
すでに入力した行列データへのアクセスは、次のように行います。
>> A
また、特定の要素へのアクセスや修正は、次のように行います。
>> A(2,1)
>> A(2,1)=-5

２）２次の単位行列

は、次により入力できます。
>> B=eye(2,2)
便利なのは、次のように異なる行数と列数が許されることです。
>> B=eye(2,3)
これは、次のサイズ２×３の行列

の定義を意味します。

３）サイズ３×２の零行列

は、次により定義できます。
>> C=zeros(3,2)

４）３次の対角行列

は、次により定義できます。
>> D=diag([1 2 3])
すなわち、ベクトルにdiagを作用させているわけですが、行列にdiagを作用させ、対角成分を抽出することもできます。
>> d=diag(D)

５）行列A,B,C,Dを小行列としてもつブロック行列

を定義するためには、次のように入力します。
>> E=[A B;C D]

６）サイズ２×２の複素行列

も、次により定義できます。
>> F=[1+i, 2+3*i;3+2*i, 4+4*i]
ここで、iは虚数単位として定義されています。もちろん再定義可能です。

７）MATLABでは、空行列を定義できます。
>> G=[]

８）すべての要素が1である行列

は、次により定義できます。
>> H=ones(2,2)

[2] 行列データの管理
１）現時点でどのような行列を定義したかを調べるためには、次のように入力します。
>> who
行列のザイズを合わせて表示するには、次のように入力します。
>> whos
また、たとえば入力した行列データdを消去するためには、次のように入力します。
>>clear d
すべてのデータを消去するときは、次のように入力します。
>>clear

２）行列データEのサイズを調べるには、次のように入力します。
>> [m,n]=size(E)

３）浮動小数点表示を行うためには、次のように入力します。
>> format short e
これを固定小数点表示に戻すためには、次のように入力します。
>> format

４）カレントディレクトリのチェックを行うためには、次のコマンドが使えます
>> pwd
>> ls
カレントディレクトリの変更のためには、次のコマンドを与えます。
>> cd dname

５）メモリ上のデータのセーブとロードのためには、次のコマンドを与えます。
>> save filename
>> load filename

[3] コロン記法
１）まず、次を入力してみてください。
>> h=1:3
これは、「form 1 to 3」を意味します。すなわちサイズ1×5の行列h=[1 2 3]が生成されます。コロン「:」はtoの意味で使われ、colon notationと呼ばれています。

２）それでは、次はどうでしょう。
>> h=0:0.5:3
これは、「form 1 to 3 by 0.5」を意味します。すなわち、２つのコロンで挟まれた0.5は増分を意味し、サイズ1×5の行列h=[1 1.5 2 2.5 3]が生成されます。ちなみに、h=1:3はh=1:1:3と同じと考えておきましょう。

３）それでは、次はどうでしょう。
>> h=0:-2
これは、h=1:1:-2の意味になりますが、1から-2まで、増分1では到達できないので、空行列となります。

[4] 小行列の抽出
１）コロン記法の利点は，行列の添え字部分に適用できることにあります。たとえば，行列Eの(2,3)要素には
>> E(2,3)
でアクセスできるのですが，この2と3は，スカラーである必要はなく，ベクトルが使えます。たとえば，次を確かめてください。
>> E([1 3],: )
これは第１行と弟２行からなるサイズ2×5の小行列が取り出されることに注意してください。列を指定する「：」はすべての列を意味しています。

２）次はどうでしょう。
>> E(:,2:4 )
ここで、2:4は[2 3 4]というベクトルでしたよね。第2～4列からなるサイズ5×3の小行列が取り出されることに注意してください。行を指定する「：」はすべての行を意味しています。

３)それでは，次はどうでしょう。
>> E([1 3],2:4 )

[5] 行列の分割
１）いろいろな応用では、ある行列を分割する必要が出てきます。これは小行列の抽出の観点から、たとえば次のようにできます。
>> [m,n]=size(E); i=2; j=2;
>> A=E(1:i,1:j);
>> B=E(1:i,j+1:n);
>> C=E(i+1:m,1:j);
>> D=E(i+1:m,j+1:n);
ここで、i=0のときは1:i=[]、i=mのときはi+1:m=[]などに注意してください。

[6] 行列演算
いま、行列Aが次のように定義されていることを確認してください。

また、行列Bを新しく定義します。
>> B=eye(A)

１）行列A,Bの和、差、乗算は次のように計算できます。
>> X=A+B
>> X=A-B
>> X=A*B

２）行列Aが正則のとき、その逆行列は
>> X=inv(A)
で計算されます。しかし、これは逆行列の要素が欲しいとき以外は使わないようにしましょう。
多くの場合、逆行列は次の連立一次方程式

または

を解くときに用いますが、MATLABでは、次のように計算します。
>> X=A\B
>> X=B/A
それぞれ左からの割り算、右からの割り算と呼ばれます。
これは数値的に安定な数値計算アルゴリズムを得るためは直交行列だけの演算ですませることが必要だからです。

３）行列Aのべき乗と転置共役は次のように計算でされます。
>> X=A^2
>> X=A’

４） それでは、次の演算結果と比較してみましょう。
>> X=A.+B
>> X=A.-B
>> X=A.*B
>> X=A.\B
>> X=B./A
>> X=A.^2
>> X=A.’
すなわち、演算子の前に「ドット．」をおくと、要素ごとの演算やただの転置になります。

５）次に、組み込み関数としては、次が使えます。
sin,cos,tan,asin,acos,atan,sinh,cosh,tanh,asinh,acosh,atanh,sqrt,exp,log,log10,abs,real,imag

６）行列関数としては次が準備されています。
>> X=expm(A)
>> X=norm(A)
>> X=rank(A)
>> X=det(A)
ぞれぞれ、行列指数関数、ノルム、階数、行列式を計算します。

７）また、固有値問題を解くには次の関数を用います。
–>[V,R]=eig(A)
単に固有値だけを求めるのであれば
–>r=eig(A)
でＯＫです。

８）さらに、特異値問題を解くには次の関数を用います。
–>[U,S,V]=svd(A)
単に特異値だけを求めるのであれば
–>s=svd(A)
でＯＫです。

９）多項式との掛け算は、次のように行います。
–>r=convol([1 1],[1 2])

１０） いま、次のベクトルを定義します。
–>x=[3 1 5 4 2]
このとき、次はxの要素を小さい順番に並べ替えます。
–>[y,i]=sort(x)
yがソーティングされた結果、iが元のどの位置にあったかを示すインデックスです。たとえば
–>x（i)
としてみるとyと同じ結果が出ます。

１１）次は、ベクトルの要素和、最大値、最小値を求める関数です。
–>y=sum(x)
–>y=max(x)
–>y=min(x)

[7] 関数のグラフ
１）次の関数のグラフを描いてみます。

次のコマンドを与えてください。
>> x=-3:0.1:3;
>> y=1/sqrt(2*pi)*exp(-x.*x/2)；
>> plot(x,y)
ここで，なぜx*xでなく，x.*xとしているか考えてみてください。またpiはとして定義されています。

２）描画範囲（-3<=x<=3, 0<=ｙ<=0.4）を指定し，グリッドを描画するには，次のようなコマンドを追加します。
>> grid
>> axis([-3 3 0 0.5])
>> xtitle(’N(0,1)’)

３） 次の１次系の周波数応答を片対数グラフび描いてみましょう。

次のコマンドを与えてください。
>> w=logspace(-1,1);
>> ga=20*log10(sqrt(1+w.^2).^(-1));
>> semilogx(w,ga)
>> grid

[8] プログラミング
これまでは対話型入力を行ってきましたが，一連のコマンドをエディタを用いてあらかじめ編集しておいて一括処理する，すなわちMATLABでのプログラミングについて学びます。まず，新規スクリプトを示すアイコンをクリックして，エディタを起動してください。

１） 1から9までの奇数の和を求める次のプログラムを入力し，ファイル名ex1.mでセーブします。
//ex1.m
//—–
s=0;
for i=1:2:9,
s=s+i;
end
disp(s,’sum=’)
//—–
//eof
エディタの実行ボタンをクリックします。答えは25のはずです。

２） マシンイプシロン(machine epsilon)と呼ばれる特別な定数を求めてみましょう。次のプログラムをファイル名ex2.mでセーブします。
//ex2.m
//—–
s=1;
while 1+s>1,
s=s/2;
end
s=s*2;
disp(s,’eps=’),
//—–
//eof
エディタの実行ボタンをクリックします。このsは次のepsと等しくなります。
>> eps
次を実行してみてください。
>> 1+eps/2==1
すなわち，
マシンイプシロンeps=a^{-k}は，1+a^{-k-1}>1が成り立たなくなる最小のkを用いて定義されます。浮動小数点による数値計算では，1+eps=1となる正数が存在することに注意してください。

３）次は，if文を使った例です。次のプログラムをファイル名ex3.mでセーブします。
//ex3.m
//—–
x=input(’x= ‘);
if imag(x)~=0,
disp(’complex number’)
elseif x>0,
disp(’positive real number’)
elseif x<0,
disp(’negative real number’)
else
disp(’zero’)
end
//—–
//eof
エディタの実行ボタンをクリックします。。

４）関数の例として，行列の階数を計算するものを示しましょう。次のプログラムをファイル名rank2.mでセーブします。
//rank2.m
//—–
function r=rank2(A)
s=svd(A);
tol=max(size(A))*s(1)*eps; r=sum(s>tol);
endfunction
//—–
//eof
このとき，次を入力してください。
>> r=rank([1 2;3 4])

５） 次の微分方程式の解を求めることを考えます。

次のプログラムをファイル名ex4.mでセーブします。
//ex4.m
//—–
function dx=f(t,x),dx=-x+sin(10*t), endfunction
x0=1; t0=0;
t=0:0.01:5;
x=ode(x0,t0,t,f);
plot(t,x),
mtlb_grid
//—–
//eof
エディタの実行ボタンをクリックします。

制御系CADに関わる数値計算では実行列の特異値分解(Singular-Value Decomposition, SVD)を多用しますが、データ駆動分野の計算でも基盤技術となっています。

●いまデータは次の複素行列にまとめられているとします。

ここで列ベクトルはn次元数ベクトルですが、データ駆動分野では、nの値は数個ではなく、数千、数万のオーダーになります。

●をサイズの複素行列（）とします。このとき、ユニタリ行列とが存在して

が成り立ちます（）。ここで、実行列は次のように表されます。

MATLABのコマンドでは、次のように求めます。

>> [U,S,V]=svd(X)

●いまとします。このとき(2)は次式となります。

MATLABのコマンドでは、次のように求めます。

>> [U1,S1,V]=svd(X,’econ’)

(2)の場合はは大規模な行列となりますが、(3)の場合はスリムな行列となりますので、Economic SVDと呼ぶことがあります。

●いま実効階数をとします。すなわち微小なに対して

とします。このとき(3)から次式のように近似できます。

●(2.1)、(3.1)、(5.1)の関係はダイアディック形式を用いて次のように表されます。

●相関行列またはは、(3.1)より、次式のように表されます。

これらより

すなわち、非零の特異値は相関行列またはの固有値の正の平方根です。もしの場合はの特異値はの固有値の絶対値となります。これはスカラの場合、次式を意味しています。

データ駆動分野では、nの値は数個ではなく、数千、数万のオーダーになります。一方、ｍの値はそのように大きな値とはなりません。したがって、(8.2)の小規模な固有値問題を解いてとを求め、(3.1)に基づいて、(8.1)の大規模な固有値問題の固有ベクトルの一部を、次式により求めることが行われます。

(5.1)に基づく場合は次式となります。

このような手法はスナップショットと呼ばれています。

●観測データを行ベクトルとしてもつを考えます。

ここで、回の観測が行われ、各観測では個のデータを得るものとしています。これから

を引いた行列の特異値分解を

とします。このとき、共分散行列は

のように表されます。すなわち共分散行列の主成分ベクトルと、その方向に沿う不変分散値が、行列の特異値分解から得られることに留意します。

補遺：出力FB型追従SMI制御…Homework

[1] 定値外乱を受ける制御対象

の出力を、次のコマンド（定値目標）

に追従させることを考えます。そのために、積分動作

を考え、次の拡大系を構成します。

定常状態では

を得ます(,,は定数ベクトル)。

●さて、関係式

を用いて、偏差系

を得ます。これはSM標準形となっていることに注意して、SM制御系を設計します。

●スイッチング関数として、次式を考えます。

(15)に対して、座標変換

を行って、次式を得ます。

以下では、が安定行列となるようにスイッチング関数が選ばれていると仮定します。

●このとき、スライディングモード制御則（SM制御則、SMC則）

を、２次安定性

すなわち

が成り立つように決定します（, , ）。

可到達性の検討

等価制御は

のように得られます。(20)の第１項は、この等価制御をベースして

のように構成します（は安定行列）。このとき閉ループ系は次式で与えられます。

すなわち

ここで、は安定行列なので

を満たすを選ぶことができます。これを用いて

と選びます（は定数）。このとき次式が成り立ちます。

スライディングモードの検討

は安定行列なので

を満たすを選ぶことができます。

積分動作をもつSMC

上で求めた偏差系E3に対するSMCは次式で与えられました。

これらを積分して、制御対象(1)に対する積分動作をもつSMCを導出します。

まず(32)は(10)を用いて次式のように書けます。

これを積分して

次に(33)は(10)を用いて次式のように書けます。

これを積分すれば

●

for i=1:N, for j=1:N
Mqq(i,j)=m_y(i,j);
Mqp(i,j)=0;
Mpq(i,j)=0;
Mpp(i,j)=m_z(i,j);
for l=1:N, for k=1:N
Mqq(i,j)=Mqq(i,j)+F_y(i,l,k,j)*q(l)*q(k);
Mqp(i,j)=Mqp(i,j)+N_y(i,l,k,j)*q(l)*p(k);
Mpq(i,j)=Mpq(i,j)+N_z(i,l,k,j)*p(l)*q(k);
Mpp(i,j)=Mpp(i,j)+F_z(i,l,k,j)*p(l)*p(k);
end, end, end, end
MM=eye(4*N,4*N);
MM(1:2*N,1:2*N)=[Mqq+chi2*eye(N,N) Mqp;Mpq Mpp+chi2*eye(N,N)];
MM(2*N+1:3*N,1:N)=-c_0*eye(N,N);
MM(3*N+1:4*N,N+1:2*N)=-d_0*eye(N,N);

for i=1:N, for j=1:N
Dqq(i,j)=c_y(i,j)+chi3*c_simp*(abs(V-dy).*f_y(:,i).*f_y(:,j));
Dqp(i,j)=0;
Dpq(i,j)=0;
Dpp(i,j)=c_z(i,j)+chi3*c_simp*(abs(dy).*f_z(:,i).*f_z(:,j));
Dqqa(i,j)=0;
Dppb(i,j)=0;
for l=1:N, for k=1:N
Dqq(i,j)=Dqq(i,j)+D_y(i,l,k,j)*q(l)*q(k)+E_y(i,l,k,j)*q(l)*dq(k);
Dqp(i,j)=Dqp(i,j)+L_y(i,l,k,j)*q(l)*p(k)+M_y(i,l,k,j)*q(l)*dp(k);
Dpq(i,j)=Dpq(i,j)+L_z(i,l,k,j)*p(l)*q(k)+M_z(i,l,k,j)*p(l)*dq(k);
Dpp(i,j)=Dpp(i,j)+D_z(i,l,k,j)*p(l)*p(k)+E_z(i,l,k,j)*p(l)*dp(k);
Dqqa(i,j)=Dqqa(i,j)+c_1*S_y(i,j,k,l)*qa(k)*qa(l);
Dppb(i,j)=Dppb(i,j)+d_1*S_z(i,j,k,l)*pb(k)*pb(l);
end, end, end, end
DD=eye(4*N,4*N);
DD(1:2*N,1:2*N)=[Dqq Dqp;Dpq Dpp];
DD(2*N+1:3*N,2*N+1:3*N)=Dqqa-c_1*eye(N,N);
DD(3*N+1:4*N,3*N+1:4*N)=Dppb-d_1*eye(N,N);

for i=1:N, for j=1:N
Kqq(i,j)=k_y(i,j);
Kpp(i,j)=k_z(i,j);
Kqqa(i,j)=0;
Kqpa(i,j)=0;
Kpqb(i,j)=0;
Kppb(i,j)=0;
for l=1:N, for k=1:N
Kqq(i,j)=Kqq(i,j)+B_y(i,l,k,j)*q(l)*q(k)+H_y(i,l,k,j)*p(l)*p(k);
Kpp(i,j)=Kpp(i,j)+B_z(i,l,k,j)*p(l)*p(k)+H_z(i,l,k,j)*q(l)*q(k);
Kqqa(i,j)=Kqqa(i,j)+chi4*S_y(i,j,k,l)*q(k)*q(l);
Kqpa(i,j)=Kqpa(i,j)-chi5*S_y(i,j,k,l)*q(k)*dp(l);
Kpqb(i,j)=Kpqb(i,j)+chi4*S_z(i,j,k,l)*p(k)*p(l);
Kppb(i,j)=Kppb(i,j)+chi5*S_z(i,j,k,l)*p(k)*dp(l);
end, end, end, end
KK=eye(4*N,4*N);
KK(1:N,1:N)=Kqq;
KK(N+1:2*N,N+1:2*N)=Kpp;
KK(1:2*N,2*N+1:4*N)=-[Kqqa Kqpa;Kpqb Kppb];
KK(2*N+1:3*N,2*N+1:3*N)=c_2*eye(N,N);
KK(3*N+1:4*N,3*N+1:4*N)=d_2*eye(N,N);

f1=zeros(N,1);
for i=1:N
f1(i)=chi3*c_simp*(abs(V-dy).*f_y(:,i).*V);
end

●for

for i=1:N, for j=1:N
m_y(i,j)=c_simp*(f_y(:,i).*f_y(:,j))+G_m*f_y(n_d+1,i)*df_y(n_d+1,j);
end, end
m_z=m_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
E_y(i,j,k,l)=c_simp*(f_y(:,i).*df_y(:,j).*(simp_u*(df_y(:,k).*df_y(:,l))))…
+G_m*f_y(n_d+1,i)*df_y(n_d+1,j)*c_simp*(df_y(:,k).*df_y(:,l))…
-c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_b*(simp_u*(df_y(:,k).*df_y(:,l)))))…
-G_m*c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_u*(df_y(:,k).*df_y(:,l))));
end, end, end, end
E_z=E_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
F_y(i,j,k,l)=E_y(i,j,k,l);
end, end, end, end
F_z=F_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
M_y(i,j,k,l)=c_simp*(f_y(:,i).*df_y(:,j).*(simp_u*(df_z(:,k).*df_z(:,l))))…
+G_m*f_y(n_d+1,i)*df_y(n_d+1,j)*c_simp*(df_z(:,k).*df_z(:,l))…
-c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_b*(simp_u*(df_z(:,k).*df_z(:,l)))))…
-G_m*c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_u*(df_z(:,k).*df_z(:,l))));
end, end, end, end
M_z=M_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
N_y(i,j,k,l)=c_simp*(f_y(:,i).*df_y(:,j).*(simp_u*(df_z(:,k).*df_z(:,l))))…
+G_m*f_y(n_d+1,i)*df_y(n_d+1,j)*c_simp*(df_z(:,k).*df_z(:,l))…
-c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_b*(simp_u*(df_z(:,k).*df_z(:,l)))))…
-G_m*c_simp*(f_y(:,i).*ddf_y(:,j).*(simp_u*(df_z(:,k).*df_z(:,l))))…
+c_simp*(f_y(:,i).*ddf_y(:,j).*ddf_z(:,k).*ddf_z(:,l)…
+f_y(:,i).*ddf_y(:,j).*df_z(:,k).*dddf_z(:,l)…
+3*f_y(:,i).*df_y(:,j) .*ddf_z(:,k).*dddf_z(:,l)…
+f_y(:,i).*df_y(:,j) .*df_y(:,k).*ddddf_y(:,l));
end, end, end, end
N_z=N_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
S_y(i,j,k,l)=c_simp*(f_y(:,i).*f_y(:,j).*f_y(:,k).*f_y(:,l));
end, end, end, end
S_z=S_y;

for i=1:N, for j=1:N
c_y(i,j)=2*sqrt(beta)*c_simp*(U.*f_y(:,i).*df_y(:,j));
end, end
c_z=c_y;

for i=1:N, for j=1:N
k_y_0(i,j)=c_simp*(gamma*f_y(:,i).*df_y(:,j))+gamma*G_p*f_y(n_d+1,i).*df_y(n_d+1,j)…
-c_simp*(gamma*(1-xi+G_p))+c_simp*(f_y(:,i).*ddddf_y(:,j));
end, end

for i=1:N, for j=1:N
k_y(i,j)= k_y_0(i,j)+sqrt(beta)*c_simp*(dU.*(1-xi).*f_y(:,i).*ddf_y(:,j))…
+c_simp*(U.^2.*f_y(:,i).*ddf_y(:,j));
end, end
k_z=k_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
B_y_0(i,j,k,l)=1/2*gamma*c_simp*(f_y(:,i).*df_y(:,j).*df_y(:,k).*df_y(:,l))…
+1/2*gamma*G_p*f_y(n_d+1,i).*df_y(n_d+1,j).*df_y(n_d+1,k).*df_y(n_d+1,l)…
-3/2*c_simp*(gamma*(1-xi+G_p))…
+c_simp*(f_y(:,i).*ddf_y(:,j).*ddf_y(:,k).*ddf_y(:,l)…
+4*f_y(:,i).*df_y(:,j) .*ddf_y(:,k).*dddf_y(:,l)…
+f_y(:,i).*ddf_y(:,j).*ddf_y(:,k).*ddddf_y(:,l));
end, end, end, end

for i=1:N, for j=1:N, for k=1:N, for l=1:N
B_y(i,j,k,l)= B_y_0(i,j,k,l)…
+3/2*sqrt(beta)*c_simp*(dU.*(1-xi).*f_y(:,i).*ddf_y(:,j).*df_y(:,k).*df_y(:,l))…
+sqrt(beta)*c_simp*(dU.*f_y(:,i).*ddf_y(:,j).*(simp_b*(df_y(:,k).*df_y(:,l))))…
+c_simp*(U.^2.*(f_y(:,i).*df_y(:,j).*df_y(:,k).*ddf_y(:,l)…
-f_y(:,i).*ddf_y(:,j).*(simp_b*(df_y(:,k).*ddf_y(:,l)))));
end, end, end, end
B_z=B_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
H_y_0(i,j,k,l)=1/2*gamma*c_simp*(f_y(:,i).*df_y(:,j).*df_y(:,k).*df_y(:,l))…
+1/2*gamma*G_p*f_y(n_d+1,i).*df_y(n_d+1,j).*df_y(n_d+1,k).*df_y(n_d+1,l)…
-1/2*c_simp*(gamma*(1-xi+G_p).*f_y(:,i).*ddf_y(:,j).*df_y(:,k).*df_y(:,l))…
-c_simp*(gamma*(1-xi+G_p).*f_y(:,i).*df_y(:,j).*df_z(:,k).*ddf_z(:,l));
end, end, end, end

for i=1:N, for j=1:N, for k=1:N, for l=1:N
H_y(i,j,k,l)= H_y_0(i,j,k,l)…
+1/2*sqrt(beta)*c_simp*(dU.*(1-xi).*f_y(:,i).*ddf_y(:,j).*df_y(:,k).*df_y(:,l)…
+sqrt(beta)*(1-xi).*f_y(:,i).*df_y(:,j).*df_z(:,k).*ddf_z(:,l)…
+sqrt(beta)*f_y(:,i).*ddf_y(:,j).*(simp_b*(df_z(:,k).*df_z(:,l))))…
+c_simp*(U.^2.*(f_y(:,i).*df_y(:,j).*df_z(:,k).*ddf_z(:,l)…
-f_y(:,i).*ddf_y(:,j).*(simp_b*(df_y(:,k).*ddf_y(:,l)))));
end, end, end, end
H_z=H_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
D_y(i,j,k,l)=2*sqrt(beta)*c_simp*(U.*(f_y(:,i).*df_y(:,j).*df_y(:,k).*df_y(:,l)…
-f_y(:,i).*ddf_y(:,j).*(simp_b*(df_y(:,k).*df_y(:,l)))));
end, end, end, end
D_z=D_y;

for i=1:N, for j=1:N, for k=1:N, for l=1:N
L_y(i,j,k,l)=2*sqrt(beta)*c_simp*(U.*(f_y(:,i).*df_y(:,j).*df_z(:,k).*df_z(:,l)…
-f_y(:,i).*ddf_y(:,j).*(simp_b*(df_z(:,k).*df_z(:,l)))));
end, end, end, end
L_z=L_y;