インタフェース org.mklab.nfc.matrix.Matrix の使用 (mklab API)

概要

パッケージ

クラス

使用

階層ツリー

非推奨 API

索引

ヘルプ

前次

フレームあり フレームなし

インタフェース
org.mklab.nfc.matrix.Matrix の使用

Matrix を使用しているパッケージ
org.mklab.nfc.matrix	行列に関するクラスを提供します。
org.mklab.nfc.matrix.misc	さまざまな行列を生成するクラスを提供します。
org.mklab.nfc.matrix.util	行列操作に関するクラスを提供します。
org.mklab.nfc.matx	MaTXに関係するデータを扱うためのクラスを提供します。
org.mklab.nfc.ode	常微分方程式(のソルバー)に関するクラスを提供します。
org.mklab.nfc.rpn	逆ポーランド記法に関係するクラスを提供します。
org.mklab.nfc.scalar	スカラーに関するクラスを提供します。
org.mklab.tool.control	制御系の解析・設計に関するクラスを提供します。
org.mklab.tool.control.system	制御システムを表現するためのクラスを提供します。
org.mklab.tool.control.system.continuous	連続時間システムを表現するためのクラスを提供します。
org.mklab.tool.control.system.controller	制御器を表す(設計する)ためのクラスを提供します。
org.mklab.tool.control.system.discontinuous	不連続システムを表現するためのクラスを提供します。
org.mklab.tool.control.system.discrete	離散時間システムを表現するためのクラスを提供します。
org.mklab.tool.control.system.graph	グラフを扱うためのクラスを提供します。
org.mklab.tool.control.system.math	数学ブロックを表現するためのクラスを提供します。
org.mklab.tool.control.system.sampled	サンプル値システムを表現するためのクラスを提供します。
org.mklab.tool.control.system.sink	吸収ブロックを表現するクラスを提供します。
org.mklab.tool.control.system.source	信号を生成(発生)するシステムを表現するためのクラスを提供します。
org.mklab.tool.matrix	行列計算に関するクラスを提供します。
org.mklab.tool.signal	信号処理に関するクラスを提供します。

org.mklab.nfc.matrix での Matrix の使用

Matrix 型の型パラメータを持つ org.mklab.nfc.matrix のクラス
`class`	`AbstractFundamentalMatrix<M extends Matrix>` 行列データを扱うための抽象クラスです。
`class`	`AbstractMatrix<M extends Matrix>` 行列を統一的に扱うためのクラスです。
`class`	`IndexedMatrix<M extends Matrix>` 指数付きの行列を表すクラスです。
`interface`	`TransformableMatrix<M extends Matrix>` 自動型変換可能な行列を表すインターフェースです。

org.mklab.nfc.matrix での Matrix のサブインタフェース
`interface`	`NumericalMatrixOperator<E extends NumericalScalar<E>>` 数値行列を表すインターフェースです。
`interface`	`SymbolicMatrixOperator<E extends SymbolicScalar<E>>` 数式行列を表すインターフェースです。
`interface`	`TransformableMatrix<M extends Matrix>` 自動型変換可能な行列を表すインターフェースです。

Matrix を実装している org.mklab.nfc.matrix のクラス
`class`	`AbstractMatrix<M extends Matrix>` 行列を統一的に扱うためのクラスです。
`class`	`BaseMatrix<M extends BaseMatrix<M,E>,E extends Scalar<E>>` `Scalar`を成分とする行列を表わすクラスです。
`class`	`DoubleComplexMatrix` 倍精度(double)型の複素数`DoubleComplexNumber`を成分とする行列を表すクラスです。
`class`	`DoubleMatrix` 倍精度(double)型の値を成分とする行列を表すクラスです。
`class`	`IntMatrix` int型の値を成分とする行列を表すクラスです。
`class`	`NumericalComplexMatrix<E extends NumericalScalar<E>>` `ComplexScalar`を成分とする行列を表わすクラスです。
`class`	`NumericalMatrix<E extends NumericalScalar<E>>` `NumericalScalar`を成分とする行列を表わすクラスです。
`class`	`PolynomialMatrix` 多項式(`Polynomial`)を成分とする行列を表わすクラスです。
`class`	`RationalPolynomialMatrix` 有理多項式(`RationalPolynomial`)を成分とする行列を表すクラスです。
`class`	`SymbolicMatrix<M extends SymbolicMatrix<M,E>,E extends SymbolicScalar<E>>` `SymbolicScalar`を成分とする行列を表すクラスです。

Matrix を返す org.mklab.nfc.matrix のメソッド
`Matrix`	`Matrix.add(Matrix value)` `value`との和を返します。
`Matrix`	`AbstractMatrix.add(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.addElementWise(double value)` 成分毎に実数を加えます。
`Matrix`	`IntMatrix.addElementWise(double scalar)`
`Matrix`	`MatrixElementWiseOperator.addElementWise(int value)` 成分毎に整数を加えます。
`Matrix`	`MatrixElementWiseOperator.addElementWise(Scalar<?> value)` 成分毎にスカラーを加えます。
`Matrix`	`IntMatrix.addElementWise(Scalar<?> value)`
`Matrix`	`DoubleMatrix.addElementWise(Scalar<?> value)`
`Matrix`	`FundamentalMatrix.appendDown(Matrix value)` 下側に行列`value`を付けた行列を生成します。
`Matrix`	`AbstractFundamentalMatrix.appendDown(Matrix value)`
`Matrix`	`FundamentalMatrix.appendRight(Matrix value)` 右側に`value`を付けた行列を生成します。
`Matrix`	`AbstractFundamentalMatrix.appendRight(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.ceilElementWise()` 大きい整数に丸めます。
`Matrix`	`Matrix.conjugate()` 共役複素行列を返します。
`Matrix`	`Matrix.conjugateTranspose()` 各成分の共役複素数の転置行列を返します。
`Matrix`	`Matrix.covariance(Matrix value)` `opponent`との共分散行列を返します。
`Matrix`	`AbstractMatrix.covariance(Matrix value)`
`Matrix`	`Matrix.createOnes()` 同サイズの全成分が1である行列を生成します。
`Matrix`	`Matrix.createOnes(int size)` `size`*`size`の全成分が1である行列を生成します。
`Matrix`	`Matrix.createOnes(int rowSize, int columnSize)` `rowSize`*`columnSize`の全成分が1である行列を生成します。
`Matrix`	`Matrix.createOnes(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber` 倍の全成分が1である行列を生成します。
`Matrix`	`Matrix.createUnit()` 同サイズの単位行列を生成します。
`Matrix`	`Matrix.createUnit(int size)` `size`*`size`の単位行列を生成します。
`Matrix`	`Matrix.createUnit(int rowSize, int columnSize)` `rowSize`*`columnSize`の単位行列を生成します。
`Matrix`	`Matrix.createUnit(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber` 倍の単位行列を生成します。
`Matrix`	`Matrix.createZero()` 同サイズの零行列を生成します。
`Matrix`	`Matrix.createZero(int size)` `size`*`size`の零行列を生成します。
`Matrix`	`Matrix.createZero(int rowSize, int columnSize)` `rowSize`*`columnSize`の零行列を生成します。
`Matrix`	`Matrix.createZero(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber` 倍の零行列を生成します。
`Matrix`	`Matrix.cumulativeProduct()` 各要の累積積からなる行列を返します。
`Matrix`	`Matrix.cumulativeProductColumnWise()` 列毎の累積積行列を返します。
`Matrix`	`Matrix.cumulativeProductRowWise()` 行毎の累積積行列を返します。
`Matrix`	`Matrix.cumulativeSum()` 各要の累積和からなる行列を返します。
`Matrix`	`Matrix.cumulativeSumColumnWise()` 列毎の累積和行列を返します。
`Matrix`	`Matrix.cumulativeSumRowWise()` 行毎の累積和行列を返します。
`Matrix`	`FundamentalMatrix.diagonalToVector()` 対角成分をからなる列ベクトルを生成します。
`Matrix`	`Matrix.divide(double value)` 各成分と実数valueの商(`this`/`value`)を返します。
`Matrix`	`Matrix.divide(int value)` 各成分と整数valueの商(`this`/`value`)を返します。
`Matrix`	`Matrix.divide(Matrix value)` 行列`value`の逆行列との積(`this`*value ^-1)を返します。
`Matrix`	`AbstractMatrix.divide(Matrix value)`
`Matrix`	`Matrix.divide(Scalar<?> value)` 各成分とスカラーの商からなる行列を返します。
`Matrix`	`IntMatrix.divide(Scalar<?> value)`
`Matrix`	`DoubleMatrix.divide(Scalar<?> value)`
`Matrix`	`MatrixElementWiseOperator.divideElementWise(Matrix value)` `value`との成分毎の商を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.divideElementWise(Matrix value)`
`Matrix`	`SymbolicMatrixOperator.evaluate(double argument)` 変数に倍精度実数を代入して評価します。
`Matrix`	`SymbolicMatrix.evaluate(double value)`
`Matrix`	`SymbolicMatrixOperator.evaluate(int argument)` 変数に整数を代入して評価します。
`Matrix`	`SymbolicMatrix.evaluate(int value)`
`Matrix`	`SymbolicMatrixOperator.evaluate(Matrix argument)` 変数に行列の成分を代入して、評価します。
`Matrix`	`SymbolicMatrix.evaluate(Matrix value)`
`Matrix`	`SymbolicMatrixOperator.evaluateElementWise(Matrix argument)` 変数に行列を代入して、評価します。
`Matrix`	`SymbolicMatrix.evaluateElementWise(Matrix matrix)`
`Matrix`	`MatrixElementWiseOperator.fixElementWise()` ゼロ方向の整数に丸めます。
`Matrix`	`FundamentalMatrix.flipLeftRight()` 左右の列を反転した行列を生成します。
`Matrix`	`FundamentalMatrix.flipUpDown()` 上下の行を反転した行列を生成します。
`Matrix`	`MatrixElementWiseOperator.floorElementWise()` 小さい整数に丸めます。
`Matrix`	`FundamentalMatrix.getColumnVector(int column)` 指定された列を返します。
`Matrix`	`FundamentalMatrix.getColumnVectors(int minimum, int maximum)` `minimum`列から`maximum`列までの部分行列を生成します。
`Matrix`	`FundamentalMatrix.getColumnVectors(IntMatrix index)` `index`で指定された列からなる部分行列を生成します。
`Matrix`	`Matrix.getImaginaryPart()` 虚部行列を返します。
`Matrix`	`BaseMatrix.getImaginaryPart()`
`Matrix`	`Matrix.getRealPart()` 実部行列を返します。
`Matrix`	`BaseMatrix.getRealPart()`
`Matrix`	`FundamentalMatrix.getRowVector(int row)` 指定された行を返します。
`Matrix`	`FundamentalMatrix.getRowVectors(int minimum, int maximum)` `minimum`行から`maximum`行までの部分行列を生成します。
`Matrix`	`FundamentalMatrix.getRowVectors(IntMatrix index)` `index`で指定された行からなる部分行列を生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(int row, int column, Grid block)` `block`のサイズで分割したときの`row`行`column` 列番目のブロック行列を返します。
`Matrix`	`FundamentalMatrix.getSubMatrix(int rowMinimum, int rowMaximum, int columnMinimum, int columnMaximum)` 部分行列`this(rowMinimum:rowMaximum,columnMinimum:columnMaximum)`を生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(int rowMinimum, int rowMaximum, IntMatrix columnIndex)` `rowMinimum`行から`rowMaximum`行目で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(int row, IntMatrix columnIndex)` `row`行ベクトルの`columnIndex`で指定された成分からなる横ベクトルを生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(IntMatrix rowIndex, int column)` `column`列ベクトルの`rowIndex`で指定された成分からなる縦ベクトルを生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(IntMatrix rowIndex, int columnMinimum, int columnMaximum)` `columnMinimum`列から`columnMaximum`列まで、 `rowIndex`で指定された行を成分とする部分行列を生成します。
`Matrix`	`FundamentalMatrix.getSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex)` `rowIndex`で指定された行で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`Matrix`	`FundamentalMatrix.getSubVector(int minimum, int maximum)` 成分を行毎に数え、`minimum`から`maximum`までの成分からなるベクトルを生成します。
`Matrix`	`FundamentalMatrix.getSubVector(int minimum, int maximum, int by)` 成分を行毎に数え、`minimum`から`maximum`までの`by` 飛び成分からなるベクトルを生成します。
`Matrix`	`FundamentalMatrix.getSubVector(IntMatrix index)` 行毎に数え`index`で指定した成分を成分とする部分行列を生成します。
`Matrix`	`Matrix.inverse()` 逆行列(`this` ^-1)を返します。
`Matrix`	`Matrix.inverse(double tolerance, boolean stopIfSingular)` 逆行列(`this` ^-1)を返します。
`Matrix`	`IntMatrix.inverse(double tolerance, boolean stopIfSingular)`
`Matrix`	`NumericalMatrixOperator.inverse(NumericalScalar<?> tolerance, boolean stopIfSingular)` 逆行列(`this` ^-1)を返します。
`Matrix`	`MatrixElementWiseOperator.inverseElementWise()` 成分毎の逆数からなる行列を返します。
`Matrix`	`IntMatrix.inverseElementWise()`
`Matrix`	`Matrix.leftDivide(double value)` 逆行列と実数`value`の積(`this` ^-1*`value`)を返します。
`Matrix`	`AbstractMatrix.leftDivide(double value)`
`Matrix`	`Matrix.leftDivide(int value)` 逆行列と整数`value`の積(`this` ^-1*`value`)を返します。
`Matrix`	`AbstractMatrix.leftDivide(int value)`
`Matrix`	`Matrix.leftDivide(Matrix value)` 逆行列と行列`value`の積(`this` ^-1*`value`)を返します。
`Matrix`	`AbstractMatrix.leftDivide(Matrix value)`
`Matrix`	`Matrix.leftDivide(Scalar<?> value)` 逆行列とスカラーvalueの積(`this` ^-1*`value`)を返します。
`Matrix`	`AbstractMatrix.leftDivide(Scalar<?> value)`
`Matrix`	`MatrixElementWiseOperator.leftDivideElementWise(Matrix value)` `value`との成分毎の左からの商を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.leftDivideElementWise(Matrix value)`
`Matrix`	`NumericalMatrixOperator.maxElementWise(Matrix opponent)` `opponent`と成分毎に比較し、大きいほうを成分にもつ行列を返します。
`Matrix`	`NumericalMatrix.maxElementWise(Matrix opponent)`
`Matrix`	`DoubleMatrix.maxElementWise(Matrix opponent)`
`Matrix`	`Matrix.meanColumnWise()` 各成分列毎の平均値行ベクトルを返します。
`Matrix`	`Matrix.meanRowWise()` 各成分行毎の平均値列ベクトルを返します。
`Matrix`	`NumericalMatrixOperator.minElementWise(Matrix opponent)` `opponent`と成分毎に比較し、小さいほうを成分にもつ行列を返します。
`Matrix`	`NumericalMatrix.minElementWise(Matrix opponent)`
`Matrix`	`DoubleMatrix.minElementWise(Matrix opponent)`
`Matrix`	`Matrix.multiply(double value)` 各成分と実数`value`の積を(`this`*`value`)を返します。
`Matrix`	`Matrix.multiply(int value)` 各成分と整数`value`の積を(`this`*`value`)を返します。
`Matrix`	`Matrix.multiply(Matrix value)` 行列`value`との積(`this`*`value`)を返します。
`Matrix`	`AbstractMatrix.multiply(Matrix value)`
`Matrix`	`Matrix.multiply(Scalar<?> value)` 各成分とスカラー`value`の積を返します。
`Matrix`	`IntMatrix.multiply(Scalar<?> value)`
`Matrix`	`DoubleMatrix.multiply(Scalar<?> value)`
`Matrix`	`MatrixElementWiseOperator.multiplyElementWise(Matrix value)` `value`との成分毎の積を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.multiplyElementWise(Matrix value)`
`Matrix`	`Matrix.power(int order)` 整数order乗(`this` ^order)を返します。
`Matrix`	`AbstractMatrix.power(int order)`
`Matrix`	`MatrixElementWiseOperator.powerElementWise(int order)` 成分毎に累乗します。
`Matrix`	`MatrixElementWiseOperator.powerElementWise(IntMatrix order)` 成分毎に累乗します。
`static Matrix`	`IntMatrix.powerElementWise(int scalar, Matrix matrix)` 1個の整数について、行列の各成分の累乗を求めます。
`Matrix`	`NumericalMatrixOperator.powerElementWise(Matrix matrix)` 成分毎に累乗するした値を成分とする行列を返します。
`Matrix`	`NumericalMatrix.powerElementWise(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.powerElementWise(Matrix order)` 成分毎に累乗します。
`Matrix`	`AbstractMatrix.powerElementWise(Matrix order)`
`Matrix`	`Matrix.productColumnWise()` 列毎に掛けた行ベクトルを返します。
`Matrix`	`Matrix.productRowWise()` 行毎に掛けた列ベクトルを返します。
`Matrix`	`FundamentalMatrix.reshape(int newRowSize, int newColumnSize)` サイズを`newRowSize`*`newColumnSize`に変更した行列を生成します。
`Matrix`	`FundamentalMatrix.resize(int newRowSize, int newColmunSize)` `newRowSize`*`newColumnSize`にサイズ変更します。
`Matrix`	`FundamentalMatrix.rotateLeft(int number)` 全ての成分を左方向へ回転します。
`Matrix`	`FundamentalMatrix.rotateUp(int number)` 全ての成分を上方向へ回転します。
`Matrix`	`MatrixElementWiseOperator.roundElementWise()` 最も近い整数に丸めます。
`Matrix`	`MatrixElementWiseOperator.roundToZeroElementWise()` 絶対値が小さい成分を0に丸めます。
`Matrix`	`MatrixElementWiseOperator.roundToZeroElementWise(double tolerance)` 絶対値が小さい成分を0に丸めます。
`Matrix`	`NumericalMatrixOperator.roundToZeroElementWise(NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`Matrix`	`Matrix.shiftLeft(int number)` 全ての成分を左方向へシフトします。
`Matrix`	`Matrix.shiftUp(int number)` 全ての成分を上方向へシフトします。
`Matrix`	`Matrix.subtract(Matrix value)` `value`との差を返します。
`Matrix`	`AbstractMatrix.subtract(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.subtractElementWise(double value)` 成分毎に実数を引きます。
`Matrix`	`IntMatrix.subtractElementWise(double scalar)`
`Matrix`	`MatrixElementWiseOperator.subtractElementWise(int value)` 成分毎に実数を引きます。
`Matrix`	`MatrixElementWiseOperator.subtractElementWise(Scalar<?> value)` 成分毎にスカラーを引きます。
`Matrix`	`IntMatrix.subtractElementWise(Scalar<?> value)`
`Matrix`	`DoubleMatrix.subtractElementWise(Scalar<?> value)`
`Matrix`	`Matrix.sumColumnWise()` 列毎に加えた行ベクトルを返します。
`Matrix`	`Matrix.sumRowWise()` 行毎に加えた列ベクトルを返します。
`Matrix`	`Matrix.toComplex()` 複素成分行列へ変換します。
`Matrix`	`BaseMatrix.toComplex()`
`Matrix`	`RationalPolynomialMatrix.transformFrom(Matrix value)`
`Matrix`	`PolynomialMatrix.transformFrom(Matrix value)`
`Matrix`	`Matrix.transformFrom(Matrix value)` 引数で与えられた型からこの型へ変換します。
`Matrix`	`BaseMatrix.transformFrom(Matrix value)`
`Matrix`	`AbstractMatrix.transformFrom(Matrix value)`
`Matrix`	`Matrix.transformTo(Matrix value)` この型から引数で与えられた型へ変換します。
`Matrix`	`BaseMatrix.transformTo(Matrix value)`
`Matrix`	`AbstractMatrix.transformTo(Matrix value)`
`protected static Matrix[]`	`AbstractMatrix.transformToSameClass(Matrix m1, Matrix m2)` 2個の行列を同じ型の行列に変換します。
`Matrix`	`FundamentalMatrix.transpose()` 転置行列(`this` ^T)を生成します。
`Matrix`	`Matrix.unaryMinus()` 符号を反転した値(-this)を返します。
`Matrix`	`FundamentalMatrix.vectorToDiagonal()` 列ベクトルまたは行ベクトルの各成分を対角成分に持つ行列を生成します。

Matrix 型のパラメータを持つ org.mklab.nfc.matrix のメソッド
`Matrix`	`Matrix.add(Matrix value)` `value`との和を返します。
`Matrix`	`AbstractMatrix.add(Matrix value)`
`Matrix`	`FundamentalMatrix.appendDown(Matrix value)` 下側に行列`value`を付けた行列を生成します。
`Matrix`	`AbstractFundamentalMatrix.appendDown(Matrix value)`
`Matrix`	`FundamentalMatrix.appendRight(Matrix value)` 右側に`value`を付けた行列を生成します。
`Matrix`	`AbstractFundamentalMatrix.appendRight(Matrix value)`
`NumericalMatrixOperator<?>`	`NumericalMatrixOperator.atan2ElementWise(Matrix matrix)` 各成分の逆正接(2)関数の結果を成分とする行列を生成します。
`NumericalMatrixOperator<?>`	`NumericalMatrix.atan2ElementWise(Matrix value)`
`NumericalMatrixOperator<?>`	`DoubleMatrix.atan2ElementWise(Matrix order)`
`BooleanMatrix`	`IntMatrix.compareElementWise(String operator, Matrix opponent)`
`BooleanMatrix`	`FundamentalMatrix.compareElementWise(String operator, Matrix opponent)` `opponent`と成分毎に`operator`で指定された演算子で比較した結果を `BooleanMatrix`で返します。
`BooleanMatrix`	`DoubleMatrix.compareElementWise(String operator, Matrix opponent)`
`BooleanMatrix`	`BaseMatrix.compareElementWise(String operator, Matrix opponent)`
`void`	`IntMatrix.copy(Matrix source)`
`void`	`FundamentalMatrix.copy(Matrix source)` `source`の成分をコピーします。
`void`	`DoubleMatrix.copy(Matrix source)`
`void`	`BaseMatrix.copy(Matrix source)`
`Matrix`	`Matrix.covariance(Matrix value)` `opponent`との共分散行列を返します。
`Matrix`	`AbstractMatrix.covariance(Matrix value)`
`Matrix`	`Matrix.divide(Matrix value)` 行列`value`の逆行列との積(`this`*value ^-1)を返します。
`Matrix`	`AbstractMatrix.divide(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.divideElementWise(Matrix value)` `value`との成分毎の商を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.divideElementWise(Matrix value)`
`boolean`	`IntMatrix.equals(Matrix opponent, double tolerance)`
`boolean`	`FundamentalMatrix.equals(Matrix opponent, double tolerance)` 行列`opponent`と値が許容誤差以内で等しいか判定します。
`boolean`	`DoubleMatrix.equals(Matrix opponent, double tolerance)`
`boolean`	`BaseMatrix.equals(Matrix opponent, double tolerance)`
`Matrix`	`SymbolicMatrixOperator.evaluate(Matrix argument)` 変数に行列の成分を代入して、評価します。
`Matrix`	`SymbolicMatrix.evaluate(Matrix value)`
`Matrix`	`SymbolicMatrixOperator.evaluateElementWise(Matrix argument)` 変数に行列を代入して、評価します。
`Matrix`	`SymbolicMatrix.evaluateElementWise(Matrix matrix)`
`boolean`	`RationalPolynomialMatrix.isTransformableFrom(Matrix value)`
`boolean`	`PolynomialMatrix.isTransformableFrom(Matrix value)`
`boolean`	`Matrix.isTransformableFrom(Matrix value)` 引数で与えられた型から、この型へ変換可能か判定します。
`boolean`	`IntMatrix.isTransformableFrom(Matrix value)`
`boolean`	`DoubleMatrix.isTransformableFrom(Matrix value)`
`boolean`	`BaseMatrix.isTransformableFrom(Matrix value)`
`boolean`	`AbstractMatrix.isTransformableFrom(Matrix value)`
`boolean`	`Matrix.isTransformableTo(Matrix value)` この型から引数で与えられた型へ変換可能か判定します。
`boolean`	`BaseMatrix.isTransformableTo(Matrix value)`
`boolean`	`AbstractMatrix.isTransformableTo(Matrix value)`
`Matrix`	`Matrix.leftDivide(Matrix value)` 逆行列と行列`value`の積(`this` ^-1*`value`)を返します。
`Matrix`	`AbstractMatrix.leftDivide(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.leftDivideElementWise(Matrix value)` `value`との成分毎の左からの商を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.leftDivideElementWise(Matrix value)`
`Matrix`	`NumericalMatrixOperator.maxElementWise(Matrix opponent)` `opponent`と成分毎に比較し、大きいほうを成分にもつ行列を返します。
`Matrix`	`NumericalMatrix.maxElementWise(Matrix opponent)`
`Matrix`	`DoubleMatrix.maxElementWise(Matrix opponent)`
`Matrix`	`NumericalMatrixOperator.minElementWise(Matrix opponent)` `opponent`と成分毎に比較し、小さいほうを成分にもつ行列を返します。
`Matrix`	`NumericalMatrix.minElementWise(Matrix opponent)`
`Matrix`	`DoubleMatrix.minElementWise(Matrix opponent)`
`NumericalMatrixOperator<?>`	`NumericalMatrixOperator.modulusElementWise(Matrix matrix)` 各成分の符合付剰余を成分とする行列を生成します。
`NumericalMatrixOperator<?>`	`NumericalMatrix.modulusElementWise(Matrix value)`
`DoubleMatrix`	`DoubleMatrix.modulusElementWise(Matrix order)`
`Matrix`	`Matrix.multiply(Matrix value)` 行列`value`との積(`this`*`value`)を返します。
`Matrix`	`AbstractMatrix.multiply(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.multiplyElementWise(Matrix value)` `value`との成分毎の積を成分にもつ行列を返します。
`Matrix`	`AbstractMatrix.multiplyElementWise(Matrix value)`
`static IntMatrix`	`IntMatrix.ones(int rowNumber, int columNumber, Matrix block)` 行列`block`の`rowNumber`*`colNumber` 倍の全成分1の行列を生成します。
`static IntMatrix`	`IntMatrix.ones(Matrix matrix)` 行列`matrix`と同サイズの全成分1の行列を生成します。
`static BooleanMatrix`	`BooleanMatrix.ones(Matrix matrix)` 行列`matrix`と同サイズで全成分`true`の行列を生成します。
`static DoubleComplexMatrix`	`DoubleComplexMatrix.powerElementWise(DoubleComplexNumber scalar, Matrix matrix)` 複素数の累乗(行列成分毎)を成分とする行列を生成します。
`static DoubleMatrix`	`DoubleMatrix.powerElementWise(double scalar, Matrix matrix)` 実数の累乗(行列成分毎)を成分とする行列を生成します。
`static Matrix`	`IntMatrix.powerElementWise(int scalar, Matrix matrix)` 1個の整数について、行列の各成分の累乗を求めます。
`static DoubleMatrix`	`DoubleMatrix.powerElementWise(int scalar, Matrix matrix)` 整数の累乗(行列成分毎)を成分とする行列を生成します。
`Matrix`	`NumericalMatrixOperator.powerElementWise(Matrix matrix)` 成分毎に累乗するした値を成分とする行列を返します。
`Matrix`	`NumericalMatrix.powerElementWise(Matrix value)`
`Matrix`	`MatrixElementWiseOperator.powerElementWise(Matrix order)` 成分毎に累乗します。
`NumericalMatrixOperator<?>`	`DoubleMatrix.powerElementWise(Matrix order)`
`Matrix`	`AbstractMatrix.powerElementWise(Matrix order)`
`static PolynomialMatrix`	`PolynomialMatrix.powerElementWise(Polynomial scalar, Matrix matrix)` 1個の多項式について、行列の各成分の累乗を求めます。
`static RationalPolynomialMatrix`	`RationalPolynomialMatrix.powerElementWise(RationalPolynomial scalar, Matrix matrix)` 1個の有理多項式について、行列の各成分の累乗を求めます。
`NumericalMatrixOperator<?>`	`NumericalMatrixOperator.remainderElementWise(Matrix matrix)` 各成分の剰余を成分とする行列を生成します。
`NumericalMatrixOperator<?>`	`NumericalMatrix.remainderElementWise(Matrix value)`
`DoubleMatrix`	`DoubleMatrix.remainderElementWise(Matrix order)`
`void`	`FundamentalMatrix.setColumnVector(int column, Matrix source)` 指定された列に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setColumnVector(int column, Matrix source)`
`void`	`FundamentalMatrix.setColumnVectors(int minimum, int maximum, Matrix source)` `minimum`列から`maximum`列に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setColumnVectors(int min, int max, Matrix source)`
`void`	`FundamentalMatrix.setColumnVectors(IntMatrix index, Matrix source)` 指定された列に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setColumnVectors(IntMatrix index, Matrix source)`
`void`	`Matrix.setImaginaryPart(Matrix imaginaryPart)` 虚部行列を設定します。
`void`	`IntMatrix.setImaginaryPart(Matrix imaginaryPart)`
`void`	`DoubleMatrix.setImaginaryPart(Matrix imaginaryPart)`
`void`	`BaseMatrix.setImaginaryPart(Matrix imagPart)`
`void`	`Matrix.setRealPart(Matrix realPart)` 実部行列を設定します。
`void`	`IntMatrix.setRealPart(Matrix realPart)`
`void`	`DoubleMatrix.setRealPart(Matrix realPart)`
`void`	`BaseMatrix.setRealPart(Matrix realPart)`
`void`	`FundamentalMatrix.setRowVector(int row, Matrix source)` 指定された行に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setRowVector(int row, Matrix source)`
`void`	`FundamentalMatrix.setRowVectors(int minimum, int maximum, Matrix source)` `minimum`行から`maximum`行に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setRowVectors(int min, int max, Matrix source)`
`void`	`FundamentalMatrix.setRowVectors(IntMatrix index, Matrix source)` 指定された複数の行に`source`を代入します。
`void`	`AbstractFundamentalMatrix.setRowVectors(IntMatrix index, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(int row, int column, Grid block, Matrix source)` 指定した成分に行列`source`を代入します。
`void`	`AbstractFundamentalMatrix.setSubMatrix(int row, int column, Grid block, Matrix source)`
`void`	`IntMatrix.setSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(int rowMinimum, int rowMaximum, int columnMinimum, int columnMaximum, Matrix source)` 指定した成分に行列`source`を代入します。
`void`	`DoubleMatrix.setSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax, Matrix source)`
`void`	`BaseMatrix.setSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax, Matrix source)`
`void`	`IntMatrix.setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(int rowMinimum, int rowMaximum, IntMatrix columnIndex, Matrix source)` `rowMinimum`列目から`rowMaximum`列目の成分の`columnIndex` で指定された行の成分に行列`source`を代入します。
`void`	`DoubleMatrix.setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, Matrix source)`
`void`	`BaseMatrix.setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(int row, IntMatrix columnIndex, Matrix source)` `row`列目の成分の`columnIndex`で指定された行の成分に行列`sourceを代入します。`
`void`	`AbstractFundamentalMatrix.setSubMatrix(int row, IntMatrix columnIndex, Matrix source)`
`void`	`IntMatrix.setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(IntMatrix rowIndex, int columnMinimum, int columnMaximum, Matrix source)` `rowIndex`で指定した行の`columnMinimum`列から`columnMaximum` 列までの行列`source`を代入します。
`void`	`DoubleMatrix.setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, Matrix source)`
`void`	`BaseMatrix.setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(IntMatrix rowIndex, int column, Matrix source)` `rowIndex`で指定した行の`column`列に行列`source` を代入します。
`void`	`AbstractFundamentalMatrix.setSubMatrix(IntMatrix rowIndex, int column, Matrix source)`
`void`	`IntMatrix.setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)`
`void`	`FundamentalMatrix.setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)` `rowIndex`で指定した行の`columnIndex`で指定した列に行列`source`を代入します。
`void`	`DoubleMatrix.setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)`
`void`	`BaseMatrix.setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)`
`void`	`FundamentalMatrix.setSubVector(int minimum, int maximum, int by, Matrix source)` 成分を行毎に数え、`minimum`から`maximum`までの成分を`by`飛びに代入します。
`void`	`AbstractFundamentalMatrix.setSubVector(int min, int max, int by, Matrix source)`
`void`	`IntMatrix.setSubVector(int min, int max, Matrix source)`
`void`	`FundamentalMatrix.setSubVector(int minimum, int maximum, Matrix source)` 成分を行毎に数え、`minimum`から`maximum`までに`source`の成分を代入します。
`void`	`DoubleMatrix.setSubVector(int min, int max, Matrix source)`
`void`	`BaseMatrix.setSubVector(int min, int max, Matrix source)`
`void`	`IntMatrix.setSubVector(IntMatrix index, Matrix source)`
`void`	`FundamentalMatrix.setSubVector(IntMatrix index, Matrix source)` `index`で指定した各成分に行列`source`の成分を代入します。
`void`	`DoubleMatrix.setSubVector(IntMatrix index, Matrix source)`
`void`	`BaseMatrix.setSubVector(IntMatrix index, Matrix source)`
`Matrix`	`Matrix.subtract(Matrix value)` `value`との差を返します。
`Matrix`	`AbstractMatrix.subtract(Matrix value)`
`Matrix`	`RationalPolynomialMatrix.transformFrom(Matrix value)`
`Matrix`	`PolynomialMatrix.transformFrom(Matrix value)`
`Matrix`	`Matrix.transformFrom(Matrix value)` 引数で与えられた型からこの型へ変換します。
`IntMatrix`	`IntMatrix.transformFrom(Matrix value)`
`DoubleMatrix`	`DoubleMatrix.transformFrom(Matrix value)`
`Matrix`	`BaseMatrix.transformFrom(Matrix value)`
`Matrix`	`AbstractMatrix.transformFrom(Matrix value)`
`Matrix`	`Matrix.transformTo(Matrix value)` この型から引数で与えられた型へ変換します。
`Matrix`	`BaseMatrix.transformTo(Matrix value)`
`Matrix`	`AbstractMatrix.transformTo(Matrix value)`
`protected static Matrix[]`	`AbstractMatrix.transformToSameClass(Matrix m1, Matrix m2)` 2個の行列を同じ型の行列に変換します。
`static IntMatrix`	`IntMatrix.unit(int rowNumber, int columnNumber, Matrix block)` 行列`matrix`の`rowNumber`*`colNumber` 倍の実単位行列を返します。
`static BooleanMatrix`	`BooleanMatrix.unit(int rowNumber, int columnNumber, Matrix block)` 行列`block`の`rowNum` * `columnNum`倍の単位行列を生成します。
`static IntMatrix`	`IntMatrix.unit(Matrix matrix)` 行列`matrix`と同サイズの実単位行列を返します。
`static DoubleMatrix`	`DoubleMatrix.unit(Matrix matrix)` 行列`matrix`と同サイズの実単位行列を生成します。
`static BooleanMatrix`	`BooleanMatrix.unit(Matrix matrix)` 行列`matrix`と同サイズの単位行列(対角成分のみ`true`)を生成します。
`static IntMatrix`	`IntMatrix.zero(int rowNumber, int columnNumber, Matrix block)` 行列`block`の`rowNumber`*`colNumber` 倍の零行列を生成します。
`static IntMatrix`	`IntMatrix.zero(Matrix matrix)` 行列`matrix`と同サイズの零行列を生成します。

Matrix 型のパラメータを持つ org.mklab.nfc.matrix のコンストラクタ
`BooleanMatrix(Matrix matrix)` `matrix`と同サイズの`boolean`行列を生成します。

org.mklab.nfc.matrix.misc での Matrix の使用

Matrix を返す org.mklab.nfc.matrix.misc のメソッド
`static Matrix`	`InverseHilbertMatrix.create(int size)` `size`×`size`の逆ヒルベルト行列を求める
`static Matrix`	`HilbertMatrix.create(int size)` `size`×`size`のヒルベルト行列を返します。
`static Matrix`	`HadamardMatrix.create(int size)` `2^size`次のアダマール行列を返します。
`static Matrix`	`DiagonalMatrix.create(Matrix... matrices)` 対角ブロック行列を生成します。
`static Matrix`	`VandermondeMatrix.create(Matrix x)` 2番目から最後までの列が`x`であるヴァンデルモンド行列を返します。
`static Matrix`	`UpperTriangleMatrix.create(Matrix x)` `x`の上三角部分を返します。
`static Matrix`	`ToeplitzMatrix.create(Matrix a)` 対称(エルミート)テプリッツ行列を返します。
`static Matrix`	`RotatedMatrix.create(Matrix a)` `a` の成分を反時計方向に `90` 度回転します。
`static Matrix`	`LowerTriangleMatrix.create(Matrix x)` `x`の下三角部分を返します。
`static Matrix`	`HankelMatrix.create(Matrix a)` 第1列が`a`であり、第1非対角より下の成分がゼロであるハンンケル行列を返します。
`static Matrix`	`CompanionMatrix.create(Matrix coefficientVector)` 特性多項式の係数から求めたコンパニオン行列(同判形)を返します。
`static Matrix`	`UpperTriangleMatrix.create(Matrix x, int distance)` `x`の次対角より上を返します。
`static Matrix`	`RotatedMatrix.create(Matrix a, int count)` `a` の成分を反時計方向に `count*90` 度回転します。
`static Matrix`	`LowerTriangleMatrix.create(Matrix x, int distance)` `x`の`k`次対角より下の成分を返します。
`static Matrix`	`ToeplitzMatrix.create(Matrix a, Matrix b)` `a`が第１列、`b`が第１行の非対称テプリッツ行列を返します。
`static Matrix`	`HankelMatrix.create(Matrix a, Matrix b)` 第1列が`a`であり、最終行が`b`であるハンンケル行列を返します。
`static Matrix`	`GivensMatrix.create(NumericalScalar<?> x, NumericalScalar<?> y)` 2×2の複素ギブンス回転行列 `\| c s \| \| x \| \| r \| G = \| \| ただし G * \| \| = \| \| \|-conj(s) c \| \| y \| \| 0 \|` を返します。

Matrix 型のパラメータを持つ org.mklab.nfc.matrix.misc のメソッド
`static Matrix`	`DiagonalMatrix.create(Matrix... matrices)` 対角ブロック行列を生成します。
`static Matrix`	`VandermondeMatrix.create(Matrix x)` 2番目から最後までの列が`x`であるヴァンデルモンド行列を返します。
`static Matrix`	`UpperTriangleMatrix.create(Matrix x)` `x`の上三角部分を返します。
`static Matrix`	`ToeplitzMatrix.create(Matrix a)` 対称(エルミート)テプリッツ行列を返します。
`static Matrix`	`RotatedMatrix.create(Matrix a)` `a` の成分を反時計方向に `90` 度回転します。
`static Matrix`	`LowerTriangleMatrix.create(Matrix x)` `x`の下三角部分を返します。
`static Matrix`	`HankelMatrix.create(Matrix a)` 第1列が`a`であり、第1非対角より下の成分がゼロであるハンンケル行列を返します。
`static Matrix`	`CompanionMatrix.create(Matrix coefficientVector)` 特性多項式の係数から求めたコンパニオン行列(同判形)を返します。
`static Matrix`	`UpperTriangleMatrix.create(Matrix x, int distance)` `x`の次対角より上を返します。
`static Matrix`	`RotatedMatrix.create(Matrix a, int count)` `a` の成分を反時計方向に `count*90` 度回転します。
`static Matrix`	`LowerTriangleMatrix.create(Matrix x, int distance)` `x`の`k`次対角より下の成分を返します。
`static Matrix`	`ToeplitzMatrix.create(Matrix a, Matrix b)` `a`が第１列、`b`が第１行の非対称テプリッツ行列を返します。
`static Matrix`	`HankelMatrix.create(Matrix a, Matrix b)` 第1列が`a`であり、最終行が`b`であるハンンケル行列を返します。

org.mklab.nfc.matrix.util での Matrix の使用

Matrix を返す org.mklab.nfc.matrix.util のメソッド
`static Matrix`	`Makecolv.makecolv(Matrix a)` 列ベクトルに変換します。
`static Matrix`	`Makerowv.makerowv(Matrix a)` 行ベクトルに変換します。
`static Matrix`	`Matrix4.matrix4(Matrix a11, Matrix a12, Matrix a21, Matrix a22)` 4個の行列を結合した行列を返します。

Matrix 型のパラメータを持つ org.mklab.nfc.matrix.util のメソッド
`static Matrix`	`Makecolv.makecolv(Matrix a)` 列ベクトルに変換します。
`static Matrix`	`Makerowv.makerowv(Matrix a)` 行ベクトルに変換します。
`static Matrix`	`Matrix4.matrix4(Matrix a11, Matrix a12, Matrix a21, Matrix a22)` 4個の行列を結合した行列を返します。

org.mklab.nfc.matx での Matrix の使用

org.mklab.nfc.matx での Matrix のサブインタフェース
`interface`	`MatxArray` MaTXの配列を表すインターフェースです。

Matrix を実装している org.mklab.nfc.matx のクラス
`class`	`MatxComplexArray` MaTXの複素配列を表すクラスです。
`class`	`MatxIntegerArray` MaTXの整数配列を表すクラスです。
`class`	`MatxPolynomialArray` MaTXの多項式配列を表すクラスです。
`class`	`MatxRationalPolynomialArray` MaTXの有理多項式配列を表すクラスです。
`class`	`MatxRealArray` MaTXの実配列を表すクラスです。

Matrix を返す org.mklab.nfc.matx のメソッド
`Matrix`	`MatxList.getMatrix(int index)` 要素を `Matrix` 型で取り出す。
`static Matrix`	`MatxMatrix.readMatFormat(InputStream input)` MATフォーマットのデータファイルを読み込みます。
`static Matrix`	`MatxMatrix.readMatFormat(String fileName)` MATフォーマットのデータファイルを読み込みます。
`static Matrix`	`MatxMatrix.readMxFormat(InputStream input)` 入力ストリームからMX形式の行列データを読み込みます。
`static Matrix`	`MatxMatrix.readMxFormat(MxDataHead head, InputStream input)` 入力ストリームからMX形式の行列データを読み込みます。
`static Matrix`	`MatxMatrix.readMxFormat(String fileName)` MX形式の行列データを読み込みます。
`Matrix`	`MatxArray.toMatrix()` Matrix型の値を返します。

Matrix 型のパラメータを持つ org.mklab.nfc.matx のメソッド
`void`	`MatxList.add(Matrix value)` valueをリストの最後に追加します。
`BooleanMatrix`	`MatxList.compareElementWise(Matrix opponent, String operator)` 各要素とopponentをoperatorで指定された演算子 (".==", ".!
`void`	`MatxList.set(int index, Matrix value)` リストのi番目に行列valueを設定します。

org.mklab.nfc.ode での Matrix の使用

Matrix を返す org.mklab.nfc.ode のメソッド
`Matrix`	`DifferenceEquation.differenceEquation(double t, Matrix x)` 時刻`t`と変数`x`からステップ`(t/T+1)`変数の値を返します。
`Matrix`	`DifferentialDifferenceEquation.differenceEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続変数`xc`、離散変数`xd`から離散変数の次ステップの値を返します。
`Matrix`	`DifferenceSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)` 時刻`t`、状態`x`、外部信号(入力と出力)`inputOutput`からステップ`(t/T+1)`の状態を返します。
`Matrix`	`DifferentialDifferenceSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 時刻`t`、連続状態`xc`、離散状態`xd`、外部信号(入力と出力) `inputOutput`から離散状態の次ステップの値を返します。
`Matrix`	`DifferenceEquation.differenceEquation(int k, Matrix x)` ステップ`k`と変数`x`からステップ`(k+1)`変数の値を返します。
`Matrix`	`DifferenceSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)` ステップ`k`、状態`x`、外部信号(入力と出力)`inputOutput`からステップ`(k+1)`の状態を返します。
`Matrix`	`DifferentialEquation.differentialEquation(double t, Matrix x)` 時刻`t`と変数`x`から変数の微分を返します。
`Matrix`	`DifferentialSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)` 時刻`t`、状態`x`、外部信号(入力と出力)`inputOutput` から状態の微分を返します。
`Matrix`	`DifferentialDifferenceEquation.differentialEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続変数`xc`、離散変数`xd`から連続変数の微分値を返します。
`Matrix`	`DifferentialDifferenceSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 時刻`t`、連続状態`xc`、離散状態`xd`、外部信号(入力と出力) `inputOutput`から連続状態の微分値を返します。
`Matrix`	`DiscreteAlgebraicSystem.inputOutputEquation(double t)` 時刻`t` における外部信号(入力と出力)を返します。
`Matrix`	`ContinuousDiscreteAlgebraicSystem.inputOutputEquation(double t)` 時刻`t`における外部信号(入力と出力)を返します。
`Matrix`	`ContinuousAlgebraicSystem.inputOutputEquation(double t)` 時刻`t`における外部信号(入力と出力)を返します。
`Matrix`	`DifferentialSystem.inputOutputEquation(double t, Matrix x)` 時刻`t`と状態`x`から外部信号(入力と出力)を返します。
`Matrix`	`DifferenceSystem.inputOutputEquation(double t, Matrix x)` 時刻`t`と状態`x`から外部信号(入力と出力)を返します。
`Matrix`	`DifferentialDifferenceSystem.inputOutputEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続状態`xc`、離散状態`xd`から外部信号(入力と出力)を返します。
`Matrix`	`DiscreteAlgebraicSystem.inputOutputEquation(int k)` ステップ`k`における外部信号(入力と出力)を返します。
`Matrix`	`DifferenceSystem.inputOutputEquation(int k, Matrix x)` ステップ`k`と状態`x`から外部信号(入力と出力)を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double step)`
`Matrix`	`RungeKutta4.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialDifferenceEquation equation, double t, Matrix xc, Matrix xd, double h)` `h`秒後の微分方程式の解を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialDifferenceSystem system, double t, Matrix xc, Matrix xd, double h)` `h`秒後の状態を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialEquation equation, double t, Matrix x, double h)` `h`秒後の微分方程式の解を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialSystem system, double t, Matrix x, double h)` `h`秒後の状態を返します。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たす次の時刻の状態を求めます。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 許容誤差を満たすシミュレーション計算を行います。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たす次の時刻の状態を求めます。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たすシミュレーション結果を計算します。

Matrix 型のパラメータを持つ org.mklab.nfc.ode のメソッド
`Matrix`	`DifferenceEquation.differenceEquation(double t, Matrix x)` 時刻`t`と変数`x`からステップ`(t/T+1)`変数の値を返します。
`Matrix`	`DifferentialDifferenceEquation.differenceEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続変数`xc`、離散変数`xd`から離散変数の次ステップの値を返します。
`Matrix`	`DifferenceSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)` 時刻`t`、状態`x`、外部信号(入力と出力)`inputOutput`からステップ`(t/T+1)`の状態を返します。
`Matrix`	`DifferentialDifferenceSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 時刻`t`、連続状態`xc`、離散状態`xd`、外部信号(入力と出力) `inputOutput`から離散状態の次ステップの値を返します。
`Matrix`	`DifferenceEquation.differenceEquation(int k, Matrix x)` ステップ`k`と変数`x`からステップ`(k+1)`変数の値を返します。
`Matrix`	`DifferenceSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)` ステップ`k`、状態`x`、外部信号(入力と出力)`inputOutput`からステップ`(k+1)`の状態を返します。
`Matrix`	`DifferentialEquation.differentialEquation(double t, Matrix x)` 時刻`t`と変数`x`から変数の微分を返します。
`Matrix`	`DifferentialSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)` 時刻`t`、状態`x`、外部信号(入力と出力)`inputOutput` から状態の微分を返します。
`Matrix`	`DifferentialDifferenceEquation.differentialEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続変数`xc`、離散変数`xd`から連続変数の微分値を返します。
`Matrix`	`DifferentialDifferenceSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 時刻`t`、連続状態`xc`、離散状態`xd`、外部信号(入力と出力) `inputOutput`から連続状態の微分値を返します。
`double`	`PiecewiseDifferentialEquation.getDiscontinuousPoint(double t1, Matrix x1, double t2, Matrix x2)` 指定された区間内([(t1,x1),(t2,x2)]の不連続点の時刻を返します。
`double`	`PiecewiseContinuousDiscreteAlgebraicSystem.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)` 指定された区間内([t1,t2]の不連続点の時刻を返します。
`double`	`PiecewiseContinuousAlgebraicSystem.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)` 指定された区間内([t1,t2]の不連続点の時刻を返します。
`double`	`PiecewiseDifferentialSystem.getDiscontinuousPoint(double t1, Matrix x1, Matrix u1, double t2, Matrix x2, Matrix u2)` 指定された区間内([(t1,x1),(t2,x2)]の不連続点の時刻を返します。
`double`	`PiecewiseDifferentialDifferenceEquation.getDiscontinuousPoint(double t1, Matrix xc1, Matrix xd1, double t2, Matrix xc2, Matrix xd2)` 指定された区間内([(t1,xc1,xd1),(t2,xc2,xd2)]の不連続点の時刻を返します。
`double`	`PiecewiseDifferentialDifferenceSystem.getDiscontinuousPoint(double t1, Matrix xc1, Matrix xd1, Matrix u1, double t2, Matrix xc2, Matrix xd2, Matrix u2)` 指定された区間内([(t1,xc1,xd1,u1),(t2,xc2,xd2,u2)]の不連続点の時刻を返します。
`int`	`PiecewiseDifferentialEquation.getPiece(double t, Matrix x)` 区分の番号を返します。
`List<Integer>`	`PiecewiseContinuousDiscreteAlgebraicSystem.getPiece(double t, Matrix u)` 区分の番号を返します。
`List<Integer>`	`PiecewiseContinuousAlgebraicSystem.getPiece(double t, Matrix u)` 区分の番号を返します。
`List<Integer>`	`PiecewiseDifferentialSystem.getPiece(double t, Matrix x, Matrix u)` 区分の番号を返します。
`int`	`PiecewiseDifferentialDifferenceEquation.getPiece(double t, Matrix xc, Matrix xd)` 区分の番号を返します。
`List<Integer>`	`PiecewiseDifferentialDifferenceSystem.getPiece(double t, Matrix xc, Matrix xd, Matrix u)` 区分の番号を返します。
`Matrix`	`DifferentialSystem.inputOutputEquation(double t, Matrix x)` 時刻`t`と状態`x`から外部信号(入力と出力)を返します。
`Matrix`	`DifferenceSystem.inputOutputEquation(double t, Matrix x)` 時刻`t`と状態`x`から外部信号(入力と出力)を返します。
`Matrix`	`DifferentialDifferenceSystem.inputOutputEquation(double t, Matrix xc, Matrix xd)` 時刻`t`、連続状態`xc`、離散状態`xd`から外部信号(入力と出力)を返します。
`Matrix`	`DifferenceSystem.inputOutputEquation(int k, Matrix x)` ステップ`k`と状態`x`から外部信号(入力と出力)を返します。
`void`	`DifferenceEquationSolver.solve(DifferenceEquation equation, double t0, double t1, Matrix xd0)` `t0`から`t1`までの解を求め, 結果を`Matrix` の配列として返します。
`void`	`DifferenceEquationSolver.solve(DifferenceSystem system, double t0, double t1, Matrix xd0)` `t0`から`t1`までのシミュレーションを行い, 結果を `Matrix`の配列として返します。
`void`	`DifferentialEquationSolver.solve(DifferentialDifferenceEquation equation, double t0, double t1, Matrix xc0, Matrix xd0)` `t0`秒から`t1`秒までの解を求め, 結果を `Matrix` の配列として返します。
`void`	`DifferentialEquationSolver.solve(DifferentialDifferenceSystem system, double t0, double t1, Matrix xc0, Matrix xd0)` `t0`秒から`t1`秒までのシミュレーションを行い, 結果を `Matrix`の配列として返します。
`void`	`DifferentialEquationSolver.solve(DifferentialEquation equation, double t0, double t1, Matrix x0)` `t0`秒から`t1`秒までの解を求め, 結果を `Matrix` の配列として返します。
`void`	`DifferentialEquationSolver.solve(DifferentialSystem system, double t0, double t1, Matrix x0)` `t0`秒から`t1`秒までのシミュレーションを行い, 結果を `Matrix`の配列として返します。
`void`	`DifferentialEquationAutoSolver.solveAuto(DifferentialDifferenceEquation equation, double t0, double t1, Matrix xc0, Matrix xd0)` 指定された許容誤差を満たすように微分差分方程式の解を求めます。
`void`	`DifferentialEquationAutoSolver.solveAuto(DifferentialDifferenceSystem system, double t0, double t1, Matrix xc0, Matrix xd0)` 指定された許容誤差でシミュレーション計算を行い、状態の時系列を返します。
`void`	`DifferentialEquationAutoSolver.solveAuto(DifferentialEquation equation, double t0, double t1, Matrix x0)` 指定された許容誤差を満たすように微分方程式の解を求めます。
`void`	`DifferentialEquationAutoSolver.solveAuto(DifferentialSystem system, double t0, double t1, Matrix x0)` 指定された許容誤差でシミュレーション計算を行います。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double step)`
`Matrix`	`RungeKutta4.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialDifferenceEquation equation, double t, Matrix xc, Matrix xd, double h)` `h`秒後の微分方程式の解を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialDifferenceSystem system, double t, Matrix xc, Matrix xd, double h)` `h`秒後の状態を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialEquation equation, double t0, Matrix x0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialEquation equation, double t, Matrix x, double h)` `h`秒後の微分方程式の解を返します。
`Matrix`	`RungeKuttaFehlberg.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`RungeKutta4.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`ModifiedEuler.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`Matrix`	`ImprovedEuler.step(DifferentialSystem system, double t0, Matrix x0, double h)`
`abstract Matrix`	`DifferentialEquationSolver.step(DifferentialSystem system, double t, Matrix x, double h)` `h`秒後の状態を返します。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialDifferenceEquation equation, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たす次の時刻の状態を求めます。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialDifferenceSystem system, double t0, Matrix xc0, Matrix xd0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 許容誤差を満たすシミュレーション計算を行います。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialEquation equation, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たす次の時刻の状態を求めます。
`Matrix`	`RungeKuttaFehlberg.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`RungeKutta4.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)`
`Matrix`	`EquationAutoSolver.stepAuto(DifferentialSystem system, double t0, Matrix x0, double trialTimeStep, double minTimeStep, double maxTimeStep, double tolerance, double[] actualStepNextTrialStep)` 指定された許容誤差を満たすシミュレーション結果を計算します。

org.mklab.nfc.rpn での Matrix の使用

Matrix を返す org.mklab.nfc.rpn のメソッド
`Matrix`	`ReversePolishNotationOperand.getOperandValue()` オペランドの値を返します。

org.mklab.nfc.scalar での Matrix の使用

Matrix を返す org.mklab.nfc.scalar のメソッド
`Matrix`	`Scalar.createGrid(double[] elements)` ベクトルを生成します。
`Matrix`	`AbstractScalar.createGrid(double[] elements)`
`Matrix`	`Scalar.createGrid(int[] elements)` ベクトルを生成します。
`Matrix`	`AbstractScalar.createGrid(int[] elements)`
`Matrix`	`Scalar.createGrid(int rowSize, int columnSize, double[][] elements)` 行列を生成します。
`Matrix`	`AbstractScalar.createGrid(int rowSize, int columnSize, double[][] elements)`
`Matrix`	`Scalar.createGrid(int rowSize, int columnSize, int[][] elements)` 行列を生成します。
`Matrix`	`AbstractScalar.createGrid(int rowSize, int columnSize, int[][] elements)`
`Matrix`	`Scalar.createGrid(int rowSize, int columnSize, Scalar<? extends Scalar<?>>[][] elements)` 行列を生成します。
`Matrix`	`Scalar.createGrid(Scalar<? extends Scalar<?>>[] elements)` ベクトルを生成します。
`Matrix`	`Scalar.createZeroGrid(int size)` 零ベクトルを生成します。
`Matrix`	`AbstractScalar.createZeroGrid(int size)`
`Matrix`	`Scalar.createZeroGrid(int rowSize, int columnSize)` 零行列を生成します。
`Matrix`	`AbstractScalar.createZeroGrid(int rowSize, int columnSize)`
`Matrix`	`SymbolicScalar.evaluate(Matrix argument)` 式変数に行列を代入した評価結果を返します。
`Matrix`	`RationalPolynomial.evaluate(Matrix value)`
`Matrix`	`Polynomial.evaluate(Matrix value)`
`Matrix`	`RationalPolynomial.evaluateElementWise(Matrix value)` 式変数に行列の各成分を代入した結果からなる行列を求めて返します。
`Matrix`	`Polynomial.evaluateElementWise(Matrix value)` 式変数に行列の各成分を代入した結果からなる行列を生成します。
`Matrix`	`Polynomial.getCoefficients()` 多項式の係数を成分とする行ベクトル(行列)を返します。
`Matrix`	`RationalPolynomial.getPoles()` 極(分母多項式=0の解)を求めます。
`Matrix`	`Polynomial.getRoots()` 多項式の根を返します。
`Matrix`	`RationalPolynomial.getZeros()` 零点(分子多項式=0の解)を求めます。

Matrix 型のパラメータを持つ org.mklab.nfc.scalar のメソッド
`Matrix`	`SymbolicScalar.evaluate(Matrix argument)` 式変数に行列を代入した評価結果を返します。
`Matrix`	`RationalPolynomial.evaluate(Matrix value)`
`Matrix`	`Polynomial.evaluate(Matrix value)`
`Matrix`	`RationalPolynomial.evaluateElementWise(Matrix value)` 式変数に行列の各成分を代入した結果からなる行列を求めて返します。
`Matrix`	`Polynomial.evaluateElementWise(Matrix value)` 式変数に行列の各成分を代入した結果からなる行列を生成します。

Matrix 型のパラメータを持つ org.mklab.nfc.scalar のコンストラクタ
`Polynomial(Matrix coefficientVector)` コンストラクター
`Polynomial(Matrix coefficientVector, String variableName)` コンストラクター

org.mklab.tool.control での Matrix の使用

Matrix として宣言されている org.mklab.tool.control のフィールド
`protected Matrix`	`AbstractLinearSystem.a` システム行列
`protected Matrix`	`AbstractLinearSystem.b` 入力行列
`protected Matrix`	`AbstractLinearSystem.c` 出力行列
`protected Matrix`	`AbstractLinearSystem.d` ゲイン行列
`protected Matrix`	`AbstractLinearSystem.e` E行列

Matrix を返す org.mklab.tool.control のメソッド
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q)` 連続時間リカッティ方程式 `A#P + PA - PRP + Q = 0` の解をシュア分解を用いて求め、その解を返します。
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q, double tolerance)` 虚軸に対する固有値の位置を判定するための許容誤差として`tolerance`を用いる。
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q, NumericalScalar<?> tolerance)` 虚軸に対する固有値の位置を判定するための許容誤差として`tolerance`を用いる。
`static Matrix`	`Ctrm.ctrm(Matrix A, Matrix B)` 可制御性行列 `V = [B AB Aˆ2B ...]`
`static Matrix`	`Dgramian.dgramian(Matrix A, Matrix B)` `dgramian(A,B)`は、可制御性グラミアンを返します。
`static Matrix`	`Dhinf.dhinf_aug(Matrix G, int n, int mw, int pz, double gamma)` 一般化プラント `n mw mu [[ x(k+1) ] n [[ A B1 B2 ] [[ x(k) ] [[ x ] [ z(k) ] = pz [ C1 D11 D12 ] [ w(k) ] = G [ w ] [ y(k) ]] py [ C2 D21 D22 ]] [ u(k) ]] [ u ]]` について、対応するリカッティ方程式を解き、 `n py [[ q(k+1) ] = n [[ Ac Bc ] [[ q(k) ] = Gc [[ q ] [ u(k) ]] mu [ Cc 0 ]] [ y(k) ]] [ y ]]` で定義される、H∞制御器`Gc`を返します。
`static Matrix`	`Dhinf.dhinf(Matrix G, int n, int mw, int pz, double gamma)`
`static Matrix`	`Dlyap.dlyap(Matrix A, Matrix Q)` 離散時間システムのリカッティ方程式 `APA# + Q = P` の解を返します。
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R)`
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R, double tol1)` 離散時間システムのリカッティ方程式 `P - A#PA + A#PB(R + B'PB)˜ B'PA = Q` の安定化解を返します。
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R, double toleranceOfEquation, double toleranceOfPoles)` もし、単位円上に閉ループ極があれば、警告メッセージが表示されます。
`Matrix`	`LinearSystem.getA()` A行列(システム行列)を返します。
`Matrix`	`AbstractLinearSystem.getA()` A行列(システム行列)を返します。
`Matrix`	`LinearSystem.getB()` B行列(入力行列)を返します。
`Matrix`	`AbstractLinearSystem.getB()` B行列(入力行列)を返します。
`Matrix`	`LinearSystem.getC()` C行列(出力行列)を返します。
`Matrix`	`AbstractLinearSystem.getC()` C行列(出力行列)を返します。
`Matrix`	`LinearSystem.getD()` D行列(ゲイン行列)を返します。
`Matrix`	`AbstractLinearSystem.getD()` D行列(ゲイン行列)を返します。
`Matrix`	`LinearSystem.getE()`
`Matrix`	`AbstractLinearSystem.getE()` E行列(ディスクリプタ行列)を返します。
`static Matrix`	`Gramian.gramian(Matrix A, Matrix B)` `gramian(A,B)`は、連続時間システムの可制御性グラミアンを返します。
`static Matrix`	`Hinf.hinf(Matrix G, int n, int mw, int pz, double gamma)` 一般化プラント `. n mw mu [[ x ] n [[ A B1 B2 ] [[ x ] [[ x ] [ z ] = pz [ C1 D11 D12 ] [ w ] = G [ w ] [ y ]] py [ C2 D21 D22 ]] [ u ]] [ u ]]` について、適当なリカッティ方程式を解き、H∞制御器 `. n py [[ q ] = n [[ Ac Bc ] [[ q ] = Gc [[ q ] [ u ]] mu [ Cc 0 ]] [ y ]] [ y ]]` を返します。
`static Matrix`	`Ltitr.ltitr(Matrix A, Matrix B, Matrix U)` 離散時間線形システム `x[n + 1] = Ax[n] + Bu[n]` に入力の系列 `U` が加えられた場合の時間応答を計算します。
`static Matrix`	`Ltitr.ltitr(Matrix A, Matrix B, Matrix inputSequence, Matrix x0)` 初期状態を `x0` とします。
`static Matrix`	`Lyap.lyap(Matrix A, Matrix Q)` 連続時間系のリヤプノフ方程式 `AP + PA# = -Q` の解`P`を返します。
`static Matrix`	`Lyap.lyap(Matrix A, Matrix B, Matrix Q)` 行列方程式 `AP + PB = -Q` の解`P`を返します。
`static Matrix`	`Obsm.obsm(Matrix A, Matrix C)` 可観測行列 `N = [[C][CA][CAˆ2 ...]]`
`static Matrix`	`Pplace.pplace(Matrix A, Matrix B, Matrix poles)` システム行列 `A,B` で表されるシステムを、状態フィードバックしたとき固有値をPにするようにフィードバックゲイン `F` を求めます。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R)` 連続時間のリカッティ方程式 `A#P + PA - PRP + Q = 0` の安定化解を有本・ポッターの方法で求めます。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R, double residualTolerance)` リカッティ方程式の式誤差のフロベニウスノルムが`residulaTolerance`より大きいとき、警告メッセージが表示されます。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R, double residualTolerance, double poleTolerance)` もし、リカッティ方程式の式誤差のフロベニウスノルムが`residulaTolerance`より大きいなら、警告メッセージが表示されます。
`static Matrix`	`Rlocus.rlocus(Matrix numerator, Matrix denominator)` 方程式 `num(s) H(s) = 1 + k ---------- = 0 den(s)` の根の軌跡データを返します。
`static Matrix`	`Rlocus.rlocus(Matrix numerator, Matrix denominator, Matrix K)` 各列が `K(i)` に対応する行列を返します。
`static Matrix`	`Rlocus.rlocus(Matrix A, Matrix b, Matrix c, Matrix d)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(Matrix A, Matrix b, Matrix c, Matrix d, Matrix K)` システム `. x = Ax + Bu y = Cx + Du u = -k*y` の根軌跡のデータを返します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomial g)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomialMatrix G)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomial g, Matrix K)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomialMatrix G, Matrix K)` 根軌跡のデータを計算します。
`static Matrix`	`Svfr.svfr(RationalPolynomialMatrix G, Matrix w)`
`static Matrix`	`Svfr.svfr(RationalPolynomialMatrix G, Matrix w, int type)` 入力と出力の数が等しいシステム`G(s)`の周波数応答`G(jw)`の特異値を求めます。
`static Matrix`	`Tzero.tzero(Matrix A, Matrix B, Matrix C, Matrix D)` システム `. x = Ax + Bu y = Cx + Du` の伝達ゼロ点を求めます。

Matrix 型の引数を持つ型を返す org.mklab.tool.control のメソッド
`static List<Matrix>`	`Augment.augment(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` 2つの線形システムから拡張システムを生成します。
`static List<Matrix>`	`Balreal.balreal(Matrix A, Matrix B, Matrix C)` 平衡実現されたシステム(Ab, Bb, Cb)を返します。
`static List<Matrix>`	`C2d.c2d(Matrix A, Matrix B, double samplingInterval)` 連続時間システム `dx/dt = Ax + Bu` を離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` に変換します。
`static List<Matrix>`	`C2d.c2d(Matrix A, Matrix B, NumericalScalar<?> samplingInterval)` 連続時間システム `dx/dt = Ax + Bu` を離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` に変換します。
`static List<Matrix>`	`Canon.canon(Matrix A, Matrix B, Matrix C, Matrix D)` システム`(A,B,C,D)` をモード形式の正準形に変換します。
`static List<Matrix>`	`Canon.canon(Matrix A, Matrix B, Matrix C, Matrix D, String type)` システム`(A,B,C,D)` を以下のタイプにしたがって正準形に変換します。
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C)` 可制御部分と不可制御部分に分解したシステム表現を返します。
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C, double tolerance)` 部分空間の次元を決めるために許容誤差`tolerance`を用いる。
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C, NumericalScalar<?> tolerance)` 部分空間の次元を決めるために許容誤差`tolerance`を用いる。
`static List<Matrix>`	`D2c.d2c(Matrix Ad, Matrix Bd, double samplingInterval)` 離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` を連続時間システム `dx/dt = Ax + Bu` に変換します。
`static List<Matrix>`	`D2c.d2c(Matrix Ad, Matrix Bd, NumericalScalar<?> samplingInterval)` 離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` を連続時間システム `dx/dt = Ax + Bu` に変換します。
`static List<Matrix>`	`Dbalreal.dbalreal(Matrix A, Matrix B, Matrix C)` 与えられたシステム`(A,B,C)`の平衡実現を返します。
`static List<Matrix>`	`SkeletonDes2tf.des2tf(Matrix A, Matrix B, Matrix C, Matrix D, Matrix E)`
`static List<Matrix>`	`SkeletonDes2tf.des2tf(Matrix a, Matrix b, Matrix c, Matrix d, Matrix e, boolean simplify)`
`static List<Matrix>`	`Dimpulse.dimpulse(Matrix num, Matrix den, int seriesSize)` 単位インパルス応答を計算する
`static List<Matrix>`	`Dimpulse.dimpulse(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の `iu` 番目の入力に単位インパルスを加えたときの応答を計算します。
`static List<Matrix>`	`Dimpulse.dimpulse(RationalPolynomial g, int seriesSize)` 単位インパルス応答を計算する
`static List<Matrix>`	`Dimpulse.dimpulse(RationalPolynomialMatrix G, int inputNumber, int seriesSize)` 単位インパルス応答を計算する
`static List<Matrix>`	`Dinitial.dinitial(Matrix numerator, Matrix denominator, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dinitial.dinitial(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, Matrix T)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の初期値応答を計算します。
`static List<Matrix>`	`Dinitial.dinitial(RationalPolynomial g, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dinitial.dinitial(RationalPolynomialMatrix G, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dlqe.dlqe(Matrix A, Matrix G, Matrix C, Matrix Q, Matrix R)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] + Gw[n] z[n] = Cx[n] + Du[n] + v[n]` について、プロセス雑音と観測雑音の分散が `E[w] = E[v] = 0, E[ww'] = Q, E[vv'] = R` であるとします。
`static List<Matrix>`	`Dlqr.dlqr(Matrix A, Matrix B, Matrix Q, Matrix R)` 離散時間線形システム `x[n + 1] = Ax[n] + Bu[n]` について、二次形式評価関数 `J = Sum (x#Qx + u#Ru)` <pre> を最小にする、状態フィードバック則 `u = -Fx` のフィードバックゲイン行列 `F` を返します。
`static List<Matrix>`	`Dlqr.dlqr(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` 評価関数が `J = Sum (x#Qx + u#Ru + 2 x#Su) dt` となるよう、入力`u`と状態`x`の積の重み行列を `S`とします。
`static List<Matrix>`	`Dlsim.dlsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` に入力列 `U` を与え、その時間応答を計算します。
`static List<Matrix>`	`Dlsim.dlsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, Matrix x0)` `x0`を初期状態として指定します。
`static List<Matrix>`	`Dstep.dstep(Matrix numerator, Matrix denominator, int seriesSize)` 単位ステップ応答を計算する
`static List<Matrix>`	`Dstep.dstep(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の `iu` 番目の入力に単位ステップが加えられたときの、時間応答を計算します。
`static List<Matrix>`	`Dstep.dstep(RationalPolynomial g, int seriesSize)` 単位ステップ応答を計算する
`static List<Matrix>`	`Dstep.dstep(RationalPolynomialMatrix G, int inputNumber, int seriesSize)` 単位ステップ応答を計算する
`static List<Matrix>`	`Feedback.feedback(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` 2個のシステム`s1`と`s2`をネガティブフィードバック結合したシステムを生成します。
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type)` ネガティブフィードバック結合したシステムを生成します。
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type, Matrix FH)`
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type, Matrix A2, Matrix B2, Matrix C2, Matrix D2)`
`static List<Matrix>`	`Impulse.impulse(LinearSystem system, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(Matrix numerator, Matrix denominator, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `iu` 番目の入力に単位インパルスが加えられた場合のインパルス応答を計算します。
`static List<Matrix>`	`Impulse.impulse(RationalPolynomial g, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Initial.initial(Matrix numerator, Matrix denominator, Matrix x0, Matrix T)` 初期値応答を計算する
`static List<Matrix>`	`Initial.initial(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の初期値応答を計算します。
`static List<Matrix>`	`Initial.initial(RationalPolynomial g, Matrix x0, Matrix T)` 初期値応答を計算する
`static List<Matrix>`	`Initial.initial(RationalPolynomialMatrix G, Matrix x0, Matrix T)` 初期値応答を計算する
`static List<Matrix>`	`Lqe.lqe(Matrix A, Matrix B, Matrix C, Matrix Q, Matrix R)` 連続時間システム `. x = Ax + Bu + Gw z = Cx + Du + v` について、プロセス雑音と観測雑音の分散が `E[w] = E[v] = 0, E[ww#] = Q, E[vv#] = R` であるとします。
`static List<Matrix>`	`Lqr.lqr(Matrix A, Matrix B, Matrix Q, Matrix R)` 連続時間線形システム `dx/dt = Ax + Bu` について、二次形式評価関数 `J = Integral (x#Qx + u#Ru) dt` を最小にする、最適状態フィードバック則`u = -Fx`のフィードバックゲイン行列`F`とリカッティ方程式 `P A + A# P - P B R˜ B# P + Q = 0` の解`P`を要素とするリストを返します。
`static List<Matrix>`	`Lqr.lqr(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` 評価関数が `J = Integral (x#Qx + u#Ru + 2 x#Su) dt` となるよう、入力`u`と状態`x`の積の重み行列を `S`とします。
`static List<Matrix>`	`Lqrs.lqrs(Matrix A, Matrix B, Matrix Q, Matrix R)` 連続時間線形システム `. x = Ax + Bu` について、二次形式評価関数 `J = Integral (x#Qx + u#Ru) dt` を最小にする、最適状態フィードバック則`u = -Fx`のフィードバックゲイン行列`F`を返します。
`static List<Matrix>`	`Lqrs.lqrs(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` `S`を`u`と`x`とのクロス項を指定するために使用します。
`static List<Matrix>`	`Lqry.lqry(Matrix A, Matrix B, Matrix C, Matrix D, Matrix Q, Matrix R)` 連続時間線形システム `. x = Ax + Bu y = Cx + Du` について、二次形式評価関数 `J = Integral (y#Qy + u#Ru) dt` を最小にする最適フィードバック則`u = -Fy`のフィードバックゲイン行列`F`を返します。
`static List<Matrix>`	`Lqry.lqry(Matrix A, Matrix B, Matrix C, Matrix D, Matrix Q, Matrix R, Matrix S)` `S`を`u`と`y`とのクロス項を指定するために使用します。
`static List<Matrix>`	`Lsim.lsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U_, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` に入力の時系列 `U` が与えられた場合の時間応答を計算します。
`static List<Matrix>`	`Lsim.lsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U_, Matrix T, Matrix x0_)` 連続時間応答を計算する
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D)` システム(A,B,C,D)の最小実現を返します。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, double tolerance)` 状態の次数を決定するための許容誤差として`tolerance`を用いる。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, double tolerance, int order)` 次数が`order`となるよう、許容誤差を自動的に決めます。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, NumericalScalar<?> tolerance)` 状態の次数を決定するための許容誤差として`tolerance`を用いる。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, NumericalScalar<?> tolerance, int order)` 次数が`order`となるよう、許容誤差を自動的に決めます。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C)` 可観測部分と不可観測部分に分解したシステム表現を返します。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C, double tolerance)` 可観測部分空間の次数を決定するために許容誤差`tol` を用いる。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C, NumericalScalar<?> tolerance)` 可観測部分空間の次数を決定するために許容誤差`tol` を用いる。
`static List<Matrix>`	`Obsg.obsg(Matrix A, Matrix B, Matrix C)` システム行列`A,B,C`から最小次元オブザーバを設計します。
`static List<Matrix>`	`Obsg.obsg(Matrix A, Matrix B, Matrix C, Matrix P)` システム `. x = Ax + Bu y = Cx` について、ゴピナスの方法で設計した最少次オブザーバ `. z = Ahz + Bhy + Jhu xh = Chz + Dh*y` の係数行列を返します。
`static List<Matrix>`	`Parallel.parallel(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` システム1 `. x1 = A1 x1 + B1 u1 y1 = C1 x1 + D1 u1` とシステム2 `. x2 = A2 x2 + B2 u2 y2 = C2 x2 + D2 u2` を並列結合(y = y1 + y2)したシステム `.`
`static List<Matrix>`	`Ramp.ramp(LinearSystem system, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(Matrix numerator, Matrix denominator, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `inputNumber` 番目の入力に単位ランプ入力が加えられた場合のランプ応答を求めます。
`static List<Matrix>`	`Ramp.ramp(RationalPolynomial g, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Series.series(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` システム1 `. x1 = A1 x1 + B1 u1 y1 = C1 x1 + D1 u1` の出力をシステム2 `. x2 = A2 x2 + B2 u2 y2 = C2 x2 + D2 u2` の入力に `-1 -1 u1 ---> C1(sI - A1)B1 ---> y1 ---> u2 ---> C2(sI - A2)B2 ---> y2` のように接続したシステムを生成します。
`static List<Matrix>`	`Ss2tf.ss2tf(Matrix A, Matrix B, Matrix C, Matrix D)`
`static List<Matrix>`	`Ss2tf.ss2tf(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であるシステムの`i`番目の入力から出力までの伝達関数 `NUM(s) -1 G(s) = -------- = C(sI-A) B + D den(s)` の分子行列多項式の係数行列`NUM`と分母多項式の係数 `den`を求めます。
`static List<Matrix>`	`Ss2zp.ss2zp(Matrix A, Matrix B, Matrix C, Matrix D)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であり、その伝達関数が `-1 (s-z1)(s-z2)...`
`static List<Matrix>`	`Ss2zp.ss2zp(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` `i`番目の入力から出力までの伝達関数のゼロ点、極、ゲインを求めます。
`static List<Matrix>`	`Step.step(LinearSystem system, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(Matrix numerator, Matrix denominator, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `iu` 番目の入力に単位ステップ入力が加えられた場合のステップ応答を求めます。
`static List<Matrix>`	`Step.step(RationalPolynomial g, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Tf2des.tf2des(Matrix numeratorMatrix, Matrix denominatorMatrix)` 1入力多出力システム(非プロパー) `NUM(s) G(s) = -------- den(s)` の状態空間表現 `.`
`static List<Matrix>`	`Tf2des.tf2des(RationalPolynomial transferFunction)` 1入力多出力システム(非プロパー) `NUM(s) G(s) = -------- den(s)` の状態空間表現 `.`
`static List<Matrix>`	`Tf2ss.tf2ss(Matrix numeratorMatrix, Matrix denominatorMatrix)` 1入力多出力システム `NUM(s) G(s) = -------- den(s)` の状態空間表現 `. x = Ax + Bu y = Cx + Du` を求めます。
`static List<Matrix>`	`Tf2zp.tf2zp(Matrix numerator, Matrix deniminator)` 1入力多出力システム `NUM(s) (s-z1)(s-z2)...`
`static List<Matrix>`	`Tfm2ss.tfm2ss(RationalPolynomialMatrix G)` 伝達関数行列が `-1 G(s) = C (sI - A) B + D` であるシステムの状態空間表現 `. x = Ax + Bu y = Cx + Du` を求めます。
`static List<Matrix>`	`Tfm2ss.tfm2ss(RationalPolynomialMatrix G, int inputNumber)` `iu`番目の入力から出力までのシステムの状態空間表現を求めます。
`static List<Matrix>`	`Tfm2ss.tfm2ss(RationalPolynomialMatrix G, int inputNumber, double tolerance)` 最小実現をminreal()で求める際に、許容誤差`tol` を用いる。
`static List<Matrix>`	`Tfm2tf.tfm2tf(RationalPolynomialMatrix G)`
`static List<Matrix>`	`Tfm2tf.tfm2tf(RationalPolynomialMatrix G, int inputNumber)` 伝達関数行列が `NUM(s) G(s) = -------- den(s)` であるシステムの`i`番目の入力から出力までのシステムの伝達関数の分子行列多項式の係数行列`NUM`と分母多項式の係数 `den`を求めます。
`static List<Matrix>`	`Tfm2zp.tfm2zp(RationalPolynomialMatrix G)`
`static List<Matrix>`	`Tfm2zp.tfm2zp(RationalPolynomialMatrix G, int inputNumber)` 伝達関数行列が `(s-z1)(s-z2)...`
`static List<Matrix>`	`Tfn2ss.tfn2ss(RationalPolynomial g)` 伝達関数が`g`であるシステムの状態空間表現 `. x = Ax + Bu y = Cx + Du` を求めます。
`static List<Matrix>`	`Tfn2tf.tfn2tf(RationalPolynomial g)` 伝達関数が `num(s) g(s) = ------ den(s)` であるシステムの伝達関数の分子多項式の係数`num`と分母多項式の係数`den`を求めます。
`static List<Matrix>`	`Tfn2zp.tfn2zp(RationalPolynomial g)` 伝達関数が `(s-z1)(s-z2)...`
`static List<Matrix>`	`Zp2ss.zp2ss(Matrix z_, Matrix p_, Matrix k)` 極`p`、ゼロ点`z`,ゲイン`k`であるシステム `(s-z1)(s-z2)...`
`static List<Matrix>`	`Zp2tf.zp2tf(Matrix zeros, Matrix poles, Matrix k)` 極`p`、ゼロ点`z`,ゲイン`k`である1入力多出力システム `NUM(s) (s-z1)(s-z2)...`

Matrix 型のパラメータを持つ org.mklab.tool.control のメソッド
`static String`	`Abcdchk.abcdchk(Matrix A)` 行列Aの大きさが整合しているか判定します。
`static String`	`Abcdchk.abcdchk(Matrix A, Matrix B)` 行列AとBの大きさが整合しているか判定します。
`static String`	`Abcdchk.abcdchk(Matrix A, Matrix B, Matrix C)` 行列A, B, Cの大きさが整合しているか判定します。
`static String`	`Abcdchk.abcdchk(Matrix A, Matrix B, Matrix C, Matrix D)` 行列A, B, C, Dの大きさが整合しているか判定します。
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q)` 連続時間リカッティ方程式 `A#P + PA - PRP + Q = 0` の解をシュア分解を用いて求め、その解を返します。
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q, double tolerance)` 虚軸に対する固有値の位置を判定するための許容誤差として`tolerance`を用いる。
`static Matrix`	`Are.are(Matrix A, Matrix R, Matrix Q, NumericalScalar<?> tolerance)` 虚軸に対する固有値の位置を判定するための許容誤差として`tolerance`を用いる。
`static List<Matrix>`	`Augment.augment(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` 2つの線形システムから拡張システムを生成します。
`static List<Matrix>`	`Balreal.balreal(Matrix A, Matrix B, Matrix C)` 平衡実現されたシステム(Ab, Bb, Cb)を返します。
`static List<Matrix>`	`C2d.c2d(Matrix A, Matrix B, double samplingInterval)` 連続時間システム `dx/dt = Ax + Bu` を離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` に変換します。
`static List<Matrix>`	`C2d.c2d(Matrix A, Matrix B, NumericalScalar<?> samplingInterval)` 連続時間システム `dx/dt = Ax + Bu` を離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` に変換します。
`static List<Matrix>`	`Canon.canon(Matrix A, Matrix B, Matrix C, Matrix D)` システム`(A,B,C,D)` をモード形式の正準形に変換します。
`static List<Matrix>`	`Canon.canon(Matrix A, Matrix B, Matrix C, Matrix D, String type)` システム`(A,B,C,D)` を以下のタイプにしたがって正準形に変換します。
`static ProperLinearSystem`	`LinearSystemFactory.createConstant(Matrix gain)` 定数行列から線形システム(定数システム)を生成します。
`static ProperLinearSystem`	`LinearSystemFactory.createLinearSystem(Matrix a, Matrix b, Matrix c, Matrix d)` 状態空間表現の係数行列から線形システムを生成します。
`static LinearSystem`	`LinearSystemFactory.createLinearSystem(Matrix a, Matrix b, Matrix c, Matrix d, Matrix e)` 係数行列から線形システムを生成します。
`static LinearSystem`	`LinearSystemFactory.createLinearSystem(Matrix a, Matrix b, Matrix c, Matrix d, Matrix e, boolean isDescriptorForm)` 係数行列からisDescriptorFormに応じて，ディスクリプタ形式or状態空間表現で線形システムを生成します．
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C)` 可制御部分と不可制御部分に分解したシステム表現を返します。
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C, double tolerance)` 部分空間の次元を決めるために許容誤差`tolerance`を用いる。
`static List<Matrix>`	`Ctrf.ctrf(Matrix A, Matrix B, Matrix C, NumericalScalar<?> tolerance)` 部分空間の次元を決めるために許容誤差`tolerance`を用いる。
`static Matrix`	`Ctrm.ctrm(Matrix A, Matrix B)` 可制御性行列 `V = [B AB Aˆ2B ...]`
`static List<Matrix>`	`D2c.d2c(Matrix Ad, Matrix Bd, double samplingInterval)` 離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` を連続時間システム `dx/dt = Ax + Bu` に変換します。
`static List<Matrix>`	`D2c.d2c(Matrix Ad, Matrix Bd, NumericalScalar<?> samplingInterval)` 離散時間システム `x[n + 1] = Ad * x[n] + Bd * u[n]` を連続時間システム `dx/dt = Ax + Bu` に変換します。
`static List<Matrix>`	`Dbalreal.dbalreal(Matrix A, Matrix B, Matrix C)` 与えられたシステム`(A,B,C)`の平衡実現を返します。
`static List<Matrix>`	`SkeletonDes2tf.des2tf(Matrix A, Matrix B, Matrix C, Matrix D, Matrix E)`
`static List<Matrix>`	`SkeletonDes2tf.des2tf(Matrix a, Matrix b, Matrix c, Matrix d, Matrix e, boolean simplify)`
`static RationalPolynomialMatrix`	`Des2tfm.des2tfm(Matrix A, Matrix B, Matrix C, Matrix D, Matrix E, boolean simplify)`
`static Matrix`	`Dgramian.dgramian(Matrix A, Matrix B)` `dgramian(A,B)`は、可制御性グラミアンを返します。
`static Matrix`	`Dhinf.dhinf_aug(Matrix G, int n, int mw, int pz, double gamma)` 一般化プラント `n mw mu [[ x(k+1) ] n [[ A B1 B2 ] [[ x(k) ] [[ x ] [ z(k) ] = pz [ C1 D11 D12 ] [ w(k) ] = G [ w ] [ y(k) ]] py [ C2 D21 D22 ]] [ u(k) ]] [ u ]]` について、対応するリカッティ方程式を解き、 `n py [[ q(k+1) ] = n [[ Ac Bc ] [[ q(k) ] = Gc [[ q ] [ u(k) ]] mu [ Cc 0 ]] [ y(k) ]] [ y ]]` で定義される、H∞制御器`Gc`を返します。
`static Matrix`	`Dhinf.dhinf(Matrix G, int n, int mw, int pz, double gamma)`
`static List<Matrix>`	`Dimpulse.dimpulse(Matrix num, Matrix den, int seriesSize)` 単位インパルス応答を計算する
`static List<Matrix>`	`Dimpulse.dimpulse(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の `iu` 番目の入力に単位インパルスを加えたときの応答を計算します。
`static List<Matrix>`	`Dinitial.dinitial(Matrix numerator, Matrix denominator, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dinitial.dinitial(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, Matrix T)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の初期値応答を計算します。
`static List<Matrix>`	`Dinitial.dinitial(RationalPolynomial g, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dinitial.dinitial(RationalPolynomialMatrix G, Matrix x0, Matrix T)`
`static List<Matrix>`	`Dlqe.dlqe(Matrix A, Matrix G, Matrix C, Matrix Q, Matrix R)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] + Gw[n] z[n] = Cx[n] + Du[n] + v[n]` について、プロセス雑音と観測雑音の分散が `E[w] = E[v] = 0, E[ww'] = Q, E[vv'] = R` であるとします。
`static List<Matrix>`	`Dlqr.dlqr(Matrix A, Matrix B, Matrix Q, Matrix R)` 離散時間線形システム `x[n + 1] = Ax[n] + Bu[n]` について、二次形式評価関数 `J = Sum (x#Qx + u#Ru)` <pre> を最小にする、状態フィードバック則 `u = -Fx` のフィードバックゲイン行列 `F` を返します。
`static List<Matrix>`	`Dlqr.dlqr(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` 評価関数が `J = Sum (x#Qx + u#Ru + 2 x#Su) dt` となるよう、入力`u`と状態`x`の積の重み行列を `S`とします。
`static List<Matrix>`	`Dlsim.dlsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` に入力列 `U` を与え、その時間応答を計算します。
`static List<Matrix>`	`Dlsim.dlsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, Matrix x0)` `x0`を初期状態として指定します。
`static Matrix`	`Dlyap.dlyap(Matrix A, Matrix Q)` 離散時間システムのリカッティ方程式 `APA# + Q = P` の解を返します。
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R)`
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R, double tol1)` 離散時間システムのリカッティ方程式 `P - A#PA + A#PB(R + B'PB)˜ B'PA = Q` の安定化解を返します。
`static Matrix`	`Dric.dric(Matrix A, Matrix B, Matrix Q, Matrix R, double toleranceOfEquation, double toleranceOfPoles)` もし、単位円上に閉ループ極があれば、警告メッセージが表示されます。
`static List<Matrix>`	`Dstep.dstep(Matrix numerator, Matrix denominator, int seriesSize)` 単位ステップ応答を計算する
`static List<Matrix>`	`Dstep.dstep(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 離散時間システム `x[n+1] = Ax[n] + Bu[n] y[n] = Cx[n] + Du[n]` の `iu` 番目の入力に単位ステップが加えられたときの、時間応答を計算します。
`static List<?>`	`Faddeev.faddeev(Matrix A)` 行列 `A` のリゾルベント行列 `NN(s) NN_(n-1) sˆ(n-1) + ... + NN1 s + NN0 -1 ----- = ------------------------------------------- = (s*I - A) dd(s) sˆn + dd_(n-1) sˆ(n-1) + ... + dd1 s + dd0` の分子行列多項式の係数行列と分母多項式の係数を返します。
`static List<Matrix>`	`Feedback.feedback(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` 2個のシステム`s1`と`s2`をネガティブフィードバック結合したシステムを生成します。
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type)` ネガティブフィードバック結合したシステムを生成します。
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type, Matrix FH)`
`static List<Matrix>`	`Feedbk.feedbk(Matrix A1, Matrix B1, Matrix C1, Matrix D1, int type, Matrix A2, Matrix B2, Matrix C2, Matrix D2)`
`static List<NumericalMatrix<?>>`	`Ltifr.getResponse(Matrix A, Matrix B, NumericalMatrixOperator<?> s_)` 連続時間線形時不変システムの周波数応答 `(s*I - A) \ B` を計算します。
`static Matrix`	`Gramian.gramian(Matrix A, Matrix B)` `gramian(A,B)`は、連続時間システムの可制御性グラミアンを返します。
`static Matrix`	`Hinf.hinf(Matrix G, int n, int mw, int pz, double gamma)` 一般化プラント `. n mw mu [[ x ] n [[ A B1 B2 ] [[ x ] [[ x ] [ z ] = pz [ C1 D11 D12 ] [ w ] = G [ w ] [ y ]] py [ C2 D21 D22 ]] [ u ]] [ u ]]` について、適当なリカッティ方程式を解き、H∞制御器 `. n py [[ q ] = n [[ Ac Bc ] [[ q ] = Gc [[ q ] [ u ]] mu [ Cc 0 ]] [ y ]] [ y ]]` を返します。
`static List<Matrix>`	`Impulse.impulse(LinearSystem system, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(Matrix numerator, Matrix denominator, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `iu` 番目の入力に単位インパルスが加えられた場合のインパルス応答を計算します。
`static List<Matrix>`	`Impulse.impulse(RationalPolynomial g, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Impulse.impulse(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位インパルス応答を計算する
`static List<Matrix>`	`Initial.initial(Matrix numerator, Matrix denominator, Matrix x0, Matrix T)` 初期値応答を計算する
`static List<Matrix>`	`Initial.initial(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の初期値応答を計算します。
`static List<Matrix>`	`Initial.initial(RationalPolynomial g, Matrix x0, Matrix T)` 初期値応答を計算する
`static List<Matrix>`	`Initial.initial(RationalPolynomialMatrix G, Matrix x0, Matrix T)` 初期値応答を計算する
`LinearSystem`	`LinearSystem.leftMultiply(Matrix constantMatrix)` 定数行列`constantMatrix`を左から掛けてできるシステムを返します。
`LinearSystem`	`AbstractLinearSystem.leftMultiply(Matrix constantMatrix)` 定数行列`constantMatrix`を左から掛けてできるシステムを返します。
`static List<Matrix>`	`Lqe.lqe(Matrix A, Matrix B, Matrix C, Matrix Q, Matrix R)` 連続時間システム `. x = Ax + Bu + Gw z = Cx + Du + v` について、プロセス雑音と観測雑音の分散が `E[w] = E[v] = 0, E[ww#] = Q, E[vv#] = R` であるとします。
`static List<Matrix>`	`Lqr.lqr(Matrix A, Matrix B, Matrix Q, Matrix R)` 連続時間線形システム `dx/dt = Ax + Bu` について、二次形式評価関数 `J = Integral (x#Qx + u#Ru) dt` を最小にする、最適状態フィードバック則`u = -Fx`のフィードバックゲイン行列`F`とリカッティ方程式 `P A + A# P - P B R˜ B# P + Q = 0` の解`P`を要素とするリストを返します。
`static List<Matrix>`	`Lqr.lqr(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` 評価関数が `J = Integral (x#Qx + u#Ru + 2 x#Su) dt` となるよう、入力`u`と状態`x`の積の重み行列を `S`とします。
`static List<Matrix>`	`Lqrs.lqrs(Matrix A, Matrix B, Matrix Q, Matrix R)` 連続時間線形システム `. x = Ax + Bu` について、二次形式評価関数 `J = Integral (x#Qx + u#Ru) dt` を最小にする、最適状態フィードバック則`u = -Fx`のフィードバックゲイン行列`F`を返します。
`static List<Matrix>`	`Lqrs.lqrs(Matrix A, Matrix B, Matrix Q, Matrix R, Matrix S)` `S`を`u`と`x`とのクロス項を指定するために使用します。
`static List<Matrix>`	`Lqry.lqry(Matrix A, Matrix B, Matrix C, Matrix D, Matrix Q, Matrix R)` 連続時間線形システム `. x = Ax + Bu y = Cx + Du` について、二次形式評価関数 `J = Integral (y#Qy + u#Ru) dt` を最小にする最適フィードバック則`u = -Fy`のフィードバックゲイン行列`F`を返します。
`static List<Matrix>`	`Lqry.lqry(Matrix A, Matrix B, Matrix C, Matrix D, Matrix Q, Matrix R, Matrix S)` `S`を`u`と`y`とのクロス項を指定するために使用します。
`static List<Matrix>`	`Lsim.lsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U_, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` に入力の時系列 `U` が与えられた場合の時間応答を計算します。
`static List<Matrix>`	`Lsim.lsim(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U_, Matrix T, Matrix x0_)` 連続時間応答を計算する
`static NumericalMatrixOperator<?>`	`Ltifr.ltifr(Matrix A, Matrix B, Matrix s_)` 連続時間線形時不変システムの周波数応答 `(s*I - A) \ B` を計算します。
`static Matrix`	`Ltitr.ltitr(Matrix A, Matrix B, Matrix U)` 離散時間線形システム `x[n + 1] = Ax[n] + Bu[n]` に入力の系列 `U` が加えられた場合の時間応答を計算します。
`static Matrix`	`Ltitr.ltitr(Matrix A, Matrix B, Matrix inputSequence, Matrix x0)` 初期状態を `x0` とします。
`static Matrix`	`Lyap.lyap(Matrix A, Matrix Q)` 連続時間系のリヤプノフ方程式 `AP + PA# = -Q` の解`P`を返します。
`static Matrix`	`Lyap.lyap(Matrix A, Matrix B, Matrix Q)` 行列方程式 `AP + PB = -Q` の解`P`を返します。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D)` システム(A,B,C,D)の最小実現を返します。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, double tolerance)` 状態の次数を決定するための許容誤差として`tolerance`を用いる。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, double tolerance, int order)` 次数が`order`となるよう、許容誤差を自動的に決めます。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, NumericalScalar<?> tolerance)` 状態の次数を決定するための許容誤差として`tolerance`を用いる。
`static List<Matrix>`	`Minreal.minreal(Matrix A, Matrix B, Matrix C, Matrix D, NumericalScalar<?> tolerance, int order)` 次数が`order`となるよう、許容誤差を自動的に決めます。
`LinearSystem`	`LinearSystem.multiply(Matrix constantMatrix)` 定数行列`constantMatrix`を右から掛けてできるシステムを返します。
`LinearSystem`	`AbstractLinearSystem.multiply(Matrix constantMatrix)` 定数行列`constantMatrix`を右から掛けてできるシステムを返します。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C)` 可観測部分と不可観測部分に分解したシステム表現を返します。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C, double tolerance)` 可観測部分空間の次数を決定するために許容誤差`tol` を用いる。
`static List<Matrix>`	`Obsf.obsf(Matrix A, Matrix B, Matrix C, NumericalScalar<?> tolerance)` 可観測部分空間の次数を決定するために許容誤差`tol` を用いる。
`static List<Matrix>`	`Obsg.obsg(Matrix A, Matrix B, Matrix C)` システム行列`A,B,C`から最小次元オブザーバを設計します。
`static List<Matrix>`	`Obsg.obsg(Matrix A, Matrix B, Matrix C, Matrix P)` システム `. x = Ax + Bu y = Cx` について、ゴピナスの方法で設計した最少次オブザーバ `. z = Ahz + Bhy + Jhu xh = Chz + Dh*y` の係数行列を返します。
`static Matrix`	`Obsm.obsm(Matrix A, Matrix C)` 可観測行列 `N = [[C][CA][CAˆ2 ...]]`
`static List<Matrix>`	`Parallel.parallel(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` システム1 `. x1 = A1 x1 + B1 u1 y1 = C1 x1 + D1 u1` とシステム2 `. x2 = A2 x2 + B2 u2 y2 = C2 x2 + D2 u2` を並列結合(y = y1 + y2)したシステム `.`
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator)` 根軌跡をプロットします。
`static Gnuplot`	`Step.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, DoubleMatrix T)` 単位ステップ応答をプロットします。
`static Gnuplot`	`Ramp.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, DoubleMatrix T)` 単位ランプ応答をプロットします。
`static Gnuplot`	`Impulse.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, DoubleMatrix T)` 単位インパルス応答をプロットする
`static Gnuplot`	`Dstep.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, int seriesSize)` 単位ステップ応答をプロットする
`static Gnuplot`	`Dimpulse.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, int seriesSize)` 単位インパルス応答をプロットする
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, Matrix K)` 根軌跡をプロットします。
`static Gnuplot`	`Initial.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, Matrix x0, DoubleMatrix T)` 初期値応答をプロットする
`static Gnuplot`	`Dinitial.plot(Gnuplot gnuplot, Matrix numerator, Matrix denominator, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, Matrix A, Matrix b, Matrix c, Matrix d)` 根軌跡をプロットします。
`static Gnuplot`	`Step.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, DoubleMatrix T)` 単位ステップ応答をプロットします。
`static Gnuplot`	`Ramp.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, DoubleMatrix T)` 単位ランプ応答をプロットします。
`static Gnuplot`	`Dstep.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 単位ステップ応答をプロットする
`static Gnuplot`	`Dimpulse.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)` 単位インパルス応答をプロットする
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, Matrix A, Matrix b, Matrix c, Matrix d, Matrix K)` 根軌跡をプロットします。
`static Gnuplot`	`Dlsim.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix U)`
`static Gnuplot`	`Lsim.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, DoubleMatrix T)` 連続時間応答をプロットする
`static Gnuplot`	`Initial.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, DoubleMatrix T)` 初期値応答をプロットする
`static Gnuplot`	`Dinitial.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Lsim.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, DoubleMatrix T, Matrix x0)` 連続時間応答をプロットする
`static Gnuplot`	`Dlsim.plot(Gnuplot gnuplot, Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, Matrix x0)`
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, RationalPolynomial g, Matrix K)` 根軌跡をプロットします。
`static Gnuplot`	`Initial.plot(Gnuplot gnuplot, RationalPolynomial g, Matrix x0, DoubleMatrix T)` 初期値応答をプロットする
`static Gnuplot`	`Dinitial.plot(Gnuplot gnuplot, RationalPolynomial g, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Rlocus.plot(Gnuplot gnuplot, RationalPolynomialMatrix G, Matrix K)` 根軌跡をプロットします。
`static Gnuplot`	`Initial.plot(Gnuplot gnuplot, RationalPolynomialMatrix G, Matrix x0, DoubleMatrix T)` 初期値応答をプロットする
`static Gnuplot`	`Dinitial.plot(Gnuplot gnuplot, RationalPolynomialMatrix G, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Rlocus.plot(Matrix numerator, Matrix denominator)`
`static Gnuplot`	`Step.plot(Matrix numerator, Matrix denominator, DoubleMatrix T)`
`static Gnuplot`	`Ramp.plot(Matrix numerator, Matrix denominator, DoubleMatrix T)`
`static Gnuplot`	`Impulse.plot(Matrix numerator, Matrix denominator, DoubleMatrix T)`
`static Gnuplot`	`Dstep.plot(Matrix numerator, Matrix denominator, int seriesSize)`
`static Gnuplot`	`Dimpulse.plot(Matrix numerator, Matrix denominator, int seriesSize)`
`static Gnuplot`	`Rlocus.plot(Matrix numerator, Matrix denominator, Matrix K)`
`static Gnuplot`	`Initial.plot(Matrix numerator, Matrix denominator, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Dinitial.plot(Matrix numerator, Matrix denominator, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Rlocus.plot(Matrix A, Matrix b, Matrix c, Matrix d)`
`static Gnuplot`	`Step.plot(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, DoubleMatrix T)`
`static Gnuplot`	`Ramp.plot(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, DoubleMatrix T)`
`static Gnuplot`	`Dstep.plot(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)`
`static Gnuplot`	`Dimpulse.plot(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int seriesSize)`
`static Gnuplot`	`Rlocus.plot(Matrix A, Matrix b, Matrix c, Matrix d, Matrix K)`
`static Gnuplot`	`Dlsim.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U)`
`static Gnuplot`	`Lsim.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, DoubleMatrix T)`
`static Gnuplot`	`Initial.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Dinitial.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Lsim.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, DoubleMatrix T, Matrix x0)`
`static Gnuplot`	`Dlsim.plot(Matrix A, Matrix B, Matrix C, Matrix D, Matrix U, Matrix x0)`
`static Gnuplot`	`Rlocus.plot(RationalPolynomial g, Matrix K)`
`static Gnuplot`	`Initial.plot(RationalPolynomial g, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Dinitial.plot(RationalPolynomial g, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Rlocus.plot(RationalPolynomialMatrix G, Matrix K)`
`static Gnuplot`	`Initial.plot(RationalPolynomialMatrix G, Matrix x0, DoubleMatrix T)`
`static Gnuplot`	`Dinitial.plot(RationalPolynomialMatrix G, Matrix x0, DoubleMatrix T)`
`static Matrix`	`Pplace.pplace(Matrix A, Matrix B, Matrix poles)` システム行列 `A,B` で表されるシステムを、状態フィードバックしたとき固有値をPにするようにフィードバックゲイン `F` を求めます。
`static List<Matrix>`	`Ramp.ramp(LinearSystem system, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(Matrix numerator, Matrix denominator, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `inputNumber` 番目の入力に単位ランプ入力が加えられた場合のランプ応答を求めます。
`static List<Matrix>`	`Ramp.ramp(RationalPolynomial g, Matrix T)` 単位ランプ応答を計算します。
`static List<Matrix>`	`Ramp.ramp(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位ランプ応答を計算します。
`static List<?>`	`Resolvent.resolvent(Matrix A)` 行列`A`のリゾルベント行列 `N(s) -1 ----- = (s*I - A) ch(s)` の分子`N`と分母`ch`(特性多項式)を返します。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R)` 連続時間のリカッティ方程式 `A#P + PA - PRP + Q = 0` の安定化解を有本・ポッターの方法で求めます。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R, double residualTolerance)` リカッティ方程式の式誤差のフロベニウスノルムが`residulaTolerance`より大きいとき、警告メッセージが表示されます。
`static Matrix`	`Ric.ric(Matrix A, Matrix Q, Matrix R, double residualTolerance, double poleTolerance)` もし、リカッティ方程式の式誤差のフロベニウスノルムが`residulaTolerance`より大きいなら、警告メッセージが表示されます。
`static Matrix`	`Rlocus.rlocus(Matrix numerator, Matrix denominator)` 方程式 `num(s) H(s) = 1 + k ---------- = 0 den(s)` の根の軌跡データを返します。
`static Matrix`	`Rlocus.rlocus(Matrix numerator, Matrix denominator, Matrix K)` 各列が `K(i)` に対応する行列を返します。
`static Matrix`	`Rlocus.rlocus(Matrix A, Matrix b, Matrix c, Matrix d)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(Matrix A, Matrix b, Matrix c, Matrix d, Matrix K)` システム `. x = Ax + Bu y = Cx + Du u = -k*y` の根軌跡のデータを返します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomial g, Matrix K)` 根軌跡のデータを計算します。
`static Matrix`	`Rlocus.rlocus(RationalPolynomialMatrix G, Matrix K)` 根軌跡のデータを計算します。
`static List<Matrix>`	`Series.series(Matrix A1, Matrix B1, Matrix C1, Matrix D1, Matrix A2, Matrix B2, Matrix C2, Matrix D2)` システム1 `. x1 = A1 x1 + B1 u1 y1 = C1 x1 + D1 u1` の出力をシステム2 `. x2 = A2 x2 + B2 u2 y2 = C2 x2 + D2 u2` の入力に `-1 -1 u1 ---> C1(sI - A1)B1 ---> y1 ---> u2 ---> C2(sI - A2)B2 ---> y2` のように接続したシステムを生成します。
`static List<Matrix>`	`Ss2tf.ss2tf(Matrix A, Matrix B, Matrix C, Matrix D)`
`static List<Matrix>`	`Ss2tf.ss2tf(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であるシステムの`i`番目の入力から出力までの伝達関数 `NUM(s) -1 G(s) = -------- = C(sI-A) B + D den(s)` の分子行列多項式の係数行列`NUM`と分母多項式の係数 `den`を求めます。
`static RationalPolynomialMatrix`	`Ss2tfm.ss2tfm(Matrix A, Matrix B, Matrix C, Matrix D)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であるシステムの伝達関数行列 `-1 G(s) = C(sI-A) B + D` を有理多項式行列をして返します。
`static RationalPolynomialMatrix`	`Ss2tfm.ss2tfm(Matrix A, Matrix B, Matrix C, Matrix D, boolean simplify)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であるシステムの伝達関数行列 `-1 G(s) = C(sI-A) B + D` を有理多項式行列として返します。
`static RationalPolynomialMatrix`	`Ss2tfm.ss2tfm(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` 状態空間表現されたシステム `. x = Ax + Bu y = Cx + Du` の`i`番目の入力から出力までの伝達関数行列 `-1 G(s) = C(sI-A) B(:,i) + D(:,i)` を求めます。
`static RationalPolynomial`	`Ss2tfn.ss2tfn(Matrix A, Matrix B, Matrix C, Matrix D)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` である1入力1出力のシステムの伝達関数 `-1 g(s) = C(sI-A) B + D` を返します。
`static RationalPolynomial`	`Ss2tfn.ss2tfn(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` 多入力1出力システムの `inputNumber` 番目の入力から出力までの伝達関数を返します。
`static RationalPolynomial`	`Ss2tfn.ss2tfn(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, int outputNumber)` 多入力多出力システムの `inputNumber` 番目の入力から `outputNumber` 番目の出力までの伝達関数を返します。
`static List<Matrix>`	`Ss2zp.ss2zp(Matrix A, Matrix B, Matrix C, Matrix D)` 状態空間表現が `. x = Ax + Bu y = Cx + Du` であり、その伝達関数が `-1 (s-z1)(s-z2)...`
`static List<Matrix>`	`Ss2zp.ss2zp(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber)` `i`番目の入力から出力までの伝達関数のゼロ点、極、ゲインを求めます。
`static List<Matrix>`	`Step.step(LinearSystem system, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(Matrix numerator, Matrix denominator, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(Matrix A, Matrix B, Matrix C, Matrix D, int inputNumber, Matrix T)` 連続時間システム `. x = Ax + Bu y = Cx + Du` の `iu` 番目の入力に単位ステップ入力が加えられた場合のステップ応答を求めます。
`static List<Matrix>`	`Step.step(RationalPolynomial g, Matrix T)` 単位ステップ応答を計算します。
`static List<Matrix>`	`Step.step(RationalPolynomialMatrix G, int inputNumber, Matrix T)` 単位ステップ応答を計算します。
`static Matrix`	`Svfr.svfr(RationalPolynomialMatrix G, Matrix w)`
`static Matrix`	`Svfr.svfr(RationalPolynomialMatrix G, Matrix w, int type)` 入力と出力の数が等しいシステム`G(s)`の周波数応答`G(jw)`の特異値を求めます。
`static List<Matrix>`	`Tf2des.tf2des(Matrix numeratorMatrix, Matrix denominatorMatrix)` 1入力多出力システム(非プロパー) `NUM(s) G(s) = -------- den(s)` の状態空間表現 `.`
`static List<Matrix>`	`Tf2ss.tf2ss(Matrix numeratorMatrix, Matrix denominatorMatrix)` 1入力多出力システム `NUM(s) G(s) = -------- den(s)` の状態空間表現 `. x = Ax + Bu y = Cx + Du` を求めます。
`static RationalPolynomialMatrix`	`Tf2tfm.tf2tfm(Matrix numerator, Matrix denominator)` 1入力多出力システム `NUM(s) G(s) = -------- den(s)` の伝達関数行列を求めます。
`static RationalPolynomialMatrix`	`Tf2tfm.tf2tfm(Matrix numerator, Matrix denominator, boolean simplify)` 1入力多出力システム `NUM(s) G(s) = -------- den(s)` の伝達関数行列を求めます。
`static RationalPolynomial`	`Tf2tfn.tf2tfn(Matrix numeratorCoefficient, Matrix denominatorCoefficient)` 1入力1出力システム `num(s) g(s) = ------- den(s)` の伝達関数を分子多項式の係数`num`と分母多項式の係数`den`から求めます。
`static RationalPolynomial`	`Tf2tfn.tf2tfn(Matrix numeratorCoefficient, Matrix denominatorCoefficient, int inputNumber)` 1入力多出力システムの`i`番目の入力から出力までの伝達関数を求めます。
`static List<Matrix>`	`Tf2zp.tf2zp(Matrix numerator, Matrix deniminator)` 1入力多出力システム `NUM(s) (s-z1)(s-z2)...`
`static Matrix`	`Tzero.tzero(Matrix A, Matrix B, Matrix C, Matrix D)` システム `. x = Ax + Bu y = Cx + Du` の伝達ゼロ点を求めます。
`static List<Matrix>`	`Zp2ss.zp2ss(Matrix z_, Matrix p_, Matrix k)` 極`p`、ゼロ点`z`,ゲイン`k`であるシステム `(s-z1)(s-z2)...`
`static List<Matrix>`	`Zp2tf.zp2tf(Matrix zeros, Matrix poles, Matrix k)` 極`p`、ゼロ点`z`,ゲイン`k`である1入力多出力システム `NUM(s) (s-z1)(s-z2)...`
`static RationalPolynomialMatrix`	`Zp2tfm.zp2tfm(Matrix zeros, Matrix poles, Matrix k)` 極`p`、ゼロ点`z`,ゲイン`k`である1入力多出力システム `(s-z1)(s-z2)...`
`static RationalPolynomial`	`Zp2tfn.zp2tfn(Matrix zeros, Matrix poles, Matrix gain)` 極`p`、ゼロ点`z`、ゲイン`k`である1入力1出力システム `(s-z1)(s-z2)...`
`static RationalPolynomial`	`Zp2tfn.zp2tfn(Matrix zeros, Matrix poles, Matrix gain, int outputNumber)` 1入力多出力システムの`inputNumber`番目の入力から出力までの伝達関数を返します。

org.mklab.tool.control.system での Matrix の使用

Matrix を返す org.mklab.tool.control.system のメソッド
`protected abstract Matrix`	`BlockSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)` 直達項のあるシステムの出力を求めます。
`protected abstract Matrix`	`BlockSystem.calcOutputOfNonDirectFeedthroughSystem(SystemOperator system)` 直達項の無いシステムの出力を求めます。
`Matrix`	`LinearSystemOperator.getA()` システム行列Aを返します。
`Matrix`	`LinearSystemOperator.getB()` 入力行列Bを返します。
`Matrix`	`LinearSystemOperator.getC()` 出力行列Cを返します。
`Matrix`	`ControlSystem.getContinuousInitialState()` 連続時間部分システムの初期状態を返します。
`Matrix`	`ControlSystem.getContinuousState()` 連続時間部分システムの現在の状態を返します。
`Matrix`	`LinearSystemOperator.getD()` ゲイン行列Dを返します。
`Matrix`	`ControlSystem.getDiscreteInitialState()` 離散時間部分システムの初期状態を返します。
`Matrix`	`ControlSystem.getDiscreteState()` 離散時間部分システムの現在の状態を返します。
`Matrix`	`DynamicSystem.getInitialState()` 初期状態を返します。
`Matrix`	`ControlSystem.getInitialState()` 初期状態を返します。
`Matrix`	`BlockSystem.getInputNodeValueOf(SystemOperator system)` システムへ入力するノードの値を返します。
`protected Matrix`	`BlockSystem.getOutputNodeValue()` 出力ノードの値を返します。
`Matrix`	`DynamicSystem.getState()` 現在の状態を返します。
`Matrix`	`ControlSystem.getState()` 現在の状態を返します。
`Matrix`	`StaticSystem.outputEquation(double t)` 直達項をもたないシステムの出力を返します。
`Matrix`	`StaticSystem.outputEquation(double t, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`DynamicSystem.outputEquation(double t, Matrix x)` 直達項をもたないシステムの出力を返します。
`Matrix`	`DynamicSystem.outputEquation(double t, Matrix x, Matrix u)` 直達項をもつシステムの出力を返します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system のメソッド
`boolean`	`BlockSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator[][] matrix, Matrix[] localNodeValue, Matrix[] nodeTmpValue, boolean skip)` 確定したノードの値を用いて各直達項の有るシステムの出力を計算し、その値を仮のノードへ加えます。
`boolean`	`BlockSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator[][] matrix, Matrix[] localNodeValue, Matrix[] nodeTmpValue, boolean skip)` 確定したノードの値を用いて各直達項の有るシステムの出力を計算し、その値を仮のノードへ加えます。
`protected abstract Matrix`	`BlockSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)` 直達項のあるシステムの出力を求めます。
`Matrix`	`StaticSystem.outputEquation(double t, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`DynamicSystem.outputEquation(double t, Matrix x)` 直達項をもたないシステムの出力を返します。
`Matrix`	`DynamicSystem.outputEquation(double t, Matrix x, Matrix u)` 直達項をもつシステムの出力を返します。
`void`	`DynamicSystem.setInitialState(Matrix initialState)` 初期状態を設定します。
`void`	`ControlSystem.setInitialState(Matrix initialState)` 初期状態を設定します。
`void`	`BlockSystem.setInputNodeValue(Matrix u)` 入力ノードに値を設定します。
`void`	`BlockSystem.setNodeValueOfNoInputNode(SystemOperator[][] matrix, Matrix[] nodeValue, Matrix[] nodeTmpValue, boolean skipping)` 他のノードから入るエッジがないノードの値を確定します。
`void`	`BlockSystem.setNodeValueOfNoInputNode(SystemOperator[][] matrix, Matrix[] nodeValue, Matrix[] nodeTmpValue, boolean skipping)` 他のノードから入るエッジがないノードの値を確定します。
`void`	`DynamicSystem.setState(Matrix state)` 現在の状態の設定します。

org.mklab.tool.control.system.continuous での Matrix の使用

Matrix を返す org.mklab.tool.control.system.continuous のメソッド
`protected Matrix`	`BlockContinuousSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`protected Matrix`	`BlockContinuousSystem.calcOutputOfNonDirectFeedthroughSystem(SystemOperator system)`
`Matrix`	`BlockContinuousDynamicSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseContinuousDynamicSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`ContinuousLinearDynamicSystem.getA()`
`Matrix`	`ContinuousLinearDynamicSystem.getB()`
`Matrix`	`ContinuousLinearDynamicSystem.getC()`
`Matrix`	`ContinuousLinearDynamicSystem.getD()`
`Matrix`	`TransportDelay.getInitialOutput()` 初期出力を返します。
`Matrix`	`BlockContinuousDynamicSystem.getInitialState()`
`Matrix`	`BaseContinuousDynamicSystem.getInitialState()`
`Matrix`	`BlockContinuousDynamicSystem.getState()`
`Matrix`	`BaseContinuousDynamicSystem.getState()`
`Matrix`	`BlockContinuousStaticSystem.inputOutputEquation(double t)`
`Matrix`	`BaseContinuousStaticSystem.inputOutputEquation(double t)`
`Matrix`	`BlockContinuousDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BaseContinuousDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`UserDefinedContinuousStaticSystem.outputEquation(double t)`
`Matrix`	`BlockContinuousStaticSystem.outputEquation(double t)`
`Matrix`	`BaseContinuousStaticSystem.outputEquation(double t)`
`Matrix`	`UserDefinedContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`UserDefinedContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`TransportDelay.outputEquation(double t, Matrix u)`
`Matrix`	`DerivativeSystem.outputEquation(double t, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BlockContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BaseContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`UserDefinedContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BlockContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`UserDefinedContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)` 状態の微分を返します。
`Matrix`	`BlockContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.continuous のメソッド
`protected Matrix`	`BlockContinuousSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`Matrix`	`BlockContinuousDynamicSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseContinuousDynamicSystem.differentialEquation(double t, Matrix x, Matrix inputOutput)`
`double`	`BlockPiecewiseContinuousStaticSystem.getDiscontinuousPoint(double t1, Matrix input1, double t2, Matrix input2)`
`double`	`BlockPiecewiseContinuousDynamicSystem.getDiscontinuousPoint(double t1, Matrix state1, Matrix input1, double t2, Matrix state2, Matrix input2)`
`List<Integer>`	`BlockPiecewiseContinuousStaticSystem.getPiece(double t, Matrix u)`
`List<Integer>`	`BlockPiecewiseContinuousDynamicSystem.getPiece(double t, Matrix state, Matrix input)`
`Matrix`	`BlockContinuousDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BaseContinuousDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`UserDefinedContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`UserDefinedContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`TransportDelay.outputEquation(double t, Matrix u)`
`Matrix`	`DerivativeSystem.outputEquation(double t, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BlockContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BaseContinuousStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseContinuousDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`UserDefinedContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BlockContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseContinuousDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`void`	`TransportDelay.setInitialOutput(Matrix initialOutput)` 初期出力を設定します。
`void`	`DerivativeSystem.setInitialOutput(Matrix initialOutput)` 初期出力を設定します。
`void`	`IntegratorSystem.setInitialState(Matrix initialState)`
`void`	`BlockContinuousDynamicSystem.setInitialState(Matrix initialState)`
`void`	`BaseContinuousDynamicSystem.setInitialState(Matrix initialState)`
`void`	`BlockContinuousDynamicSystem.setState(Matrix state)`
`void`	`BaseContinuousDynamicSystem.setState(Matrix state)`
`Matrix`	`UserDefinedContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousLinearDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`ContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)` 状態の微分を返します。
`Matrix`	`BlockContinuousDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.continuous のコンストラクタ
`ContinuousLinearDynamicSystem(Matrix A, Matrix B, Matrix C)` 新しく生成された`ContinuousLinearDynamicSystem`オブジェクトを初期化します。
`ContinuousLinearDynamicSystem(Matrix A, Matrix B, Matrix C, Matrix D)` 新しく生成された`ContinuousLinearDynamicSystem`オブジェクトを初期化します。
`TransportDelay(double timeDelay, Matrix initialOutput)` 新しく生成された`TransportDelay`オブジェクトを初期化します。
`UserDefinedContinuousLinearDynamicSystem(Matrix a, Matrix b, Matrix c, Matrix d)` 新しく生成された`UserDefinedContinuousLinearDynamicSystem`オブジェクトを初期化します。

org.mklab.tool.control.system.controller での Matrix の使用

Matrix を返す org.mklab.tool.control.system.controller のメソッド
`Matrix`	`LqServoDesigner.getIntegratorGain()` 入力外乱に対するLQ最適サーボのための積分ゲイン行列を返します。
`Matrix`	`PolePlaceDesigner.getStateFeedback()` 極配置のための状態フィードバック行列を返します。
`Matrix`	`LqServoDesigner.getStateFeedback()` 入力外乱に対するLQ最適サーボのための状態フィードバック行列を返します。
`Matrix`	`LqrDesigner.getStateFeedback()` LQ最適制御のための状態フィードバック行列を返します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system.controller のメソッド
`void`	`PoleViewer.plot(Matrix F, LinearSystemOperator observer)` 閉ループ系の極とオブザーバの極を複素平面にプロットします。
`void`	`PolePlaceStateFeedback.setClosedLoopPoles(Matrix closedLoopPoles)` 閉ループ系の指定極を設定します。
`void`	`PolePlaceDesigner.setClosedLoopPoles(Matrix closedLoopPoles)` 閉ループ系の指定極を設定します。
`void`	`DiscreteObserverDesigner.setContinuousObserverPoles(Matrix continuousObserverPoles)` 連続時間オブザーバーの極を設定します。
`void`	`DiscreteObserver.setContinuousObserverPoles(Matrix continuousObserverPoles)` 連続時間オブザーバーの極を設定します。
`void`	`ObserverDesigner.setObserverPoles(Matrix observerPoles)` オブザーバーの極を設定します。
`void`	`ContinuousObserver.setObserverPoles(Matrix observerPoles)` オブザーバーの極を設定します。
`void`	`LqServoDesigner.setWeightingMatrices(Matrix Qe, Matrix Re)` 重み行列QeとReを設定します。
`void`	`LqrDesigner.setWeightingMatrices(Matrix Q, Matrix R)` 重み行列QとRを設定します。

org.mklab.tool.control.system.discontinuous での Matrix の使用

Matrix を返す org.mklab.tool.control.system.discontinuous のメソッド
`Matrix`	`Saturation.outputEquation(double t, Matrix u)`
`Matrix`	`RateLimiter.outputEquation(double t, Matrix u)`
`Matrix`	`Quantizer.outputEquation(double t, Matrix u)`
`Matrix`	`DeadZone.outputEquation(double t, Matrix u)`
`Matrix`	`CoulombViscousFriction.outputEquation(double t, Matrix u)`
`Matrix`	`Backlash.outputEquation(double t, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.discontinuous のメソッド
`double`	`Saturation.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`RateLimiter.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`Quantizer.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`DeadZone.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`CoulombViscousFriction.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`Backlash.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`List<Integer>`	`Saturation.getPiece(double t, Matrix u)`
`List<Integer>`	`RateLimiter.getPiece(double t, Matrix u)`
`List<Integer>`	`Quantizer.getPiece(double t, Matrix u)`
`List<Integer>`	`DeadZone.getPiece(double t, Matrix u)`
`List<Integer>`	`CoulombViscousFriction.getPiece(double t, Matrix u)`
`List<Integer>`	`Backlash.getPiece(double t, Matrix u)`
`Matrix`	`Saturation.outputEquation(double t, Matrix u)`
`Matrix`	`RateLimiter.outputEquation(double t, Matrix u)`
`Matrix`	`Quantizer.outputEquation(double t, Matrix u)`
`Matrix`	`DeadZone.outputEquation(double t, Matrix u)`
`Matrix`	`CoulombViscousFriction.outputEquation(double t, Matrix u)`
`Matrix`	`Backlash.outputEquation(double t, Matrix u)`
`void`	`RateLimiter.setInitialOutput(Matrix initialOutput)` 初期出力を設定します。
`void`	`Backlash.setInitialOutput(Matrix initialOutput)` 初期出力を設定します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system.discontinuous のコンストラクタ
`Backlash(double rateLowerBound, Matrix initialOutput)` 新しく生成された`Saturation`オブジェクトを初期化します。

org.mklab.tool.control.system.discrete での Matrix の使用

Matrix を返す org.mklab.tool.control.system.discrete のメソッド
`protected Matrix`	`BlockDiscreteSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`protected Matrix`	`BlockDiscreteSystem.calcOutputOfNonDirectFeedthroughSystem(SystemOperator system)`
`Matrix`	`BlockDiscreteDynamicSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseDiscreteDynamicSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BlockDiscreteDynamicSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseDiscreteDynamicSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)`
`Matrix`	`DiscreteLinearDynamicSystem.getA()`
`Matrix`	`DiscreteLinearDynamicSystem.getB()`
`Matrix`	`DiscreteLinearDynamicSystem.getC()`
`Matrix`	`DiscreteLinearDynamicSystem.getD()`
`Matrix`	`BlockDiscreteDynamicSystem.getInitialState()`
`Matrix`	`BaseDiscreteDynamicSystem.getInitialState()` 初期状態を返します。
`Matrix`	`HoldSystem.getState()` 状態を返します。
`Matrix`	`BlockDiscreteDynamicSystem.getState()`
`Matrix`	`BaseDiscreteDynamicSystem.getState()` 現在の状態を返します。
`Matrix`	`BlockDiscreteStaticSystem.inputOutputEquation(double t)`
`Matrix`	`BaseDiscreteStaticSystem.inputOutputEquation(double t)`
`Matrix`	`BlockDiscreteDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BaseDiscreteDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BlockDiscreteStaticSystem.inputOutputEquation(int k)`
`Matrix`	`BaseDiscreteStaticSystem.inputOutputEquation(int k)`
`Matrix`	`BlockDiscreteDynamicSystem.inputOutputEquation(int k, Matrix x)`
`Matrix`	`BaseDiscreteDynamicSystem.inputOutputEquation(int k, Matrix x)`
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(double t)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(double t)`
`Matrix`	`ZeroOrderHoldSystem.outputEquation(double t, Matrix u)`
`Matrix`	`FirstOrderHoldSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`UserDefinedDiscreteStaticSystem.outputEquation(int k)`
`Matrix`	`DiscreteStaticSystem.outputEquation(int k)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(int k)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(int k)`
`Matrix`	`UserDefinedDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`DiscreteStaticSystem.outputEquation(int k, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`DiscreteLinearDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`DiscreteDynamicSystem.outputEquation(int k, Matrix x)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteLinearDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteDynamicSystem.stateEquation(double t, Matrix x, Matrix u)` `(t/T+1)`ステップの状態を返します。
`Matrix`	`BlockDiscreteDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.stateEquation(double t, Matrix xd, Matrix inputOutput)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteLinearDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)` `(k+1)`ステップの状態を返します。
`Matrix`	`BlockDiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.discrete のメソッド
`protected Matrix`	`BlockDiscreteSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`Matrix`	`BlockDiscreteDynamicSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseDiscreteDynamicSystem.differenceEquation(double t, Matrix x, Matrix inputOutput)`
`Matrix`	`BlockDiscreteDynamicSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)`
`Matrix`	`BaseDiscreteDynamicSystem.differenceEquation(int k, Matrix x, Matrix inputOutput)`
`Matrix`	`BlockDiscreteDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BaseDiscreteDynamicSystem.inputOutputEquation(double t, Matrix x)`
`Matrix`	`BlockDiscreteDynamicSystem.inputOutputEquation(int k, Matrix x)`
`Matrix`	`BaseDiscreteDynamicSystem.inputOutputEquation(int k, Matrix x)`
`Matrix`	`ZeroOrderHoldSystem.outputEquation(double t, Matrix u)`
`Matrix`	`FirstOrderHoldSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(double t, Matrix x)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(double t, Matrix x, Matrix u)`
`Matrix`	`UserDefinedDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`DiscreteStaticSystem.outputEquation(int k, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`DiscreteLinearDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`DiscreteDynamicSystem.outputEquation(int k, Matrix x)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`BaseDiscreteStaticSystem.outputEquation(int k, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(int k, Matrix x)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteLinearDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.outputEquation(int k, Matrix x, Matrix u)`
`void`	`UnitDelaySystem.setInitialState(Matrix initialState)`
`void`	`BlockDiscreteDynamicSystem.setInitialState(Matrix initialState)`
`void`	`BaseDiscreteDynamicSystem.setInitialState(Matrix initialState)` 初期状態を設定します。
`void`	`HoldSystem.setState(Matrix state)` 状態を設定します。
`void`	`BlockDiscreteDynamicSystem.setState(Matrix state)`
`void`	`BaseDiscreteDynamicSystem.setState(Matrix state)` 現在の状態の設定します。
`Matrix`	`DiscreteDynamicSystem.stateEquation(double t, Matrix x, Matrix u)` `(t/T+1)`ステップの状態を返します。
`Matrix`	`BlockDiscreteDynamicSystem.stateEquation(double t, Matrix x, Matrix u)`
`Matrix`	`BaseDiscreteDynamicSystem.stateEquation(double t, Matrix xd, Matrix inputOutput)`
`Matrix`	`UserDefinedDiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteLinearDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`
`Matrix`	`DiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)` `(k+1)`ステップの状態を返します。
`Matrix`	`BlockDiscreteDynamicSystem.stateEquation(int k, Matrix x, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.discrete のコンストラクタ
`DiscreteLinearDynamicSystem(Matrix A, Matrix B, Matrix C)` 新しく生成された`DiscreteLinearDynamicSystem`オブジェクトを初期化します。
`DiscreteLinearDynamicSystem(Matrix A, Matrix B, Matrix C, Matrix D)` 新しく生成された`DiscreteLinearDynamicSystem`オブジェクトを初期化します。
`UserDefinedDiscreteLinearDynamicSystem(Matrix A, Matrix B, Matrix C, Matrix D)` 新しく生成された`UserDefinedContinuousLinearDynamicSystem`オブジェクトを初期化します。

org.mklab.tool.control.system.graph での Matrix の使用

Matrix として宣言されている org.mklab.tool.control.system.graph のフィールド
`protected Matrix[]`	`NodeIdentityFunctionEquation.nodeTmpValue` ノードの仮の値
`protected Matrix[]`	`NodeEquation.nodeTmpValue` ノードの仮の値

Matrix 型のパラメータを持つ org.mklab.tool.control.system.graph のメソッド
`protected void`	`NodeIdentityFunctionEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。
`protected void`	`NodeIdentityFunctionEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。
`protected void`	`NodeIdentityFunctionEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。
`protected void`	`NodeEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。
`protected void`	`NodeEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。
`protected void`	`NodeEquation.calcNonMinimumNodeValues(Matrix[] nodeValue, Matrix[] xx, SystemOperator[][] matrixLocal, Matrix[] nodeTmpValueLocal)` 与えられた次数最小ノードの値から他のノードの値を計算します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system.graph のコンストラクタ
`NodeEquation(BlockSystem blockSystem, SystemOperator[][] matrix, Matrix[] nodeTmpValue, List<Integer> minimumNode)` 新しく生成された`NodeEquation`オブジェクトを初期化します。
`NodeIdentityFunctionEquation(BlockSystem blockSystem, SystemOperator[][] matrix, Matrix[] nodeTmpValue, List<Integer> minimumNode)` 新しく生成された`NodeEquation`オブジェクトを初期化します。

org.mklab.tool.control.system.math での Matrix の使用

Matrix を返す org.mklab.tool.control.system.math のメソッド
`Matrix`	`ConstantSystem.getA()`
`Matrix`	`ConstantSystem.getB()`
`Matrix`	`BiasFunction.getBias()` バイアスを返します。
`Matrix`	`ConstantSystem.getC()`
`Matrix`	`ConstantSystem.getD()`
`Matrix`	`ConstantSystem.getGain()` 定数ゲイン行列を返します。
`Matrix`	`LookupTable.getInputData()` 入力データを返します。
`Matrix`	`ConstantSystem.getOperandValue()`
`Matrix`	`LookupTable.getOutputData()` 出力データを返します。
`Matrix`	`UnaryMinusFunction.outputEquation(double t, Matrix u)`
`Matrix`	`TrigonometricFunction.outputEquation(double t, Matrix u)`
`Matrix`	`SignumFunction.outputEquation(double t, Matrix u)`
`Matrix`	`Product.outputEquation(double t, Matrix u)`
`Matrix`	`Multiplexer.outputEquation(double t, Matrix u)`
`Matrix`	`MathematicalFunction.outputEquation(double t, Matrix u)`
`Matrix`	`LookupTable.outputEquation(double t, Matrix u)`
`Matrix`	`DeMultiplexer.outputEquation(double t, Matrix u)`
`Matrix`	`ConstantSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BiasFunction.outputEquation(double t, Matrix u)`
`Matrix`	`AbsoluteFunction.outputEquation(double t, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.math のメソッド
`double`	`SignumFunction.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`AbsoluteFunction.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`List<Integer>`	`SignumFunction.getPiece(double t, Matrix u)`
`List<Integer>`	`AbsoluteFunction.getPiece(double t, Matrix u)`
`Matrix`	`UnaryMinusFunction.outputEquation(double t, Matrix u)`
`Matrix`	`TrigonometricFunction.outputEquation(double t, Matrix u)`
`Matrix`	`SignumFunction.outputEquation(double t, Matrix u)`
`Matrix`	`Product.outputEquation(double t, Matrix u)`
`Matrix`	`Multiplexer.outputEquation(double t, Matrix u)`
`Matrix`	`MathematicalFunction.outputEquation(double t, Matrix u)`
`Matrix`	`LookupTable.outputEquation(double t, Matrix u)`
`Matrix`	`DeMultiplexer.outputEquation(double t, Matrix u)`
`Matrix`	`ConstantSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BiasFunction.outputEquation(double t, Matrix u)`
`Matrix`	`AbsoluteFunction.outputEquation(double t, Matrix u)`
`void`	`BiasFunction.setBias(Matrix bias)` バイアスを設定します。
`void`	`ConstantSystem.setGain(Matrix gain)` 定数ゲイン行列を設定します。
`void`	`LookupTable.setInputData(Matrix inputData)` 入力データを設定します。
`void`	`LookupTable.setOutputData(Matrix outputData)` 出力データを設定します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system.math のコンストラクタ
`ConstantSystem(Matrix gain)` 新しく生成された`ConstantSystem`オブジェクトを初期化します。
`UserDefinedConstantSystem(Matrix gain)` 新しく生成された`UserDefinedConstantSystem`オブジェクトを初期化します。

org.mklab.tool.control.system.sampled での Matrix の使用

Matrix を返す org.mklab.tool.control.system.sampled のメソッド
`protected Matrix`	`BlockSampledDataSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`protected Matrix`	`BlockSampledDataSystem.calcOutputOfNonDirectFeedthroughSystem(SystemOperator system)`
`Matrix`	`SampledDataDynamicSystem.continuousStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 連続時間システムの状態の微分を返します。
`Matrix`	`BlockSampledDataDynamicSystem.continuousStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BlockSampledDataDynamicSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BaseSampledDataDynamicSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BlockSampledDataDynamicSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BaseSampledDataDynamicSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`SampledDataDynamicSystem.discreteStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 離散時間システムの次ステップの状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.discreteStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`SampledDataDynamicSystem.getContinuousInitialState()` 連続時間システムの初期状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.getContinuousInitialState()`
`Matrix`	`BaseSampledDataDynamicSystem.getContinuousInitialState()`
`Matrix`	`SampledDataDynamicSystem.getContinuousState()` 現在の連続時間システムの状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.getContinuousState()`
`Matrix`	`BaseSampledDataDynamicSystem.getContinuousState()`
`Matrix`	`SampledDataDynamicSystem.getDiscreteInitialState()` 離散時間システムの初期状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.getDiscreteInitialState()`
`Matrix`	`BaseSampledDataDynamicSystem.getDiscreteInitialState()`
`Matrix`	`SampledDataDynamicSystem.getDiscreteState()` 現在の離散時間システムの状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.getDiscreteState()`
`Matrix`	`BaseSampledDataDynamicSystem.getDiscreteState()`
`Matrix`	`BlockSampledDataStaticSystem.inputOutputEquation(double t)`
`Matrix`	`BlockSampledDataDynamicSystem.inputOutputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`SampledDataStaticSystem.outputEquation(double t)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockSampledDataStaticSystem.outputEquation(double t)`
`Matrix`	`BaseSampledDataStaticSystem.outputEquation(double t)`
`Matrix`	`SampledDataStaticSystem.outputEquation(double t, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockSampledDataStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseSampledDataStaticSystem.outputEquation(double t, Matrix input)`
`Matrix`	`SampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`BaseSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`SampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix input)`
`Matrix`	`BaseSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.sampled のメソッド
`protected Matrix`	`BlockSampledDataSystem.calcOutputOfDirectFeedthroughSystem(SystemOperator system, Matrix u)`
`Matrix`	`SampledDataDynamicSystem.continuousStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 連続時間システムの状態の微分を返します。
`Matrix`	`BlockSampledDataDynamicSystem.continuousStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BlockSampledDataDynamicSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BaseSampledDataDynamicSystem.differenceEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BlockSampledDataDynamicSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`BaseSampledDataDynamicSystem.differentialEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`Matrix`	`SampledDataDynamicSystem.discreteStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)` 離散時間システムの次ステップの状態を返します。
`Matrix`	`BlockSampledDataDynamicSystem.discreteStateEquation(double t, Matrix xc, Matrix xd, Matrix inputOutput)`
`double`	`BlockPiecewiseSampledDataStaticSystem.getDiscontinuousPoint(double t1, Matrix input1, double t2, Matrix input2)`
`double`	`BlockPiecewiseSampledDataDynamicSystem.getDiscontinuousPoint(double t1, Matrix continuousState1, Matrix discreteState1, Matrix u1, double t2, Matrix continuousState2, Matrix discreteState2, Matrix u2)`
`List<Integer>`	`BlockPiecewiseSampledDataStaticSystem.getPiece(double t, Matrix u)`
`List<Integer>`	`BlockPiecewiseSampledDataDynamicSystem.getPiece(double t, Matrix continuousState, Matrix discreteState, Matrix u)`
`Matrix`	`BlockSampledDataDynamicSystem.inputOutputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`SampledDataStaticSystem.outputEquation(double t, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockSampledDataStaticSystem.outputEquation(double t, Matrix u)`
`Matrix`	`BaseSampledDataStaticSystem.outputEquation(double t, Matrix input)`
`Matrix`	`SampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)` 直達項をもたないシステムの出力を返します。
`Matrix`	`BlockSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`BaseSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd)`
`Matrix`	`SampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix u)` 直達項をもつシステムの出力を返します。
`Matrix`	`BlockSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix input)`
`Matrix`	`BaseSampledDataDynamicSystem.outputEquation(double t, Matrix xc, Matrix xd, Matrix u)`
`void`	`SampledDataDynamicSystem.setContinuousInitialState(Matrix initialState)` 連続時間システムの初期状態を設定します。
`void`	`BlockSampledDataDynamicSystem.setContinuousInitialState(Matrix initialState)`
`void`	`BaseSampledDataDynamicSystem.setContinuousInitialState(Matrix initialState)`
`void`	`SampledDataDynamicSystem.setContinuousState(Matrix state)` 現在の連続時間システムの状態の設定します。
`void`	`BlockSampledDataDynamicSystem.setContinuousState(Matrix state)`
`void`	`BaseSampledDataDynamicSystem.setContinuousState(Matrix state)`
`void`	`SampledDataDynamicSystem.setDiscreteInitialState(Matrix initialState)` 離散時間システムの初期状態を設定します。
`void`	`BlockSampledDataDynamicSystem.setDiscreteInitialState(Matrix initialState)`
`void`	`BaseSampledDataDynamicSystem.setDiscreteInitialState(Matrix initialState)`
`void`	`SampledDataDynamicSystem.setDiscreteState(Matrix state)` 現在の離散時間システムの状態の設定します。
`void`	`BlockSampledDataDynamicSystem.setDiscreteState(Matrix state)`
`void`	`BaseSampledDataDynamicSystem.setDiscreteState(Matrix state)`

org.mklab.tool.control.system.sink での Matrix の使用

Matrix を返す org.mklab.tool.control.system.sink のメソッド
`Matrix`	`UserDefinedContinuousSink.outputEquation(double t, Matrix u)`
`Matrix`	`Terminator.outputEquation(double t, Matrix u)`
`Matrix`	`Restrictor.outputEquation(double t, Matrix u)`
`Matrix`	`ExportSink.outputEquation(double t, Matrix u)`
`Matrix`	`DisplaySink.outputEquation(double t, Matrix u)`
`Matrix`	`ContinuousSink.outputEquation(double t, Matrix u)`
`Matrix`	`UserDefinedDiscreteSink.outputEquation(int k, Matrix u)`
`Matrix`	`DiscreteSink.outputEquation(int k, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.sink のメソッド
`void`	`Display.display(double t, Matrix u)` 出力を表示します。
`double`	`Restrictor.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`List<Integer>`	`Restrictor.getPiece(double t, Matrix u)`
`Matrix`	`UserDefinedContinuousSink.outputEquation(double t, Matrix u)`
`Matrix`	`Terminator.outputEquation(double t, Matrix u)`
`Matrix`	`Restrictor.outputEquation(double t, Matrix u)`
`Matrix`	`ExportSink.outputEquation(double t, Matrix u)`
`Matrix`	`DisplaySink.outputEquation(double t, Matrix u)`
`Matrix`	`ContinuousSink.outputEquation(double t, Matrix u)`
`Matrix`	`UserDefinedDiscreteSink.outputEquation(int k, Matrix u)`
`Matrix`	`DiscreteSink.outputEquation(int k, Matrix u)`

org.mklab.tool.control.system.source での Matrix の使用

Matrix を返す org.mklab.tool.control.system.source のメソッド
`Matrix`	`ConstantSource.getConstant()` 定数を返します。
`protected Matrix`	`FixedRateAsynchronousSource.getOutput(double t)`
`protected abstract Matrix`	`AsynchronousSource.getOutput(double t)` 与えられた時間の入力を取得します。
`Matrix`	`UserDefinedContinuousSource.outputEquation(double t)`
`Matrix`	`UniformRandomSource.outputEquation(double t)`
`Matrix`	`StepSource.outputEquation(double t)`
`Matrix`	`SineWaveSource.outputEquation(double t)`
`Matrix`	`RampSource.outputEquation(double t)`
`Matrix`	`PulseSource.outputEquation(double t)`
`Matrix`	`PeriodicSource.outputEquation(double t)`
`Matrix`	`NormalRandomSource.outputEquation(double t)`
`Matrix`	`ImportSource.outputEquation(double t)`
`Matrix`	`Ground.outputEquation(double t)`
`Matrix`	`ConstantSource.outputEquation(double t)`
`Matrix`	`ClockSource.outputEquation(double t)` 時刻を出力します。
`Matrix`	`AsynchronousSource.outputEquation(double t)`
`Matrix`	`ContinuousSource.outputEquation(double t, Matrix u)`
`Matrix`	`UserDefinedDiscreteSource.outputEquation(int k)`
`Matrix`	`DiscreteSource.outputEquation(int k, Matrix u)`

Matrix 型のパラメータを持つ org.mklab.tool.control.system.source のメソッド
`double`	`StepSource.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`RampSource.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`PulseSource.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`double`	`PeriodicSource.getDiscontinuousPoint(double t1, Matrix u1, double t2, Matrix u2)`
`List<Integer>`	`StepSource.getPiece(double t, Matrix u)`
`List<Integer>`	`RampSource.getPiece(double t, Matrix u)`
`List<Integer>`	`PulseSource.getPiece(double t, Matrix u)`
`List<Integer>`	`PeriodicSource.getPiece(double t, Matrix u)`
`Matrix`	`ContinuousSource.outputEquation(double t, Matrix u)`
`Matrix`	`DiscreteSource.outputEquation(int k, Matrix u)`
`void`	`ConstantSource.setConstant(Matrix constant)` 定数を設定します。

Matrix 型のパラメータを持つ org.mklab.tool.control.system.source のコンストラクタ
`ConstantSource(Matrix constant)` 新しく生成された`ConstantSource`オブジェクトを初期化します。
`PeriodicSource(DoubleMatrix timeValues, Matrix outputValues)` 新しく生成された`PeriodicSource`オブジェクトを初期化します。

org.mklab.tool.matrix での Matrix の使用

Matrix を返す org.mklab.tool.matrix のメソッド
`static Matrix`	`Chol.chol(Matrix X)` 対称行列`X`のコレスキー分解を計算します。
`static Matrix`	`Conv.conv(Matrix x, Matrix y)` ベクトル`x`と`y`の畳み込み(多項式の積)を求める計算結果のベクトルの長さは、 `(length(x)+length(y)-1)`です。
`static Matrix`	`Corrcoef.corrcoefColumnWise(Matrix x)` 行列`x`(列毎に各変数のデータ並ぶ)の成分の相関係数を返します。
`static Matrix`	`Corrcoef.corrcoefColumnWise(Matrix x, Matrix y)` `corrcoef_col([x y])`と同じです。
`static Matrix`	`Corrcoef.corrcoefRowWise(Matrix x)` 行列`x`(行毎に各変数のデータ並ぶ)の成分の相関係数を返します。
`static Matrix`	`Corrcoef.corrcoefRowWise(Matrix x, Matrix y)` `corrcoef_row([x y])`と同じです。
`static Matrix`	`Cov.covColumnWise(Matrix x)` もし`x` が行毎データが並ぶ行列なら、分散行列を返します。
`static Matrix`	`Cov.covColumnWise(Matrix x, Matrix y)`
`static Matrix`	`Cov.covRowWise(Matrix x)` もし `x` が、列毎にデータ並ぶ行列なら、分散行列を返します。
`static Matrix`	`Cov.covRowWise(Matrix x, Matrix y)`
`static Matrix`	`Diag.diag(Matrix a1, Matrix a2)` `a1`と`a2`が対角に並ぶ対角行列を求める
`static Matrix`	`Diag.diag(Matrix a1, Matrix a2, Matrix a3)` `a1`、`a2`、`a3`が対角に並ぶ対角行列を求める
`static Matrix`	`DiagVec.diagVec(Matrix A)` もし`A`が正方行列なら、`A`の対角成分が並ぶ縦ベクトルを返します。
`static Matrix`	`DiagVec.diagVec(Matrix A_, int k)` もし`A`が正方行列なら、 `A`の`k`次対角成分(`k > 0 ?`
`static Matrix`	`Diff.diff(Matrix x)` もし `x` がベクトルなら、隣り合う成分の差からなるベクトル `[x(2)-x(1) x(3)-x(2) ... x(n)-x(n-1)]` を返します。
`static Matrix`	`Diff.diff(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Diff.diffColumnWise(Matrix x)` もし `x` が行列なら、列毎に差分 `diff_col(x) = x(2:n,:) - x(1:n-1,:).`
`static Matrix`	`Diff.diffColumnWise(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Diff.diffRowWise(Matrix x)` もし `x` が行列なら、行毎に差分 `diff_row(x) = x(:,2:n) - x(:,1:n-1).`
`static Matrix`	`Diff.diffRowWise(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Erf.erf(NumericalMatrixOperator<?> x1_)` ベクトル`x`の成分の誤差関数を計算します。
`static Matrix`	`Erf.erf(NumericalMatrixOperator<?> x1_, NumericalMatrixOperator<?> x2_)` `x1`から`x2`まで積分した誤差関数 `erf(x1,x2) = 2/sqrt(PI) integral(x1,x2) exp(-tˆ2)` の値を返します。
`static Matrix`	`Eval.eval(Polynomial p, Matrix w)` 多項式の評価を計算する
`static Matrix`	`Eval.eval(RationalPolynomial g, Matrix w)` 有理多項式の評価を計算する
`static Matrix`	`Fftshift.fftshift(Matrix X)` もし `X` がベクトルなら、前半と後半を入れ替えたベクトルを返します。
`static Matrix`	`Gammac.gammac(NumericalMatrixOperator<?> x)` `x`の成分について完全ガンマ関数の値を返します。
`static Matrix`	`Gammaf.gammaf(NumericalMatrixOperator<?> a)` `a`の全ての成分について、完全ガンマ関数の値を返します。
`static Matrix`	`Gammaf.gammaf(NumericalMatrixOperator<?> a_, NumericalMatrixOperator<?> x_)` `a`の成分について、不完全ガンマ関数の値(`X`まで積分した値) を返します。
`static Matrix`	`Gammai.gammai(NumericalMatrixOperator<?> a, NumericalScalar<?> x)` `a` の成分について、不完全ガンマ関数の値( `x`
`static Matrix`	`Givens.givens(NumericalScalar<?> x, NumericalScalar<?> y)` 2×2の複素ギブンス回転行列 `\| c s \| \| x \| \| r \| G = \| \| ただし G * \| \| = \| \| \|-conj(s) c \| \| y \| \| 0 \|` を返します。
`static Matrix`	`Hadamard.hadamard(int size)` `2^size`次のアダマール行列を返します。
`static Matrix`	`Hankel.hankel(Matrix x_)` 第1列が`x`であり、第1非対角より下の成分がゼロであるハンンケル行列を返します。
`static Matrix`	`Hankel.hankel(Matrix x_, Matrix y_)` 第1列が`x`であり、最終行が`y`であるハンンケル行列を返します。
`static Matrix`	`Hilbert.hilbert(int size)` `size`×`size`のヒルベルト行列を返します。
`static Matrix`	`Idft.idft(Matrix Y_)`
`static Matrix`	`Idft.idft(Matrix Y_, int size)` ベクトル `X` の逆離散フーリエ変換を計算します。
`static Matrix`	`Ihilbert.ihilbert(int size)` `size`×`size`の逆ヒルベルト行列を求める
`static Matrix`	`Inverf.inverf(DoubleMatrix x)` `x`の全ての成分の逆誤差関数を計算します。
`static Matrix`	`Inverf.inverf(NumericalMatrixOperator<?> x, double tolerance)` `x`の全ての成分の逆誤差関数をけいさんします。
`static Matrix`	`Kronprod.kronprod(Matrix a, Matrix b)` `A`と`B`のクロネッカー積を計算します。
`static Matrix`	`Kronsum.kronsum(Matrix A, Matrix B)` `A`と`B`のクロネッカー和を返します。
`static Matrix`	`Makecolv.makecolv(Matrix a)` 列ベクトルに変換します。
`static Matrix`	`Makerowv.makerowv(Matrix a)` 行ベクトルに変換します。
`static Matrix`	`Matrix4.matrix4(Matrix a11, Matrix a12, Matrix a21, Matrix a22)` 4個の行列を結合する
`static Matrix`	`Null.nullMatrix(Matrix A)` `A` の零空間の直交基底を返します。
`static Matrix`	`Null.nullMatrix(Matrix A, double tolerance)` `tolerance` は、零空間の次元を決めるために使われる。
`static Matrix`	`Orth.orth(Matrix A)` `A` の像の直交基底を返します。
`static Matrix`	`Orth.orth(Matrix A, double tolerance)` `A` の像の直交基底を返します。
`static Matrix`	`Rot90.rot90(Matrix A)` `A` の成分を反時計方向に `90` 度回転します。
`static Matrix`	`Rot90.rot90(Matrix A, int count)` `A` の成分を反時計方向に `count*90` 度回転します。
`static Matrix`	`Toeplitz.toeplitz(Matrix x_)` 対称(エルミート)テプリッツ行列を返します。
`static Matrix`	`Toeplitz.toeplitz(Matrix x_, Matrix y_)` `x`が第１列、`y`が第１行の非対称テプリッツ行列を返します。
`static Matrix`	`Tril.tril(Matrix x)` `x`の下三角部分を返します。
`static Matrix`	`Tril.tril(Matrix x, int distance)` `x`の`k`次対角より下の成分を返します。
`static Matrix`	`Triu.triu(Matrix x)` `x`の上三角部分を返します。
`static Matrix`	`Triu.triu(Matrix x, int distance)` `x`の次対角より上を返します。
`static Matrix`	`Unwrap.unwrap(Matrix phase)` なめらかに位相が変化するように、位相角に `+-2*PI` を加えます。
`static Matrix`	`Unwrap.unwrap(Matrix phase, double tolerance)` 位相を360度で折り返さないようにします。
`static Matrix`	`Unwrap.unwrap(Matrix phase, NumericalScalar<?> tolerance)` 位相を360度で折り返さないようにします。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase)` `phase` が行列のとき、位相角を列毎に修正します。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase, double tolerance)` `tolerance` を位相角のギャップを調べるために用いる。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase, NumericalScalar<?> tolerance)` `tolerance` を位相角のギャップを調べるために用いる。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase)` `phase` が行列のとき、行毎に位相角を修正します。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase, double tolerance)` `tolerance` は、位相角のギャップを調べるために使われる。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase, NumericalScalar<?> tolerance)` `tolerance` は、位相角のギャップを調べるために使われる。
`static Matrix`	`Vander.vander(Matrix x)` 2番目から最後までの列が`x`であるヴァンデルモンド行列を返します。

Matrix 型の引数を持つ型を返す org.mklab.tool.matrix のメソッド
`static List<Matrix>`	`Bar.bar(Matrix y)` 横軸が整数の値をとる棒グラフのデータを返します。
`static List<Matrix>`	`Bar.bar(Matrix x_, Matrix y_)` `(x, y)`という組のデータに対応する棒グラフを描画するためのデータを返します。
`static List<Matrix>`	`Cdf2rdf.cdf2rdf(Matrix Vc, Matrix Dc)` 複素対角行列を実ブロック対角行列に変換します。
`static List<Matrix>`	`Deconv.deconv(Matrix b, Matrix a)` ベクトル`b`のベクトル`a`による逆畳み込み(多項式の商と余)を返します。
`static List<Matrix>`	`Hist.hist(Matrix Y)` もし`y`がベクトルなら、`y`の最小値と最大値の間を10分割して、ヒストグラムを描画するためのデータを返します。
`static List<Matrix>`	`Hist.hist(Matrix Y, int size)` `size`分割にします。
`static List<Matrix>`	`Hist.histColumnWise(Matrix Y_)` もし`y`が行列なら、列毎に計算します。
`static List<Matrix>`	`Hist.histColumnWise(Matrix Y_, int size)` `size`分割にします。
`static List<Matrix>`	`Hist.histRowWise(Matrix Y)` もし`y`が行列なら、行毎に計算します。
`static List<Matrix>`	`Hist.histRowWise(Matrix Y, int size)` `size`分割にします。
`static List<Matrix>`	`Rsf2csf.rsf2csf(Matrix Ui, Matrix Ti)` 実擬似上シュア形の行列を複素上シュア形に変換します。
`static List<Matrix>`	`Schord.schord(Matrix Qi, Matrix Ti, IntMatrix idx_)` `Ti`の固有値が指数`idx`の成分の昇順に並ぶようにするための直交行列`Q`を返します。
`static List<Matrix>`	`Vchop.vchop(Matrix X, List<IntMatrix> statesIndex)` 与えられた指数に応じて、長い状態ベクトルをいくつかの状態に分割します。

Matrix 型のパラメータを持つ org.mklab.tool.matrix のメソッド
`static List<Matrix>`	`Bar.bar(Matrix y)` 横軸が整数の値をとる棒グラフのデータを返します。
`static List<Matrix>`	`Bar.bar(Matrix x_, Matrix y_)` `(x, y)`という組のデータに対応する棒グラフを描画するためのデータを返します。
`static NumericalMatrixOperator<?>`	`Ccpair.ccpair(Matrix x_)` 複素ベクトル `x` の成分について、複素共役の対が並ぶようにソートします。
`static NumericalMatrixOperator<?>`	`Ccpair.ccpair(Matrix x_, double tolerance)` 値を比較するための許容誤差に `tolerance` を用いる。
`static NumericalMatrixOperator<?>`	`Ccpair.ccpair(Matrix x_, NumericalScalar<?> tolerance)` 値を比較するための許容誤差に `tolerance` を用いる。
`static List<Matrix>`	`Cdf2rdf.cdf2rdf(Matrix Vc, Matrix Dc)` 複素対角行列を実ブロック対角行列に変換します。
`static Matrix`	`Chol.chol(Matrix X)` 対称行列`X`のコレスキー分解を計算します。
`static NumericalScalar<?>`	`Cond.cond(Matrix A)` 2ノルムに関する条件数( `A` 最小特異値と最大特異値の比を求める)を求めます。
`static Matrix`	`Conv.conv(Matrix x, Matrix y)` ベクトル`x`と`y`の畳み込み(多項式の積)を求める計算結果のベクトルの長さは、 `(length(x)+length(y)-1)`です。
`static NumericalScalar<?>`	`Corrcoef.corrcoef(Matrix x)` 全ての成分の相関係数を返します。
`static NumericalScalar<?>`	`Corrcoef.corrcoef(Matrix x, Matrix y)` [x y]の全ての成分の相関係数を返します。
`static Matrix`	`Corrcoef.corrcoefColumnWise(Matrix x)` 行列`x`(列毎に各変数のデータ並ぶ)の成分の相関係数を返します。
`static Matrix`	`Corrcoef.corrcoefColumnWise(Matrix x, Matrix y)` `corrcoef_col([x y])`と同じです。
`static Matrix`	`Corrcoef.corrcoefRowWise(Matrix x)` 行列`x`(行毎に各変数のデータ並ぶ)の成分の相関係数を返します。
`static Matrix`	`Corrcoef.corrcoefRowWise(Matrix x, Matrix y)` `corrcoef_row([x y])`と同じです。
`static NumericalScalar<?>`	`Cov.cov(Matrix x)` ベクトル `x` の成分の分散を求めます。
`static NumericalScalar<?>`	`Cov.cov(Matrix x, Matrix y)` cov([x y])を返します。
`static Matrix`	`Cov.covColumnWise(Matrix x)` もし`x` が行毎データが並ぶ行列なら、分散行列を返します。
`static Matrix`	`Cov.covColumnWise(Matrix x, Matrix y)`
`static Matrix`	`Cov.covRowWise(Matrix x)` もし `x` が、列毎にデータ並ぶ行列なら、分散行列を返します。
`static Matrix`	`Cov.covRowWise(Matrix x, Matrix y)`
`static List<Matrix>`	`Deconv.deconv(Matrix b, Matrix a)` ベクトル`b`のベクトル`a`による逆畳み込み(多項式の商と余)を返します。
`static NumericalMatrix<?>`	`Dft.dft(Matrix X_)`
`static NumericalMatrix<?>`	`Dft.dft(Matrix X_, int N)` `X` の離散時間フーリエ変換 `W = expˆ{-j*2PI/N} Y(k) = sum_{n=0}ˆ{N-1} X(n) Wˆ{k n} k = 0,1,...`
`static Matrix`	`Diag.diag(Matrix a1, Matrix a2)` `a1`と`a2`が対角に並ぶ対角行列を求める
`static Matrix`	`Diag.diag(Matrix a1, Matrix a2, Matrix a3)` `a1`、`a2`、`a3`が対角に並ぶ対角行列を求める
`static Matrix`	`DiagVec.diagVec(Matrix A)` もし`A`が正方行列なら、`A`の対角成分が並ぶ縦ベクトルを返します。
`static Matrix`	`DiagVec.diagVec(Matrix A_, int k)` もし`A`が正方行列なら、 `A`の`k`次対角成分(`k > 0 ?`
`static Matrix`	`Diff.diff(Matrix x)` もし `x` がベクトルなら、隣り合う成分の差からなるベクトル `[x(2)-x(1) x(3)-x(2) ... x(n)-x(n-1)]` を返します。
`static Matrix`	`Diff.diff(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Diff.diffColumnWise(Matrix x)` もし `x` が行列なら、列毎に差分 `diff_col(x) = x(2:n,:) - x(1:n-1,:).`
`static Matrix`	`Diff.diffColumnWise(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Diff.diffRowWise(Matrix x)` もし `x` が行列なら、行毎に差分 `diff_row(x) = x(:,2:n) - x(:,1:n-1).`
`static Matrix`	`Diff.diffRowWise(Matrix x, int order)` `order` 階差分を求めます。
`static Matrix`	`Eval.eval(Polynomial p, Matrix w)` 多項式の評価を計算する
`static Matrix`	`Eval.eval(RationalPolynomial g, Matrix w)` 有理多項式の評価を計算する
`static Matrix`	`Fftshift.fftshift(Matrix X)` もし `X` がベクトルなら、前半と後半を入れ替えたベクトルを返します。
`static NumericalMatrix<?>`	`Funm.funm(Matrix A, Funm.ComplexFunction fun)` 行列関数を評価します。
`static NumericalMatrix<?>`	`Funm.funm(Matrix A, Funm.ComplexFunction fun, double tolerance)` 行列関数を評価します。
`static Matrix`	`Hankel.hankel(Matrix x_)` 第1列が`x`であり、第1非対角より下の成分がゼロであるハンンケル行列を返します。
`static Matrix`	`Hankel.hankel(Matrix x_, Matrix y_)` 第1列が`x`であり、最終行が`y`であるハンンケル行列を返します。
`static List<Matrix>`	`Hist.hist(Matrix Y)` もし`y`がベクトルなら、`y`の最小値と最大値の間を10分割して、ヒストグラムを描画するためのデータを返します。
`static List<Matrix>`	`Hist.hist(Matrix Y, int size)` `size`分割にします。
`static List<Matrix>`	`Hist.histColumnWise(Matrix Y_)` もし`y`が行列なら、列毎に計算します。
`static List<Matrix>`	`Hist.histColumnWise(Matrix Y_, int size)` `size`分割にします。
`static List<Matrix>`	`Hist.histRowWise(Matrix Y)` もし`y`が行列なら、行毎に計算します。
`static List<Matrix>`	`Hist.histRowWise(Matrix Y, int size)` `size`分割にします。
`static Matrix`	`Idft.idft(Matrix Y_)`
`static Matrix`	`Idft.idft(Matrix Y_, int size)` ベクトル `X` の逆離散フーリエ変換を計算します。
`static Matrix`	`Kronprod.kronprod(Matrix a, Matrix b)` `A`と`B`のクロネッカー積を計算します。
`static Matrix`	`Kronsum.kronsum(Matrix A, Matrix B)` `A`と`B`のクロネッカー和を返します。
`static Matrix`	`Makecolv.makecolv(Matrix a)` 列ベクトルに変換します。
`static Polynomial`	`Makepoly.makepoly(Matrix A)` もし`A`が正方行列なら、`det(sI - A)`、すなわち `A`の特性多項式を返します。
`static Matrix`	`Makerowv.makerowv(Matrix a)` 行ベクトルに変換します。
`static void`	`Mat2tex.mat2tex(Matrix A, String file)`
`static void`	`Mat2tex.mat2tex(Matrix A, String file, NumberFormat fmt)`
`static String`	`Mat2tex.mat2texf(Matrix A)`
`static String`	`Mat2tex.mat2texf(Matrix A, NumberFormat fmt)`
`static Matrix`	`Matrix4.matrix4(Matrix a11, Matrix a12, Matrix a21, Matrix a22)` 4個の行列を結合する
`static Matrix`	`Null.nullMatrix(Matrix A)` `A` の零空間の直交基底を返します。
`static Matrix`	`Null.nullMatrix(Matrix A, double tolerance)` `tolerance` は、零空間の次元を決めるために使われる。
`static Matrix`	`Orth.orth(Matrix A)` `A` の像の直交基底を返します。
`static Matrix`	`Orth.orth(Matrix A, double tolerance)` `A` の像の直交基底を返します。
`static Gnuplot`	`Idft.plot(Matrix Y)` 逆離散フーリエ変換の結果をプロットする
`static Gnuplot`	`Dft.plot(Matrix X)` 離散フーリエ変換の結果を描画する
`static Gnuplot`	`Bar.plot(Matrix x)` 棒グラフを描画します。
`static Gnuplot`	`Dft.plot(Matrix x, double samplingInterval)` 離散フーリエ変換の結果を描画する
`static Gnuplot`	`Dft.plot(Matrix x, double samplingInterval, int size)` 離散フーリエ変換の結果を描画する
`static Gnuplot`	`Idft.plot(Matrix Y, int size)` 逆離散フーリエ変換の結果をプロットする
`static Gnuplot`	`Bar.plot(Matrix x, Matrix y)` 棒グラフを描画します。
`static Matrix`	`Rot90.rot90(Matrix A)` `A` の成分を反時計方向に `90` 度回転します。
`static Matrix`	`Rot90.rot90(Matrix A, int count)` `A` の成分を反時計方向に `count*90` 度回転します。
`static List<Matrix>`	`Rsf2csf.rsf2csf(Matrix Ui, Matrix Ti)` 実擬似上シュア形の行列を複素上シュア形に変換します。
`static List<Matrix>`	`Schord.schord(Matrix Qi, Matrix Ti, IntMatrix idx_)` `Ti`の固有値が指数`idx`の成分の昇順に並ぶようにするための直交行列`Q`を返します。
`static Matrix`	`Toeplitz.toeplitz(Matrix x_)` 対称(エルミート)テプリッツ行列を返します。
`static Matrix`	`Toeplitz.toeplitz(Matrix x_, Matrix y_)` `x`が第１列、`y`が第１行の非対称テプリッツ行列を返します。
`static Matrix`	`Tril.tril(Matrix x)` `x`の下三角部分を返します。
`static Matrix`	`Tril.tril(Matrix x, int distance)` `x`の`k`次対角より下の成分を返します。
`static Matrix`	`Triu.triu(Matrix x)` `x`の上三角部分を返します。
`static Matrix`	`Triu.triu(Matrix x, int distance)` `x`の次対角より上を返します。
`static Matrix`	`Unwrap.unwrap(Matrix phase)` なめらかに位相が変化するように、位相角に `+-2*PI` を加えます。
`static Matrix`	`Unwrap.unwrap(Matrix phase, double tolerance)` 位相を360度で折り返さないようにします。
`static Matrix`	`Unwrap.unwrap(Matrix phase, NumericalScalar<?> tolerance)` 位相を360度で折り返さないようにします。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase)` `phase` が行列のとき、位相角を列毎に修正します。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase, double tolerance)` `tolerance` を位相角のギャップを調べるために用いる。
`static Matrix`	`Unwrap.unwrapColumnWise(Matrix phase, NumericalScalar<?> tolerance)` `tolerance` を位相角のギャップを調べるために用いる。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase)` `phase` が行列のとき、行毎に位相角を修正します。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase, double tolerance)` `tolerance` は、位相角のギャップを調べるために使われる。
`static Matrix`	`Unwrap.unwrapRowWise(Matrix phase, NumericalScalar<?> tolerance)` `tolerance` は、位相角のギャップを調べるために使われる。
`static Matrix`	`Vander.vander(Matrix x)` 2番目から最後までの列が`x`であるヴァンデルモンド行列を返します。
`static List<Matrix>`	`Vchop.vchop(Matrix X, List<IntMatrix> statesIndex)` 与えられた指数に応じて、長い状態ベクトルをいくつかの状態に分割します。

Matrix 型の型引数を持つ org.mklab.tool.matrix のメソッドパラメータ
`static List<Object>`	`Vconnect.vconnect(List<Matrix> vectors)` いくつのベクトルを接続して長いベクトルを作り、ベクトルの長さを集めたリストと合わせて返します。

org.mklab.tool.signal での Matrix の使用

Matrix を返す org.mklab.tool.signal のメソッド
`static Matrix`	`Bartlett.bartlett(int length)` `length`点のバートレット窓を返します。
`static Matrix`	`Blackman.blackman(int length)` `length`点のブラックマン窓を返します。
`static Matrix`	`Cceps.cceps(Matrix x)` `x` の複素ケプストラムを返します。
`static Matrix`	`Detrend.detrend(Matrix data)` `X`から線形トレンドを除いたデータを返します。
`static Matrix`	`Detrend.detrend(Matrix data, int zeroMean)` `X`から平均を除く。
`static Matrix`	`Detrend.detrendColumnWise(Matrix X)` 行列の列毎にトレンドを除きます。
`static Matrix`	`Detrend.detrendColumnWise(Matrix data, int zeroMean)` 行列の列毎に平均を除きます。
`static Matrix`	`Detrend.detrendRowWise(Matrix data)` 行列の行毎にトレンドを除く。
`static Matrix`	`Detrend.detrendRowWise(Matrix data, int zeroMean)` 行列の行毎に平均を除く。
`static Matrix`	`Freqs.freqs(Matrix b, Matrix a, Matrix w)` 周波数`w`におけるアナログフィルタ `b(s)/a(s)` `nb-1 nb-2 b(s) b(1)s + b(2)s + ... + b(nb) G(s) = ---- = -------------------------------- na-1 na-2 a(s) a(1)s + a(2)s + ... + a(na)` の周波数応答`Gjw`を返します。
`static Matrix`	`Sawtooth.sawtooth(Matrix t)` 時刻の列`t`に対して、周期`2*PI`のノコギリ状の信号を返します。
`static Matrix`	`Square.square(Matrix t)` 時刻の列`t`に対して、周期`2*PI` の矩形波の信号を返します。
`static Matrix`	`Square.square(Matrix t, double duty)` 指定されたデューティー周期の矩形波信号を返します。
`static Matrix`	`Xcorr.xcorr(Matrix x_)` もし`x`がベクトルなら、自己相関係数を返します。
`static Matrix`	`Xcorr.xcorr(Matrix x_, Matrix y_)` `x`と`y`の`(2*m-1)`点の相互相関係数を返します。
`static Matrix`	`Xcov.xcov(Matrix x)` もし`x`がベクトルなら、自己分散を返します。
`static Matrix`	`Xcov.xcov(Matrix x, Matrix y)` ベクトル`x`と`y`とのcross-covarianceを返します。

Matrix 型の引数を持つ型を返す org.mklab.tool.signal のメソッド
`static List<Matrix>`	`Bilinear.bilinear(Matrix A, Matrix B, Matrix C, Matrix D, double fs)` 連続時間伝達関数を離散時間伝達関数に双一次変換 `G(z) = G(s) \| \| s = 2fs(z-1)/(z+1)` を用いて変換します。
`static List<Matrix>`	`Bilinear.bilinear(Matrix A, Matrix B, Matrix C, Matrix D, double fs, double fp)` 変換前後の周波数応答が周波数`fp`(Hz)で正確に一致するよう、双一次変換の前に前処理を行います。
`static List<Matrix>`	`Filter.filter(Matrix b, Matrix a, Matrix x)` データ`x`をフィルタ `y(n) = b(1)x(n) + b(2)x(n-1) + ... + b(nb+1)x(n-nb) - a(2)y(n-1) - ... - a(na+1)*y(n-na)` に通した値を求めます。
`static List<Matrix>`	`Filter.filter(Matrix b_, Matrix a_, Matrix x_, Matrix zi_)` 初期条件と終端条件を与える。
`static List<Matrix>`	`Freqz.freqz(Matrix b, Matrix a, int n)` 周波数 `w` におけるデジタルフィルタ `b(z)/a(z)` `-1 -nb b(z) b(1) + b(2)z + .... + b(nb+1)z G(eˆ(jw)) = ---- = ---------------------------- -1 -na a(z) 1 + a(2)z + .... + a(na+1)z` の周波数応答を返します。
`static List<Matrix>`	`Freqzw.freqzw(Matrix b_, Matrix a_, Matrix w)` 周波数`w`におけるフィルタ`b/a` `-1 -nb jw B(z) b(1) + b(2)z + .... + b(nb+1)z H(e) = ---- = ---------------------------- -1 -na A(z) 1 + a(2)z + .... + a(na+1)z` の複素周波数応答を返します。
`static List<Matrix>`	`Rceps.rceps(Matrix x)` `x` の実ケプストラムと最小位相信号を返します。

Matrix 型のパラメータを持つ org.mklab.tool.signal のメソッド
`static List<Matrix>`	`Bilinear.bilinear(Matrix A, Matrix B, Matrix C, Matrix D, double fs)` 連続時間伝達関数を離散時間伝達関数に双一次変換 `G(z) = G(s) \| \| s = 2fs(z-1)/(z+1)` を用いて変換します。
`static List<Matrix>`	`Bilinear.bilinear(Matrix A, Matrix B, Matrix C, Matrix D, double fs, double fp)` 変換前後の周波数応答が周波数`fp`(Hz)で正確に一致するよう、双一次変換の前に前処理を行います。
`static Matrix`	`Cceps.cceps(Matrix x)` `x` の複素ケプストラムを返します。
`static Matrix`	`Detrend.detrend(Matrix data)` `X`から線形トレンドを除いたデータを返します。
`static Matrix`	`Detrend.detrend(Matrix data, int zeroMean)` `X`から平均を除く。
`static Matrix`	`Detrend.detrendColumnWise(Matrix X)` 行列の列毎にトレンドを除きます。
`static Matrix`	`Detrend.detrendColumnWise(Matrix data, int zeroMean)` 行列の列毎に平均を除きます。
`static Matrix`	`Detrend.detrendRowWise(Matrix data)` 行列の行毎にトレンドを除く。
`static Matrix`	`Detrend.detrendRowWise(Matrix data, int zeroMean)` 行列の行毎に平均を除く。
`static List<Matrix>`	`Filter.filter(Matrix b, Matrix a, Matrix x)` データ`x`をフィルタ `y(n) = b(1)x(n) + b(2)x(n-1) + ... + b(nb+1)x(n-nb) - a(2)y(n-1) - ... - a(na+1)*y(n-na)` に通した値を求めます。
`static List<Matrix>`	`Filter.filter(Matrix b_, Matrix a_, Matrix x_, Matrix zi_)` 初期条件と終端条件を与える。
`static Matrix`	`Freqs.freqs(Matrix b, Matrix a, Matrix w)` 周波数`w`におけるアナログフィルタ `b(s)/a(s)` `nb-1 nb-2 b(s) b(1)s + b(2)s + ... + b(nb) G(s) = ---- = -------------------------------- na-1 na-2 a(s) a(1)s + a(2)s + ... + a(na)` の周波数応答`Gjw`を返します。
`static List<Matrix>`	`Freqz.freqz(Matrix b, Matrix a, int n)` 周波数 `w` におけるデジタルフィルタ `b(z)/a(z)` `-1 -nb b(z) b(1) + b(2)z + .... + b(nb+1)z G(eˆ(jw)) = ---- = ---------------------------- -1 -na a(z) 1 + a(2)z + .... + a(na+1)z` の周波数応答を返します。
`static List<Matrix>`	`Freqzw.freqzw(Matrix b_, Matrix a_, Matrix w)` 周波数`w`におけるフィルタ`b/a` `-1 -nb jw B(z) b(1) + b(2)z + .... + b(nb+1)z H(e) = ---- = ---------------------------- -1 -na A(z) 1 + a(2)z + .... + a(na+1)z` の複素周波数応答を返します。
`static List<Matrix>`	`Rceps.rceps(Matrix x)` `x` の実ケプストラムと最小位相信号を返します。
`static Matrix`	`Sawtooth.sawtooth(Matrix t)` 時刻の列`t`に対して、周期`2*PI`のノコギリ状の信号を返します。
`static Matrix`	`Square.square(Matrix t)` 時刻の列`t`に対して、周期`2*PI` の矩形波の信号を返します。
`static Matrix`	`Square.square(Matrix t, double duty)` 指定されたデューティー周期の矩形波信号を返します。
`static Matrix`	`Xcorr.xcorr(Matrix x_)` もし`x`がベクトルなら、自己相関係数を返します。
`static Matrix`	`Xcorr.xcorr(Matrix x_, Matrix y_)` `x`と`y`の`(2*m-1)`点の相互相関係数を返します。
`static Matrix`	`Xcov.xcov(Matrix x)` もし`x`がベクトルなら、自己分散を返します。
`static Matrix`	`Xcov.xcov(Matrix x, Matrix y)` ベクトル`x`と`y`とのcross-covarianceを返します。

概要

パッケージ

クラス

使用

階層ツリー

非推奨 API

索引

ヘルプ

前次

フレームあり フレームなし

インタフェースorg.mklab.nfc.matrix.Matrix の使用

インタフェース
org.mklab.nfc.matrix.Matrix の使用