[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 23. Matrices and Linear Algebra

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 23.1 Introduction to Matrices and Linear Algebra

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 23.1.1 Dot

演算子 `.`は非可換乗算とスカラー積を表します。 オペランドが1列行列か1行行列の `a`と `b`の時、 式 `a.b`は `sum (a[i]*b[i], i, 1, length(a))`と同値です。 もし `a`と `b`が複素数でないならこれはスカラー積であり、 `a`と `b`の内積すなわちドット積がコールされます。 `a`と `b`が複素数の時、スカラー積は `conjugate(a).b`として定義されます; `eigen`パッケージの `innerproduct`は複素スカラー積を提供します。

オペランドがもっと一般的な行列の時、積は `a`と `b`の行列積です。

`b`の行数は `a`の列数と等しくなければいけなく、 結果は `a`の行数に等しい行数と `b`の列数に等しい列数を持ちます。

`.`を算術演算子として浮動小数点数の小数点と区別するために どちらかの側にスペースを残す必要があるかもしれません。 例えば `5.e3`は `5000.0`ですが、 `5 . e3`は `5`掛ける `e3`です。

`.`を含む式の整理を支配するいくつかのフラグがあります。 すなわち `dot0nscsimp`, `dot0simp`, `dot1simp`, `dotassoc`, `dotconstrules`, `dotdistrib`, `dotexptsimp`, `dotident`, `dotscrules`。

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 23.1.2 Matrices

行列は速度とメモリ効率を念頭に扱われます。 これは行列を変数に割り当てることは参照を生成することで、行列のコピーでないことを意味します。 もし行列が修正されるなら、その行列への参照すべてが修正されたオブジェクトを指します (これを避ける方法については `copymatrix`を参照してください):

    (%i1) M1:matrix([0,0],[0,0]);
                                [ 0  0 ]
    (%o1)                       [      ]
                                [ 0  0 ]
    (%i2) M2:M1;
                                [ 0  0 ]
    (%o2)                       [      ]
                                [ 0  0 ]
    (%i3) M1[1][1]:2;
    (%o3)                           2
    (%i4) M2;
                                [ 2  0 ]
    (%o4)                       [      ]
                                [ 0  0 ]

行列を入れ子のリストや変換したり逆だったりは以下のようにします:

    (%i1) l:[[1,2],[3,4]];
    (%o1)                   [[1, 2], [3, 4]]
    (%i2) M1:apply('matrix,l);
                                [ 1  2 ]
    (%o2)                       [      ]
                                [ 3  4 ]
    (%i3) M2:transpose(M1);
                                [ 1  3 ]
    (%o3)                       [      ]
                                [ 2  4 ]
    (%i4) args(M2);
    (%o4)                   [[1, 3], [2, 4]]

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 23.1.3 Vectors

`vect`はベクトル解析のための関数のパッケージです。 `load ("vect")`でこのパッケージをロードし、 `demo ("vect")`でデモンストレーションを表示します。

ベクトル解析パッケージは グラディエント、ダイバージェンス、カール、ラプラシアン演算子と一緒に ドット積やクロス積を含むシンボリックな式を結合したり整理したりすることができます。 これらの演算子の和や積上の分配は、 任意の特定の直交座標系の成分への展開を含む様々な他の展開と同様に、 いくつかのフラグで決定されます。 場のスカラーポテンシャルやベクトルポテンシャルを演繹するための関数もあります。

`vect`パッケージは以下の関数を含みます: `vectorsimp`, `scalefactors`, `express`, `potential`, `vectorpotential`.

デフォルトでは `vect`パッケージはドット演算子 `.`を可換演算子とは宣言しません。 可換ドット演算子 `.`を得るにはコマンド `declare(".", commutative)`を実行しなければいけません。

Categories: Vectors · Share packages · Package vect

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 23.1.4 eigen

パッケージ `eigen`は固有値や固有ベクトルのシンボリックな計算に充てられた いくつかの関数を含みます。 もし `eigenvalues`か `eigenvectors`のどちらかが呼び出されたら、 Maximaはパッケージを自動的にロードします。 パッケージは `load ("eigen")`として明示的にロードすることもできます。

`demo ("eigen")`でこのパッケージの能力のデモンストレーションを表示します。 `batch ("eigen")`は一連の計算の間で ユーザープロンプトなしに同じデモンストレーションを実行します。

`eigen`パッケージの関数は `innerproduct`, `unitvector`, `columnvector`, `gramschmidt`, `eigenvalues`, `eigenvectors`, `uniteigenvectors`, `similaritytransform`です。

Categories: Vectors · Matrices · Share packages · Package eigen

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 23.2 Functions and Variables for Matrices and Linear Algebra

関数: addcol (M, list_1, ..., list_n)

  １つか複数のリスト(または行列)で与えられる列を行列 Mに追加します。

  `addrow`, `append`も参照してください。

  Categories: Matrices

関数: addrow (M, list_1, ..., list_n)

  １つか複数のリスト(または行列)で与えられる行を行列 Mに追加します。

  `addcol`, `append`も参照してください。

  Categories: Matrices

関数: adjoint (M)

  行列 Mの余因子行列を返します。 余因子行列は Mの余因子の行列の転置です。

  Categories: Matrices

関数: augcoefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

  線形方程式系 eqn_1, …, eqn_mの変数 x_1, …, x_nに関する拡大係数行列を返します。 これは、 それぞれの方程式の定数項 (x_1, …, x_nに依存しないそれらの項) に関して隣接した列を持つ係数行列です。

      (%i1) m: [2*x - (a - 1)*y = 5*b, c + b*y + a*x = 0]$
      (%i2) augcoefmatrix (m, [x, y]);
                             [ 2  1 - a  - 5 b ]
      (%o2)                  [                 ]
                             [ a    b      c   ]

  Categories: Linear equations · Matrices

関数: cauchy_matrix
`cauchy_matrix` ([x_1, x_2, …, x_m], [y_1, y_2, …, y_n])
`cauchy_matrix` ([x_1, x_2, …, x_n])

  要素 a[i,j] = 1/(x_i+y_i)を持つ、 `n`掛ける mの Cauchy行列を返します。 `cauchy_matrix`の第二引数はオプションです。 この場合、 Cauchy行列の要素は a[i,j] = 1/(x_i+x_j)です。

  注意: 文献によると Cauchy行列は2つの形式で定義されたものが見られます。 2つ目の定義は a[i,j] = 1/(x_i-y_i)です。

  例:

      (%i1) cauchy_matrix([x1,x2],[y1,y2]);
                            [    1        1    ]
                            [ -------  ------- ]
                            [ y1 + x1  y2 + x1 ]
      (%o1)                 [                  ]
                            [    1        1    ]
                            [ -------  ------- ]
                            [ y1 + x2  y2 + x2 ]

      (%i2) cauchy_matrix([x1,x2]);
                            [   1         1    ]
                            [  ----    ------- ]
                            [  2 x1    x2 + x1 ]
      (%o2)                 [                  ]
                            [    1       1     ]
                            [ -------   ----   ]
                            [ x2 + x1   2 x2   ]

  Categories: Matrices

関数: charpoly (M, x)

  行列 Mの変数 xに関する特性多項式を返します。 すなわち `determinant (M - diagmatrix (length (M), x))`です。

      (%i1) a: matrix ([3, 1], [2, 4]);
                                  [ 3  1 ]
      (%o1)                       [      ]
                                  [ 2  4 ]
      (%i2) expand (charpoly (a, lambda));
                                 2
      (%o2)                lambda  - 7 lambda + 10
      (%i3) (programmode: true, solve (%));
      (%o3)               [lambda = 5, lambda = 2]
      (%i4) matrix ([x1], [x2]);
                                   [ x1 ]
      (%o4)                        [    ]
                                   [ x2 ]
      (%i5) ev (a . % - lambda*%, %th(2)[1]);
                                [ x2 - 2 x1 ]
      (%o5)                     [           ]
                                [ 2 x1 - x2 ]
      (%i6) %[1, 1] = 0;
      (%o6)                     x2 - 2 x1 = 0
      (%i7) x2^2 + x1^2 = 1;
                                  2     2
      (%o7)                     x2  + x1  = 1
      (%i8) solve ([%th(2), %], [x1, x2]);
                        1               2
      (%o8) [[x1 = - -------, x2 = - -------],
                     sqrt(5)         sqrt(5)

                                                   1             2
                                          [x1 = -------, x2 = -------]]
                                                sqrt(5)       sqrt(5)

  Categories: Matrices

関数: coefmatrix ([eqn_1, …, eqn_m], [x_1, …, x_n])

  線形方程式系 eqn_1, …, eqn_mの変数 x_1, …, x_nに関する係数行列を返します。

      (%i1) coefmatrix([2*x-(a-1)*y+5*b = 0, b*y+a*x = 3], [x,y]);
                                       [ 2  1 - a ]
      (%o1)                            [          ]
                                       [ a    b   ]

  Categories: Linear equations · Matrices

関数: col (M, i)

  行列 Mの i番目の列を返します。 戻り値は行列です。

  Categories: Matrices

関数: columnvector (L)
関数: covect (L)

  リスト Lの要素を含む１列 `length (L)`行の行列を返します。

  `covect`は `columnvector`と同義です。

  `load ("eigen")`でこの関数をロードします。

  もしこのパッケージの関数の出力の一部を行列計算で使いたいなら、これが役に立ちます。

  例:

      (%i1) load ("eigen")$
      Warning - you are redefining the Macsyma function eigenvalues
      Warning - you are redefining the Macsyma function eigenvectors
      (%i2) columnvector ([aa, bb, cc, dd]);
                                   [ aa ]
                                   [    ]
                                   [ bb ]
      (%o2)                        [    ]
                                   [ cc ]
                                   [    ]
                                   [ dd ]

  Categories: Matrices

関数: copymatrix (M)

  行列 Mのコピーを返します。 これは Mを要素毎にコピーすること以外では、コピーを作る唯一の方法です。

  `m2: m1`のように１つの行列のもう１つへの割り当ては `m1`をコピーしないことに注意してください。 割り当て `m2 [i,j]: x`または `setelmx (x, i, j, m2`は `m1 [i,j]`も変更します。 `copymatrix`を使ってコピーを生成し、割り当てを使うことは 別個の変更されたコピーを生成します。

  Categories: Matrices

関数: determinant (M)

  Mの行列式をガウスの消去法と似た方法で計算します。

  結果の形式はスイッチ `ratmx`の設定に依ります。

  スイッチ `ratmx`と `sparse`がともに `true`の時コールされる、 粗な行列式を計算するための特殊なルーチンがあります。

  Categories: Matrices

オプション変数: detout

  デフォルト値: `false`

  `detout`が `true`の時、 逆行列が計算される行列の行列式が逆行列から因子として外に出されます。

  このスイッチが効果を持つには `doallmxops`と `doscmxops`は `false`でなければいけません。 (それらの記述を参照してください。) 代わりにこの２つを正しく設定する `ev`にこのスイッチを与えるという方法もあります。

  例:

      (%i1) m: matrix ([a, b], [c, d]);
                                  [ a  b ]
      (%o1)                       [      ]
                                  [ c  d ]
      (%i2) detout: true$
      (%i3) doallmxops: false$
      (%i4) doscmxops: false$
      (%i5) invert (m);
                                [  d   - b ]
                                [          ]
                                [ - c   a  ]
      (%o5)                     ------------
                                 a d - b c

  Categories: Matrices · Evaluation flags

関数: diagmatrix (n, x)

  対角要素すべてが xに等しくて、 サイズが n掛ける nの対角線行列を返します。 `diagmatrix (n, 1)`は (`ident (n)`と同じように)単位行列を返します。

  nは整数に評価されなければいけなく、そうでないなら `diagmatrix`はエラーメッセージを出力します。

  xは別の行列を含む、任意の種類の式を取り得ます もし xが行列ならそれはコピーされません; 対角要素すべては同じインスタンス xを参照します。

  Categories: Matrices

オプション変数: doallmxops

  デフォルト値: `true`

  `doallmxops`が `true`の時 行列に関係する演算すべてが実行されます。 `false`の時、個々の `dot`スイッチの設定がどの演算を実行するか決めます。

  Categories: Matrices

オプション変数: domxexpt

  デフォルト値: `true`

  `domxexpt`が `true`の時、 行列の指数関数 `exp (M)`―ただしMは行列― は、要素 `[i,j]`が `exp (m[i,j])`に等しい行列として解釈されます。

  そうでないなら `exp (M)`は `exp (ev(M))`に評価されます。

  `domxexpt`は形式 `base^power`の式すべてに影響します。 ここで、 baseはスカラーまたは定数と仮定された式、 powerはリストまたは行列です。

  例:

      (%i1) m: matrix ([1, %i], [a+b, %pi]);
                               [   1    %i  ]
      (%o1)                    [            ]
                               [ b + a  %pi ]
      (%i2) domxexpt: false$
      (%i3) (1 - c)^m;
                                   [   1    %i  ]
                                   [            ]
                                   [ b + a  %pi ]
      (%o3)                 (1 - c)
      (%i4) domxexpt: true$
      (%i5) (1 - c)^m;
                        [                      %i  ]
                        [    1 - c      (1 - c)    ]
      (%o5)             [                          ]
                        [        b + a         %pi ]
                        [ (1 - c)       (1 - c)    ]

  Categories: Matrices

オプション変数: domxmxops

  デフォルト値: `true`

  `domxmxops`が `true`の時、行列-行列演算、行列-リスト演算すべてが実行されます (しかし、スカラー-行列演算は実行されません); もしこのスイッチが `false`なら演算は実行されません。

  Categories: Matrices

オプション変数: domxnctimes

  デフォルト値: `false`

  `domxnctimes`が `true`の時、行列の非可換積が実行されます。

  Categories: Matrices

オプション変数: dontfactor

  デフォルト値: `[]`

  ある変数に関する因数分解が起こらないよう、 `dontfactor`をその変数のリストに設定することができます。 (リストは初期には空です。) 標準有理式(CRE)形で仮定される変数順序に従って `dontfactor`リスト上のそれらよりも重要でない変数に関しても 因数分解は行われなくなります。

  Categories: Expressions

オプション変数: doscmxops

  デフォルト値: `false`

  `doscmxops`が `true`の時、スカラー-行列演算が実行されます。

  Categories: Matrices

オプション変数: doscmxplus

  デフォルト値: `false`

  `doscmxplus`が `true`の時、スカラー-行列演算は行列の結果をもたらします。 このスイッチは `doallmxops`の下に包括されません。

  Categories: Matrices

オプション変数: dot0nscsimp

  デフォルト値: `true`

  `dot0nscsimp`が `true`の時、 ゼロと非スカラー項の非可換積は可換積に整理されます。

  Categories: Simplification flags and variables

オプション変数: dot0simp

  デフォルト値: `true`

  `dot0simp`が `true`の時、 ゼロとスカラー項の非可換積は可換積に整理されます。

  Categories: Simplification flags and variables

オプション変数: dot1simp

  デフォルト値: `true`

  `dot1simp`が `true`の時、 １ともう１つの項の非可換積は可換積に整理されます。

  Categories: Simplification flags and variables

オプション変数: dotassoc

  デフォルト値: `true`

  `dotassoc`が `true`の時、式 `(A.B).C`は `A.(B.C)`に整理されます。

  Categories: Simplification flags and variables

オプション変数: dotconstrules

  デフォルト値: `true`

  `dotconstrules`が `true`の時、 定数ともう１つの項の非可換積は可換積に整理されます。 このフラグをオンにすることは事実上、 `dot1simp`はもちろん `dot0simp`, `dot0nscsimp`もオンにします。

  Categories: Simplification flags and variables

オプション変数: dotdistrib

  デフォルト値: `false`

  `dotdistrib`が `true`の時、 式 `A.(B + C)`は `A.B + A.C`に整理されます。

  Categories: Simplification flags and variables

オプション変数: dotexptsimp

  デフォルト値: `true`

  `dotexptsimp`が `true`の時、 式 `A.A`は `A^^2`に整理されます。

  Categories: Simplification flags and variables

オプション変数: dotident

  デフォルト値: 1

  `dotident`は `X^^0`が返す値です。

  Categories: Simplification flags and variables

オプション変数: dotscrules

  デフォルト値: `false`

  `dotscrules`が `true`の時、 式 `A.SC`または `SC.A`は `SC*A`に整理され、 `A.(SC*B)`は `SC*(A.B)`に整理されます。

  Categories: Simplification flags and variables

関数: echelon (M)

  ガウスの消去法で生成される行列 Mの階段形を返します。 階段形は Mから初等的な行演算によって計算されます。 それぞれの行の最初の非ゼロ要素が１で、 その要素の下の列要素がすべてゼロであるような行列です。

  `triangularize`もガウスの消去法を実行しますが、 それぞれの行の先頭の非ゼロ要素を規格化しません。

  `lu_factor`と `cholesky`は三角行列をもたらす他の関数です。

      (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                             [  3   7  aa  bb ]
                             [                ]
      (%o1)                  [ - 1  8  5   2  ]
                             [                ]
                             [  9   2  11  4  ]
      (%i2) echelon (M);
                        [ 1  - 8  - 5      - 2     ]
                        [                          ]
                        [         28       11      ]
                        [ 0   1   --       --      ]
      (%o2)             [         37       37      ]
                        [                          ]
                        [              37 bb - 119 ]
                        [ 0   0    1   ----------- ]
                        [              37 aa - 313 ]

  Categories: Linear equations · Matrices

関数: eigenvalues (M)
関数: eivals (M)

  行列 Mの固有値を含む２つのリストのリストを返します。 戻り値の最初の部分リストは行列の固有値のリストで、 二番目の部分リストは固有値の重複度のリストです。二つのリスト乃要素は順に対応しています。

  `eivals`は `eigenvalues`と同義です。

  `eigenvalues`は行列の特性多項式の根を見つけるために、関数 `solve`をコールします。 時々、`solve`は多項式の根を見つけられないかもしれません; その場合、このパッケージの (`innerproduct`, `unitvector`, `columnvector`, `gramschmidt`を除いた)いくつかの他の関数はうまく動かないでしょう。 時々、 `solve`は多項式の根の部分集合のみを見つけるかもしれません。 多項式の因数分解が5次以上の多項式を含む時これが起こりえます。 そんな場合、警告メッセージが表示され、見つかった根と対応する重複度を返します。

  いくつかの場合、 `solve`が見つける固有値は複雑な式かもしれません。 (`solve`が実数とわかっている固有値について 見てもすぐにはわからない実数式を返す時、これが起こることがあります。) 他のいくつかの関数を使って固有値を整理することが可能なことがあります。

  パッケージ`eigen.mac`は、 `eigenvalues`や `eigenvectors`が参照された時、 自動的にロードされます。 もし `eigen.mac`がまだロードされていないなら、 `load ("eigen")`はそれをロードします。 ロードした後はパッケージの中の関数と変数すべてが利用可能です。

  Categories: Package eigen

関数: eigenvectors (M)
関数: eivects (M)

  行列 Mの固有ベクトルを計算します。 戻り値は２つの要素のリストです。 一番目のものは Mの固有値のリストと固有値の重複度のリストです。 二番目のものは固有ベクトルのリストのリストです。 固有値それぞれに対して固有ベクトルのリストが１つあります。 それぞれのリストには固有ベクトルが１つの時も複数の時もあります。

  `eivects`は `eigenvectors`と同義です。

  パッケージ `eigen.mac`は、 `eigenvalues`や `eigenvectors`が参照された時、 自動的にロードされます。 もし `eigen.mac`がまだロードされていないなら、 `load ("eigen")`はそれをロードします。 ロードした後はパッケージの中の関数と変数すべてが利用可能です。

  `eigenvectors`は固有値を得るために内部的に `eigenvalues`を呼び出しことに注意してください。 だから、 `eigenvalues`がすべての固有値の部分集合を返す時、 `eigenvectors`は `eigenvalues`と同様の警告を表示して、 すべての固有ベクトルの対応する部分集合を返します。

  この関数に影響するフラグは以下の通りです:

  `nondiagonalizable`は、 `eigenvectors`が戻った後、行列が対角化不可能か可能かに依って `true`か `false`に設定されます。

  `hermitianmatrix`が `true`の時、 エルミート行列の縮退した固有ベクトルが グラム-シュミットアルゴリズムを使って直交化されるようにします。

  `knowneigvals`が `true`の時、 `eigen`パッケージは、 行列の固有値がユーザーに知られていて、グローバル名 `listeigvals`の下に記憶されていることを仮定するようにします。 `listeigvals`は出力 `eigenvalues`に似たリストに設定しなければいけません。

  ここで、関数 `algsys`が固有ベクトルについて解くために使われます。 もし固有値がごちゃごちゃしているなら、 `algsys`は時々、解を見つけられないかもしれません。 いくつかの場合、最初に `eigenvalues`コマンドを使って固有値を見つけ、 それらをもっと簡潔な何かに換算するために他の関数を使うことによって、 固有値を整理することが可能かもしれません。 整理に続いて `true`に設定された `knowneigvals`フラグとともに 再び `eigenvectors`をコールすることができます。

  `eigenvalues`も参照してください。

  例:

  固有値１つにただ１つの固有ベクトルを持つ行列。

      (%i1) M1 : matrix ([11, -1], [1, 7]);
                                 [ 11  - 1 ]
      (%o1)                      [         ]
                                 [ 1    7  ]
      (%i2) [vals, vecs] : eigenvectors (M1);
      (%o2) [[[9 - sqrt(3), sqrt(3) + 9], [1, 1]],
                              [[[1, sqrt(3) + 2]], [[1, 2 - sqrt(3)]]]]
      (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
        mult[i] = vals[2][i], vec[i] = vecs[i]);
                             val  = 9 - sqrt(3)
                                1

                                  mult  = 1
                                      1

                          vec  = [[1, sqrt(3) + 2]]
                             1

                             val  = sqrt(3) + 9
                                2

                                  mult  = 1
                                      2

                          vec  = [[1, 2 - sqrt(3)]]
                             2

      (%o3)                         done

  １つの固有値(ここでは2)に２つの固有ベクトルを持つ行列。

      (%i1) M1 : matrix ([0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 2, 0],
                         [0, 0, 0, 2]);
                               [ 0  1  0  0 ]
                               [            ]
                               [ 0  0  0  0 ]
      (%o1)                    [            ]
                               [ 0  0  2  0 ]
                               [            ]
                               [ 0  0  0  2 ]
      (%i2) [vals, vecs] : eigenvectors (M1);
      (%o2) [[[0, 2], [2, 2]], [[[1, 0, 0, 0]],
                                         [[0, 0, 1, 0], [0, 0, 0, 1]]]]
      (%i3) for i thru length (vals[1]) do disp (val[i] = vals[1][i],
        mult[i] = vals[2][i], vec[i] = vecs[i]);
                                  val  = 0
                                     1

                                  mult  = 2
                                      1

                            vec  = [[1, 0, 0, 0]]
                               1

                                  val  = 2
                                     2

                                  mult  = 2
                                      2

                     vec  = [[0, 0, 1, 0], [0, 0, 0, 1]]
                        2

      (%o3)                         done

  Categories: Package eigen

関数: ematrix (m, n, x, i, j)

  値が xの `[i, j]`要素を除いて、すべての要素がゼロの m行 n列行列を返します。

  Categories: Matrices

関数: entermatrix (m, n)

  対話的に要素を読み、 m行 n列行列を返します。

  もし nが mと等しいなら、 Maximaは、行列のタイプ(対角、対称、反対称、一般)の入力を促し、 それぞれの要素の入力を促します。 応答それぞれは、セミコロン `;`かドル記号 `$`で終了させます。

  もし nが mと等しくないなら Maximaはそれぞれの要素の入力を促します。

  要素は任意の式を取り得て、その式は評価されます。 `entermatrix`は引数を評価します。

      (%i1) n: 3$
      (%i2) m: entermatrix (n, n)$

      Is the matrix  1. Diagonal  2. Symmetric  3. Antisymmetric
      4. General
      Answer 1, 2, 3 or 4 :
      1$
      Row 1 Column 1:
      (a+b)^n$
      Row 2 Column 2:
      (a+b)^(n+1)$
      Row 3 Column 3:
      (a+b)^(n+2)$

      Matrix entered.
      (%i3) m;
                      [        3                     ]
                      [ (b + a)      0         0     ]
                      [                              ]
      (%o3)           [                  4           ]
                      [    0      (b + a)      0     ]
                      [                              ]
                      [                            5 ]
                      [    0         0      (b + a)  ]

  Categories: Console interaction · Matrices

関数: genmatrix
`genmatrix` (a, i_2, j_2, i_1, j_1)
`genmatrix` (a, i_2, j_2, i_1)
`genmatrix` (a, i_2, j_2)

  aから生成される行列を返します。 返される行列は、要素 `a[i_1,j_1]`を左上の要素として取り、 `a[i_2,j_2]`を右下の要素として取ります。 ここで、aは、 (`make_array`ではなく `array`が生成する)宣言配列か、 `hashed array`,か、 `memoizing function`か、２つの引数を持つラムダ式のいずれかです。 (`memoizing function`は、他の関数のように `:=`や `define`で生成されますが、 引数は括弧の代わりにカギ括弧でくくられます。)

  もし j_1が省略されたら、 それは i_1と等しいと仮定されます。 もし j_1と i_1両方が省略されたら、 両方とも1と等しいと仮定されます。

  もし配列の選択された要素 `i,j`が未定義なら、 行列はシンボル要素 `a[i,j]`を含みます。

  例:

      (%i1) h [i, j] := 1 / (i + j - 1);
                                          1
      (%o1)                  h     := ---------
                              i, j    i + j - 1
      (%i2) genmatrix (h, 3, 3);
                                 [    1  1 ]
                                 [ 1  -  - ]
                                 [    2  3 ]
                                 [         ]
                                 [ 1  1  1 ]
      (%o2)                      [ -  -  - ]
                                 [ 2  3  4 ]
                                 [         ]
                                 [ 1  1  1 ]
                                 [ -  -  - ]
                                 [ 3  4  5 ]
      (%i3) array (a, fixnum, 2, 2);
      (%o3)                           a
      (%i4) a [1, 1] : %e;
      (%o4)                          %e
      (%i5) a [2, 2] : %pi;
      (%o5)                          %pi
      (%i6) genmatrix (a, 2, 2);
                                 [ %e   0  ]
      (%o6)                      [         ]
                                 [ 0   %pi ]
      (%i7) genmatrix (lambda ([i, j], j - i), 3, 3);
                               [  0    1   2 ]
                               [             ]
      (%o7)                    [ - 1   0   1 ]
                               [             ]
                               [ - 2  - 1  0 ]
      (%i8) genmatrix (B, 2, 2);
                              [ B      B     ]
                              [  1, 1   1, 2 ]
      (%o8)                   [              ]
                              [ B      B     ]
                              [  2, 1   2, 2 ]

  Categories: Matrices

関数: gramschmidt (x)
関数: gramschmidt (x, F)

  xに対してグラム-シュミット直交化アルゴリズムを実行します。 xは行列かリストのリストのいずれかです。 `gramschmidt`は xを変更しません。 もし引数にあるなら `gramschmidt`は Fを内積として使います。 そうでないなら、内積は関数 `innerproduct`です。

  もし xが行列なら、アルゴリズムは xの行に適用されます。 もし xがリストのリストなら、アルゴリズムは部分リストに適用されます。 部分リストは要素数が同じでなければいけません。 いずれの場合も、戻り値はリストのリストです。 この部分リストは互いに直交し、 xと同じ空間を埋めます。 もし xの全範囲の次元が行や部分リストの数より小さいなら、 戻り値の部分リストのいくつかはゼロです。

  中間結果を整理するために、アルゴリズムのそれぞれの段階で `factor`がコールされます。 結果として、戻り値は素因数分解された整数を含みます。

  `load("eigen")`はこの関数をロードします。

  例:

  デフォルトの内積関数を使ったグラム-シュミットアルゴリズム。

      (%i1) load ("eigen")$
      (%i2) x: matrix ([1, 2, 3], [9, 18, 30], [12, 48, 60]);
                               [ 1   2   3  ]
                               [            ]
      (%o2)                    [ 9   18  30 ]
                               [            ]
                               [ 12  48  60 ]
      (%i3) y: gramschmidt (x);
                             2      2            4     3
                            3      3   3 5      2  3  2  3
      (%o3)  [[1, 2, 3], [- ---, - --, ---], [- ----, ----, 0]]
                            2 7    7   2 7       5     5
      (%i4) map (innerproduct, [y[1], y[2], y[3]], [y[2], y[3], y[1]]);
      (%o4)                       [0, 0, 0]

  指定した内積関数を使ったグラム-シュミットアルゴリズム。

      (%i1) load ("eigen")$
      (%i2) ip (f, g) := integrate (f * g, u, a, b);
      (%o2)          ip(f, g) := integrate(f g, u, a, b)
      (%i3) y : gramschmidt([1, sin(u), cos(u)], ip), a= -%pi/2, b=%pi/2;
                                     %pi cos(u) - 2
      (%o3)              [1, sin(u), --------------]
                                          %pi
      (%i4) map (ip, [y[1], y[2], y[3]], [y[2], y[3], y[1]]),
                                                      a= -%pi/2, b=%pi/2;
      (%o4)                       [0, 0, 0]

  Categories: Package eigen

関数: ident (n)

  n行 n列の単位行列を返します。

  Categories: Matrices

関数: innerproduct (x, y)
関数: inprod (x, y)

  xと yの(スカラー積やドット積とも呼ばれる)内積を返します。 xと yは、等しい長さのリストか、ともに等しい長さの1列行列か1行行列です。 戻り値は `conjugate (x) . y`です。 ここで `.`は非可換乗算演算子です。

  `load ("eigen")`はこの関数をロードします。

  `inprod`は `innerproduct`と同義です。

  Categories: Package eigen

関数: invert_by_adjoint (M)

  行列 Mの逆を返します。 逆は随伴法で計算されます。

  `invert`同様、`invert_by_adjoint`は `ratmx`と `detout` フラグを遵守します。

関数: invert (M)

  行列 Mの逆行列を返します。 逆行列はLU分解で計算されます。

  `ratmx`が `true`の時、 Mの要素は標準有理式(CRE)に変換され、 戻り値の要素もまたCREになります。

  `ratmx`が `false`の時、 Mの要素は通常の表現に変換されません。 特に、floatとbigfloatは有理数に変換されません。

  `detout`が `true`の時、 行列式が逆行列から括りだされます。 行列式が逆行列に吸収されるのを抑制するよう、グローバルフラグ `doallmxops`と `doscmxops`は `false`でなければいけません。 `xthru`を使って行列式を逆行列に掛けることができます。

  `invert`は、デフォルトの算術整理を除いて、どんな式整理も逆行列の要素に適用しません。 `ratsimp`と `expand`は加算整理を適用できます。 特に、 Mが多項式要素を持つ時、 `expand(invert(M))`が適しているかもしれません。

  `invert(M)`は `M^^-1`と同値です。

  Categories: Matrices

関数: list_matrix_entries (M)

  行列 Mの要素を含むリストを返します。

  例:

      (%i1) list_matrix_entries(matrix([a,b],[c,d]));
      (%o1)                     [a, b, c, d]

  Categories: Matrices

オプション変数: lmxchar

  デフォルト値: `[`

  `lmxchar`は行列の左区切り記号として表示される文字です。 `rmxchar`も参照してください。

  例:

      (%i1) lmxchar: "|"$
      (%i2) matrix ([a, b, c], [d, e, f], [g, h, i]);
                                 | a  b  c ]
                                 |         ]
      (%o2)                      | d  e  f ]
                                 |         ]
                                 | g  h  i ]

  Categories: Display flags and variables · Matrices

関数: matrix (row_1, ..., row_n)

  行 row_1, ..., row_nを持つ長方形行列を返します。 行それぞれは、式のリストです。 すべての行は同じ長さでなければいけません。

  オペランドが２つの行列、スカラーと行列、行列とスカラーのいずれかの時、 演算 `+` (足し算), `-` (引き算), `*` (掛け算), `/` (割り算)は要素毎に実行されます。 もしオペランドがスカラーと行列、行列とスカラーのいずれかなら、 演算 `^` (べき乗, `**`と同値)は、要素毎に実行されますが、 もしオペランドが２つの行列なら要素毎には実行されません。 `.` (非可換乗算)を含むすべての演算は通常、完全に実行されます。

  行列の掛け算は非可換乗算演算子 `.`で表されます。 対応する非可換べき乗演算子は `^^`です。 行列 `A`に関して、 `A.A = A^^2`であり、 もし存在するなら `A^^-1`は Aの逆行列です。 `A^^-1`は `invert(A)`と同値です。

  ドット演算や行列-リスト演算を含む式の整理を制御するためのスイッチがあります。 それらは、 `doallmxops`, `domxexpt` `domxmxops`, `doscmxops`, `doscmxplus`です。

  行列に関係する付加的なオプションがあります。 それらは以下の通りです: `lmxchar`, `rmxchar`, `ratmx`, `listarith`, `detout`, `scalarmatrix`, `sparse`

  行列を引数として取ったり、行列を戻り値としてもたらしたりするたくさんの関数があります。 `eigenvalues`, `eigenvectors`, `determinant`, `charpoly`, `genmatrix`, `addcol`, `addrow`, `copymatrix`, `transpose`, `echelon`, `rank`を参照してください。

  例:

  - リストからの行列の組み立て。

      (%i1) x: matrix ([17, 3], [-8, 11]);
                                 [ 17   3  ]
      (%o1)                      [         ]
                                 [ - 8  11 ]
      (%i2) y: matrix ([%pi, %e], [a, b]);
                                 [ %pi  %e ]
      (%o2)                      [         ]
                                 [  a   b  ]

  - 足し算、要素毎に。

      (%i3) x + y;
                            [ %pi + 17  %e + 3 ]
      (%o3)                 [                  ]
                            [  a - 8    b + 11 ]

  - 引き算、要素毎に。

      (%i4) x - y;
                            [ 17 - %pi  3 - %e ]
      (%o4)                 [                  ]
                            [ - a - 8   11 - b ]

  - 掛け算。要素毎に。

      (%i5) x * y;
                              [ 17 %pi  3 %e ]
      (%o5)                   [              ]
                              [ - 8 a   11 b ]

  - 割り算。要素毎に。

      (%i6) x / y;
                              [ 17       - 1 ]
                              [ ---  3 %e    ]
                              [ %pi          ]
      (%o6)                   [              ]
                              [   8    11    ]
                              [ - -    --    ]
                              [   a    b     ]

  - 行列のスカラーべき、要素毎に。

      (%i7) x ^ 3;
                               [ 4913    27  ]
      (%o7)                    [             ]
                               [ - 512  1331 ]

  - スカラー基数の行列べき、要素毎に。

      (%i8) exp(y);
                               [   %pi    %e ]
                               [ %e     %e   ]
      (%o8)                    [             ]
                               [    a     b  ]
                               [  %e    %e   ]

  - 行列基数の行列べき。これは要素毎には実行されません。

      (%i9) x ^ y;
                                      [ %pi  %e ]
                                      [         ]
                                      [  a   b  ]
                           [ 17   3  ]
      (%o9)                [         ]
                           [ - 8  11 ]

  - 非可換行列乗算。

      (%i10) x . y;
                        [ 3 a + 17 %pi  3 b + 17 %e ]
      (%o10)            [                           ]
                        [ 11 a - 8 %pi  11 b - 8 %e ]
      (%i11) y . x;
                      [ 17 %pi - 8 %e  3 %pi + 11 %e ]
      (%o11)          [                              ]
                      [  17 a - 8 b     11 b + 3 a   ]

  - 非可換行列べき乗 スカラー基数 bの行列べき Mは、要素毎に実行され、 `b^^m`は `b^m`と同じです。

      (%i12) x ^^ 3;
                              [  3833   1719 ]
      (%o12)                  [              ]
                              [ - 4584  395  ]
      (%i13) %e ^^ y;
                               [   %pi    %e ]
                               [ %e     %e   ]
      (%o13)                   [             ]
                               [    a     b  ]
                               [  %e    %e   ]

  - 行列の-1指数の非可換べき乗は存在するなら、逆行列のことです。

      (%i14) x ^^ -1;
                               [ 11      3  ]
                               [ ---  - --- ]
                               [ 211    211 ]
      (%o14)                   [            ]
                               [  8    17   ]
                               [ ---   ---  ]
                               [ 211   211  ]
      (%i15) x . (x ^^ -1);
                                  [ 1  0 ]
      (%o15)                      [      ]
                                  [ 0  1 ]

  Categories: Matrices

関数: matrixexp
`matrixexp` (M)
`matrixexp` (M, n)
`matrixexp` (M, V)

  行列指数函数 e^(M*V) を計算します。 ベクトル Vの代わりに、数 nを第二引数としてしていすることができます。 もしこの引数が省略されたら、`matrixexp`はそれを `1`で置き換えます。

  行列 Mの行列指数函数は冪級数として表現できます: e^M=sum(M^k/k!,0,inf)

  Categories: Matrices

関数: matrixmap (f, M)

  `f(M[i,j])`に等しい要素 `i,j`を持つ行列を返します。

  `map`, `fullmap`, `fullmapl`, `apply`も参照してください。

  Categories: Matrices

関数: matrixp (expr)

  もし exprが行列なら `true`を返し，そうでないなら `false`を返します。

  Categories: Predicate functions · Matrices

オプション変数: matrix_element_add

  デフォルト値: `+`

  `matrix_element_add`は行列乗算の中で足し算の代わりに呼び出される演算です。 `matrix_element_add`は任意の n項演算子(すなわち、任意の数の引数を扱う関数)に割り当てられます。 割り当てられた値はクォートマークでくくられた演算子の名前か、 関数名かラムダ式を取り得ます。

  `matrix_element_mult`と `matrix_element_transpose`も参照してください。

  例:

      (%i1) matrix_element_add: "*"$
      (%i2) matrix_element_mult: "^"$
      (%i3) aa: matrix ([a, b, c], [d, e, f]);
                                 [ a  b  c ]
      (%o3)                      [         ]
                                 [ d  e  f ]
      (%i4) bb: matrix ([u, v, w], [x, y, z]);
                                 [ u  v  w ]
      (%o4)                      [         ]
                                 [ x  y  z ]
      (%i5) aa . transpose (bb);
                           [  u  v  w   x  y  z ]
                           [ a  b  c   a  b  c  ]
      (%o5)                [                    ]
                           [  u  v  w   x  y  z ]
                           [ d  e  f   d  e  f  ]

  Categories: Matrices

オプション変数: matrix_element_mult

  デフォルト値: `*`

  `matrix_element_mult`は行列乗算の中で掛け算の代わりに呼び出される演算です。 `matrix_element_mult`は任意の二項演算子に割り当てられます。 割り当てられた値はクォートマークでくくられた演算子の名前か、関数名か、 ラムダ式を取り得ます。

  ドット演算子 `.`はいくつかの文脈で役に立つ選択です。

  `matrix_element_add`と `matrix_element_transpose`も参照してください。

  例:

      (%i1) matrix_element_add: lambda ([[x]], sqrt (apply ("+", x)))$
      (%i2) matrix_element_mult: lambda ([x, y], (x - y)^2)$
      (%i3) [a, b, c] . [x, y, z];
                                2          2          2
      (%o3)         sqrt((c - z)  + (b - y)  + (a - x) )
      (%i4) aa: matrix ([a, b, c], [d, e, f]);
                                 [ a  b  c ]
      (%o4)                      [         ]
                                 [ d  e  f ]
      (%i5) bb: matrix ([u, v, w], [x, y, z]);
                                 [ u  v  w ]
      (%o5)                      [         ]
                                 [ x  y  z ]
      (%i6) aa . transpose (bb);
                     [             2          2          2  ]
                     [ sqrt((c - w)  + (b - v)  + (a - u) ) ]
      (%o6)  Col 1 = [                                      ]
                     [             2          2          2  ]
                     [ sqrt((f - w)  + (e - v)  + (d - u) ) ]

                               [             2          2          2  ]
                               [ sqrt((c - z)  + (b - y)  + (a - x) ) ]
                       Col 2 = [                                      ]
                               [             2          2          2  ]
                               [ sqrt((f - z)  + (e - y)  + (d - x) ) ]

  Categories: Matrices

オプション変数: matrix_element_transpose

  デフォルト値: `false`

  `matrix_element_transpose`は、 転置される時、行列のそれぞれの要素に適用される演算です。 `matrix_element_mult`は任意の単項演算子に割り当てられます。 割り当てられた値はクォートマークでくくられた演算子の名前か、 関数名か、ラムダ式を取り得ます。

  `matrix_element_transpose`が `transpose`に等しい時、 `transpose`関数が要素すべてに適用されます。 `matrix_element_transpose`が `nonscalars`に等しい時、 `transpose`関数は非スカラー要素すべてに適用されます。 もしある要素がアトムなら、 `nonscalars`オプションはアトムが宣言された非スカラーの時だけ `transpose`を適用します。 一方、`transpose`オプションはいつも `transpose`を適用します。

  デフォルト値, `false`はいかなる演算も適用しないことを意味します。

  `matrix_element_add`と `matrix_element_mult`も参照してください。

  例:

      (%i1) declare (a, nonscalar)$
      (%i2) transpose ([a, b]);
                              [ transpose(a) ]
      (%o2)                   [              ]
                              [      b       ]
      (%i3) matrix_element_transpose: nonscalars$
      (%i4) transpose ([a, b]);
                              [ transpose(a) ]
      (%o4)                   [              ]
                              [      b       ]
      (%i5) matrix_element_transpose: transpose$
      (%i6) transpose ([a, b]);
                              [ transpose(a) ]
      (%o6)                   [              ]
                              [ transpose(b) ]
      (%i7) matrix_element_transpose: lambda ([x], realpart(x)
            - %i*imagpart(x))$
      (%i8) m: matrix ([1 + 5*%i, 3 - 2*%i], [7*%i, 11]);
                           [ 5 %i + 1  3 - 2 %i ]
      (%o8)                [                    ]
                           [   7 %i       11    ]
      (%i9) transpose (m);
                            [ 1 - 5 %i  - 7 %i ]
      (%o9)                 [                  ]
                            [ 2 %i + 3    11   ]

  Categories: Matrices

関数: mattrace (M)

  正方行列 Mの跡(すなわち、主対角上の要素の和)を返します。

  `mattrace`は `ncharpoly`―Maximaの`charpoly`の代わり― によってコールされます。

  `load ("nchrpl")`はこの関数をロードします。

  Categories: Matrices · Package nchrpl

関数: minor (M, i, j)

  行列 Mの i, j小行列を返します。 すなわち、行 iと列 jを除いた Mです。

  Categories: Matrices

関数: ncharpoly (M, x)

  行列Mの xに関する特性多項式を返します。 これはMaximaの `charpoly`の代わりです。

  `ncharpoly`は与えられた行列のべきの跡を計算することで機能します。 それは特性多項式の根のべきの和に等しいことが知られています。 それらの量から根の対称関数を計算することができます。 それらは特性多項式の係数以上のなにものでもありません。 `charpoly`は、 `x * ident [n] - a`の行列式を形成することで機能します。 このように、 `ncharpoly`は完全に多項式算術を避けるので、 例えば、整数で埋められた大きな密な行列の場合、 `ncharpoly`が勝ります。

  `load ("nchrpl")`はこのファイルをロードします。

  Categories: Matrices · Package nchrpl

関数: newdet (M)

  行列 Mの行列式を ジョンソン-ジェントルマンのtree minorアルゴリズムを使って計算します。 `newdet`はCRE形式で結果を返します。

  Categories: Matrices

関数: permanent (M, n)

  行列 Mのパーマネントを計算します。 パーマネントは行列式のようですが、符号が変わりません。 `permanent`はCRE形式で結果を返します。

  `newdet`も参照してください。

  Categories: Matrices

関数: rank (M)

  行列 Mのランクを計算します。 すなわち、Mの最も大きな非特異な小行列式の次数です。

  もし rankがゼロと同値の行列要素が確かにそうであることを決定することができないなら、 間違った答えを返す可能性があります。

  Categories: Matrices

オプション変数: ratmx

  デフォルト値: `false`

  `ratmx`が `false`の時、 行列要素の表現で行列式と行列の足し算、引き算、掛け算が実行され、 逆行列の結果は一般表現のまま残されます。

  `ratmx`が `true`の時、 上で述べた４つの演算は CRE形式で実行され、逆行列の結果も CRE形式になります。 要素の展開は常に望まれているわけではないですが、 これによって(`ratfac`の設定に依って) 要素が展開されるかもしれないことに注意してください。

  Categories: Matrices · Rational expressions

関数: row (M, i)

  行列 Mのi番目の行を返します。 戻り値は行列です。

  Categories: Matrices

オプション変数: rmxchar

  デフォルト値: `]`

  `rmxchar`は行列の右辺に描かれる文字です。

  `lmxchar`も参照してください。

  Categories: Display flags and variables

オプション変数: scalarmatrixp

  デフォルト値: `true`

  `scalarmatrixp`が `true`の時、 1 x 1行列が行列のドット積を計算した結果として生成される時はいつでも、 スカラーすなわち行列の唯一の要素に整理されます。

  `scalarmatrixp`が`all`の時、 すべての1 x 1行列はスカラーに整理されます。

  `scalarmatrixp`が`false`の時、 1 x 1行列はスカラーに整理されません。

  Categories: Matrices · Simplification flags and variables

関数: scalefactors (coordinatetransform)

  ここで coordinatetransformは形式 [[expression1, expression2, ...], indeterminate1, indeterminat2, ...] に評価されます。また、 indeterminate1, indeterminate2, などは曲線座標変数であり、 直交カーテシアン成分の集合は、 [expression1, expression2, ...]によって、曲線座標を使って与えられます。

  `coordinates`を ベクトル [indeterminate1, indeterminate2,...]に設定し、 `dimension`をこのベクトルの長さに設定します。 SF[1], SF[2], …, SF[DIMENSION]を座標スケールファクタに設定し、 `sfprod`をこれらのスケールファクタの積に設定します。 初期状態では 3次元直交カーテシアン座標に対応して、 `coordinates`は [X, Y, Z]であり、 `dimension`は 3であり、 SF[1]=SF[2]=SF[3]=SFPROD=1です。 式を現在の座標形の物理成分に展開するために形式を利用する関数があります。 (訳注:「形式」の部分、原文自体が欠けています)

  Categories: Package vect

関数: setelmx (x, i, j, M)

  xを行列 Mの(i, j)番目の要素に割り当て、 変わった行列を返します。

  `M [i, j]: x`は同じ効果を持ちますが、 Mの代わりに xを返します。

  Categories: Matrices

関数: similaritytransform (M)
関数: simtran (M)

  `similaritytransform`は行列 `M`の相似変換を計算します。 `uniteigenvectors`コマンドの出力であるリストを返します。 更に、もしフラグ `nondiagonalizable`が `false`なら、 ２つのグローバル行列 `leftmatrix`と `rightmatrix`を計算します。 これらの行列は、 `leftmatrix . M . rightmatrix`が Mの固有値を対角上に持つ対角行列となるという性質を持ちます。 もし `nondiagonalizable`が `true`なら、左右の行列は計算されません。

  もしフラグ `hermitianmatrix`が `true`なら、 `leftmatrix`は `rightmatrix`の転置の複素共役です。 そうでないなら、 `leftmatrix`は `rightmatrix`の逆行列です。

  `rightmatrix`は列が Mの単位固有ベクトルである行列です。 `rightmatrix`を形成可能にするために `similaritytransform`がパッケージの中の他の関数をコールするので、 他のフラグ (`eigenvalues`と `eigenvectors`を参照してください)は同じ効果を持ちます。

  `load ("eigen")`はこの関数をロードします。

  `simtran`は `similaritytransform`と同義です。

  Categories: Package eigen

オプション変数: sparse

  デフォルト値: `false`

  `sparse`が `true`かつ `ratmx`が `true`なら、 `determinant`は粗な行列式を計算するために特別なルーチンを使います。

  Categories: Matrices

関数: submatrix
`submatrix` (i_1, …, i_m, M, j_1, …, j_n)
`submatrix` (i_1, …, i_m, M)
`submatrix` (M, j_1, …, j_n)

  行列 Mから 行 i_1, …, i_mを取り除き、 列 j_1, …, j_nを取り除いた新しい行列を返します。

  Categories: Matrices

関数: transpose (M)

  Mの転置を返します。

  もしMが行列なら、 戻り値は `N[i,j] = M[j,i]`であるような別の行列 Nです。

  もし Mがリストなら、 戻り値は `N[i,1] = M[i]`であるような `length (m)`行1列の行列Nです。

  そうでないなら Mはシンボルで、 戻り値は名詞式 `'transpose (M)`です。

  Categories: Matrices

関数: triangularize (M)

  ガウスの消去法で生成されるような、行列 `M`の右上三角化行列を返します。 それぞれの行の先頭の非ゼロ係数が1に規格化されないことを除いて、 戻り値は `echelon`と同じです。

  三角化行列をもらたす他の関数に `lu_factor`と `cholesky`があります。

      (%i1) M: matrix ([3, 7, aa, bb], [-1, 8, 5, 2], [9, 2, 11, 4]);
                             [  3   7  aa  bb ]
                             [                ]
      (%o1)                  [ - 1  8  5   2  ]
                             [                ]
                             [  9   2  11  4  ]
      (%i2) triangularize (M);
                   [ - 1   8         5            2      ]
                   [                                     ]
      (%o2)        [  0   - 74     - 56         - 22     ]
                   [                                     ]
                   [  0    0    626 - 74 aa  238 - 74 bb ]

  Categories: Linear equations · Matrices

関数: uniteigenvectors (M)
関数: ueivects (M)

  行列 Mの単位固有ベクトルを計算します。 戻り値はリストのリストです。 最初のサブリストは `eigenvalues`コマンドの出力であり、 他のサブリストは固有値それぞれに対応する行列の単位固有ベクトルです。

  `eigenvectors`コマンドでの記述で言及されたフラグはこれに関しても同じ効果を持ちます。

  `knowneigvects`が `true`の時、 行列の固有ベクトルがユーザーに知られていて、グローバル名 `listeigvects`の下に記憶されていることを `eigen`パッケージは仮定します。 `listeigvects`は `eigenvectors`コマンドの出力に似たリストに設定されなければいけません。

  もし `knowneigvects`が `true`に設定されていて、 固有ベクトルのリストが与えられるなら、 フラグ `nondiagonalizable`の設定は正しくないかもしれません。 この場合に該当するなら正しい値に設定してください。 ユーザーがしていることを知っていること、 固有値が適切な次元のベクトル空間を作り出さない行列を対角化しようとはしないことを 作者は仮定しています。

  `load ("eigen")`はこの関数をロードします。

  `ueivects`は `uniteigenvectors`と同義です。

  Categories: Package eigen

関数: unitvector (x)
関数: uvect (x)

  x/norm(x)を返します; これは xと同じ向きの単位ベクトルです。

  `load ("eigen")`はこの関数をロードします。

  `uvect`は `unitvector`と同義です。

  Categories: Package eigen

関数: vectorpotential (givencurl)

  現在の座標系で与えられた回転ベクトルのベクトルポテンシャルを返します。 `potentialzeroloc`が `potential`に対して似たような役割を持ちますが、 等式の左辺側の次数は座標変数の巡回置換でなければいけません。

  Categories: Package vect

関数: vectorsimp (expr)

  以下のグローバルフラグに従って整理と展開を適用します:

  `expandall`, `expanddot`, `expanddotplus`, `expandcross`, `expandcrossplus`, `expandcrosscross`, `expandgrad`, `expandgradplus`, `expandgradprod`, `expanddiv`, `expanddivplus`, `expanddivprod`, `expandcurl`, `expandcurlplus`, `expandcurlcurl`, `expandlaplacian`, `expandlaplacianplus`, `expandlaplacianprod`.

  これらのフラグすべてはデフォルト値 `false`を持ちます。 `plus`接尾辞は加算性や分配性の利用に関係します。 `prod`接尾辞は任意の種類の積のオペランドに関する展開に関係します。

  `expandcrosscross`

    p ~ (q ~ r)を (p . r)*q - (p . q)*rに整理します。

  `expandcurlcurl`

    curl curl pを grad div p + div grad pに整理します。

  `expandlaplaciantodivgrad`

    laplacian pを div grad pに整理します。

  `expandcross`

    `expandcrossplus`と `expandcrosscross`を有効にします。

  `expandplus`

    `expanddotplus`, `expandcrossplus`, `expandgradplus`, `expanddivplus`, `expandcurlplus`, `expandlaplacianplus`を有効にします。

  `expandprod`

    `expandgradprod`, `expanddivprod`, `expandlaplacianprod`を有効にします。

  これらのフラグはすべて `evflag`として宣言されています。

  Categories: Package vect · Simplification functions

オプション変数: vect_cross

  デフォルト値: `false`

  `vect_cross`が `true`の時、 ~がSHARE;VECTの中で定義されているところ (とにかく、VECT_CROSSが `true`に設定されているところ) でDIFF(X~Y,T)が機能するようにします。

  Categories: Package vect · Differential calculus

関数: zeromatrix (m, n)

  要素すべてがゼロの m行 n列行列を返します。

  Categories: Matrices

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by 市川雄二 on October, 4 2018 using texi2html 1.76.