概要 | パッケージ | クラス | 使用 | 階層ツリー | 非推奨 API | 索引 | ヘルプ
前のクラス 次のクラス | フレームあり フレームなし
概要: 入れ子 | フィールド | コンストラクタ | メソッド | 詳細: フィールド | コンストラクタ | メソッド

## org.mklab.nfc.matrix
クラス DoubleMatrix

    java.lang.Object
      org.mklab.nfc.matrix.AbstractGrid<M>
          org.mklab.nfc.matrix.AbstractFundamentalMatrix<M>
              org.mklab.nfc.matrix.AbstractMatrix<DoubleMatrix>
                  org.mklab.nfc.matrix.DoubleMatrix

すべての実装されたインタフェース:
  Serializable, Cloneable, FundamentalMatrix, Grid, Matrix, MatrixElementOperator<DoubleNumber>, MatrixElementWiseOperator, NumericalMatrixOperator<DoubleNumber>, MatxObject

直系の既知のサブクラス:
  MatxRealArray

    public class DoubleMatrix

extends AbstractMatrix<DoubleMatrix>
implements NumericalMatrixOperator<DoubleNumber>, MatxObject

倍精度(double)型の値を成分とする行列を表すクラスです。

バージョン:
  $Revision: 1.28 $
作成者:
  Koga Laboratory
関連項目:
  直列化された形式

コンストラクタの概要
`DoubleMatrix()` 0*0の`DoubleMatrix`を生成します。
`DoubleMatrix(double[] elements)` `elements`で与えられた成分を持つ行ベクトルを生成します。
`DoubleMatrix(double[][] elements)` 与えられた成分をもつ`DoubleMatrix`を生成します。
`DoubleMatrix(DoubleNumber[] elements)` `elements`で与えられた成分を持つ行ベクトルを生成します。
`DoubleMatrix(DoubleNumber[][] elements)` 与えられた成分をもつ`DoubleMatrix`を生成します。
`DoubleMatrix(int rowSize, int columnSize)` `rowSize * columnSize` の`DoubleMatrix`零行列を生成します。
`DoubleMatrix(int rowSize, int columnSize, double[][] elements)` 与えられた成分をもつ `rowSize * columnSize` の `DoubleMatrix`を生成します。
`DoubleMatrix(int rowSize, int columnSize, DoubleNumber[][] elements)` 与えられた成分をもつ `rowSize * columnSize` の `DoubleMatrix`を生成します。
`DoubleMatrix(IntMatrix matrix)` 新しく生成された`DoubleMatrix`オブジェクトを初期化します。

メソッドの概要
`DoubleMatrix` | `absElementWise()` 各成分の絶対値を成分に持つ行列を返します。
`DoubleMatrix` | `acosElementWise()` 成分毎の逆余弦関数の結果からなる行列を返します。
`DoubleMatrix` | `acoshElementWise()` 成分毎の逆双曲線余弦関数の結果からなる行列を返します。
`DoubleMatrix` | `add(DoubleMatrix value)` 行列`value`との和行列を生成します。
`DoubleMatrix` | `addElementWise(double value)` 成分毎に実数を加えます。
`DoubleMatrix` | `addElementWise(int value)` 成分毎に整数を加えます。
`Matrix` | `addElementWise(Scalar<?> value)` 成分毎にスカラーを加えます。
`DoubleMatrix` | `appendDown(DoubleMatrix value)` 下側に実数行列`value`を連結した行列を生成します。
`DoubleMatrix` | `appendRight(DoubleMatrix value)` 右側に`value`を連結した行列を生成します。
`DoubleMatrix` | `argumentElementWise()` 各成分の偏角を成分に持つ行列を返します。
`DoubleMatrix` | `asinElementWise()` 成分毎の逆正弦関数の結果からなる行列を返します。
`DoubleMatrix` | `asinhElementWise()` 成分毎の逆双曲線正弦関数の結果からなる行列を返します。
`DoubleMatrix` | `atan2ElementWise(DoubleMatrix matrix)` 各成分の正接(2)関数の結果を成分とする行列を生成します。
`NumericalMatrixOperator<?>` | `atan2ElementWise(Matrix order)` 各成分の逆正接(2)関数の結果を成分とする行列を生成します。
`NumericalMatrixOperator<?>` | `atan2ElementWise(NumericalScalar<?> value)` 各成分の逆正接(2)関数の結果を成分とする行列を生成します。
`DoubleMatrix` | `atanElementWise()` 成分毎の逆正接関数の結果からなる行列を返します。
`DoubleMatrix` | `atanhElementWise()` 成分毎の逆双曲線正接関数の結果からなる行列を返します。
`BalancedDecomposition<DoubleMatrix>` | `balancedDecompose()` 非対称行列のバランス化分解を返します。
`DoubleMatrix` | `ceilElementWise()` 大きい整数に丸めます。
`DoubleMatrix` | `choleskyDecompose()` 対称行列のコレスキー分解を返します。
`DoubleMatrix` | `clone()` Object#clone()
`BooleanMatrix` | `compareElementWise(String operator, double value)` 各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。
`BooleanMatrix` | `compareElementWise(String operator, DoubleMatrix opponent)` `opponent`と成分毎に`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。
`BooleanMatrix` | `compareElementWise(String operator, int value)` 各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。
`BooleanMatrix` | `compareElementWise(String operator, IntMatrix opponent)` `opponent`と成分毎に`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。
`BooleanMatrix` | `compareElementWise(String operator, Matrix opponent)` `opponent`と成分毎に`operator`で指定された演算子で比較した結果を `BooleanMatrix`で返します。
`BooleanMatrix` | `compareElementWise(String operator, Scalar<?> value)` 各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。
`DoubleNumber` | `conditionNumber()` 条件数(2-ノルム)を返します。
`DoubleMatrix` | `conjugate()` 共役複素行列を返します。
`DoubleMatrix` | `conjugateTranspose()` 各成分の共役複素数の転置行列を返します。
`void` | `copy(DoubleMatrix source)` 実数行列`source`の各成分をコピーします。
`void` | `copy(IntMatrix source)` 整数行列`source`の各成分をコピーします。
`void` | `copy(Matrix source)` `source`の成分をコピーします。
`DoubleMatrix` | `cosElementWise()` 成分毎の余弦関数の結果からなる行列を返します。
`DoubleMatrix` | `coshElementWise()` 成分毎の双曲線余弦関数の結果からなる行列を返します。
`DoubleMatrix` | `covariance(DoubleMatrix opponent)` yとの共分散行列を返します。
`DoubleComplexMatrix` | `createComplexMatrix(NumericalMatrixOperator<?> realPart, NumericalMatrixOperator<?> imagPart)` 複素行列を返します。
`DoubleMatrix` | `createNormalRandom()` 同サイズの平均0、分散1の正規分布のランダムな成分を持つ行列を生成します。
`DoubleMatrix` | `createNormalRandom(int rowSize, int columnSize)` 平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize` の行列を生成します。
`DoubleMatrix` | `createNormalRandom(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber`倍の 平均0、 分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します。
`DoubleMatrix` | `createNormalRandom(int rowSize, int columnSize, long seed)` 平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize` の行列を生成します。
`DoubleMatrix` | `createOnes(int rowSize, int columnSize)` `rowSize`*`columnSize`の全成分が1である行列を生成します。
`DoubleMatrix` | `createUniformRandom()` 同サイズの0〜1の範囲の一様分布のランダムな成分を持つ行列を生成します。
`DoubleMatrix` | `createUniformRandom(int rowSize, int columnSize)` 0〜1の範囲の一様分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します 。
`DoubleMatrix` | `createUniformRandom(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber`倍の 0〜1の範囲の一様分布のランダムな成分を持つ `rowSize`*`columnSize`の行列を生成します。
`DoubleMatrix` | `createUniformRandom(int rowSize, int columnSize, long seed)` 0〜1の範囲の一様分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します 。
`DoubleMatrix` | `createUnit(int rowSize, int columnSize)` `rowSize`*`columnSize`の単位行列を生成します。
`DoubleMatrix` | `createZero(int rowSize, int columnSize)` `rowSize`*`columnSize`の零行列を生成します。
`DoubleMatrix` | `cumulativeProduct()` 各要の累積積からなる行列を返します。
`DoubleMatrix` | `cumulativeProductColumnWise()` 列毎の累積積行列を返します。
`DoubleMatrix` | `cumulativeProductRowWise()` 行毎の累積積行列を返します。
`DoubleMatrix` | `cumulativeSum()` 各要の累積和からなる行列を返します。
`DoubleMatrix` | `cumulativeSumColumnWise()` 列毎の累積和行列を返します。
`DoubleMatrix` | `cumulativeSumRowWise()` 行毎の累積和行列を返します。
`DoubleNumber` | `determinant()` 行列式を返します。
`double` | `determinant(NumericalScalar<?> tolerance, boolean stopIfSingular)` 行列式を返します。
`static DoubleMatrix` | `diagonal(double[] diagonalElements)` 対角行列を生成します。
`DoubleMatrix` | `diagonalToVector()` 対角成分をからなる列ベクトルを生成します。
`DoubleMatrix` | `divide(double value)` 各成分と実数valueの商(`this`/`value`)を返します。
`DoubleMatrix` | `divide(DoubleMatrix value)` 行列`value`の逆行列との積(`this`*`value` -1 )を生成します。
`DoubleMatrix` | `divide(int value)` 各成分と整数valueの商(`this`/`value`)を返します。
`Matrix` | `divide(Scalar<?> value)` 各成分とスカラーの商からなる行列を返します。
`DoubleMatrix` | `divideElementWise(DoubleMatrix value)` 自身と`value`の成分毎の商を成分とする行列を生成します。
`EigenSolution<DoubleComplexMatrix>` | `eigenDecompose()` 固有値を対角成分とする対角行列D、固有値に対応する固有ベクトルを横方向に並べた行列Xを返します。
`EigenSolution<NumericalMatrix<?>>` | `eigenDecompose(DoubleMatrix b)` 一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を成分とする配列を返します。
`EigenSolution<NumericalMatrix<?>>` | `eigenDecompose(NumericalMatrixOperator<?> b)` 一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を返します。
`DoubleComplexMatrix` | `eigenValue()` 固有値を成分とする列ベクトルを返します。
`DoubleComplexMatrix` | `eigenValue(NumericalMatrixOperator b)` 一般化固有値からなる列ベクトルを返します。
`DoubleComplexMatrix` | `eigenValueReal(DoubleMatrix b)` 一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を成分とする配列を返します。
`DoubleComplexMatrix` | `eigenVector()` (右)固有ベクトルを列とする行列を返します。
`DoubleComplexMatrix` | `eigenVector(DoubleMatrix b)` 一般化固有ベクトルを返します。
`NumericalMatrix<DoubleComplexNumber>` | `eigenVector(NumericalMatrixOperator b)` 一般化固有ベクトルを返します。
`boolean` | `equals(DoubleMatrix opponent, double tolerance)` 許容誤差内で行列`opponent`と等しいか判定します。
`boolean` | `equals(Matrix opponent, double tolerance)` 行列`opponent`と値が許容誤差以内で等しいか判定します。
`boolean` | `equals(Object opponent)`
`void` | `exchangeColumn(int column1, int column2)` `column1`列と`column2`列を入れ替えます。
`void` | `exchangeRow(int row1, int row2)` `row1`行と`row2`行を入れ替えます。
`DoubleMatrix` | `exp()` 指数関数行列を返します。
`DoubleMatrix` | `exp(double tolerance)` 指数関数行列を返します。
`DoubleMatrix` | `exp(NumericalScalar<?> tolerance)` 指数関数行列を返します。
`DoubleMatrix` | `expElementWise()` 成分毎の指数関数の結果からなる行列を返します。
`DoubleComplexMatrix` | `fft()` 2 のべき乗の長さのベクトルについて、基底が 2 の 高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `fft(int dataCount)` `dataSize`点まで基底が 2 の高速フーリエ変換をします。
`DoubleComplexMatrix` | `fftColumnWise()` 列毎に基底が 2 の高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `fftColumnWise(int dataCount)` 列毎に`dataSize`点まで、基底が 2 の高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `fftRowWise()` 行毎に基底が 2 の高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `fftRowWise(int dataCount)` 行毎に`dataSize`点まで,基底が 2 の高速フーリエ変換を計算します。
`DoubleMatrix` | `fixElementWise()` ゼロ方向の整数に丸めます。
`DoubleMatrix` | `floorElementWise()` 小さい整数に丸めます。
`DoubleNumber` | `frobNorm()` フロベニウスノルムを返します。
`DoubleMatrix` | `frobNormColumnWise()` 列毎のフロベニウスノルムを成分とする行ベクトルを返します。
`DoubleMatrix` | `frobNormRowWise()` 行毎のフロベニウスノルムを成分とする列ベクトルを返します。
`static String` | `getDefaultElementFormat()` 成分のデフォルト出力フォーマットを返します。
`double` | `getDoubleElement(int index)` 成分を行毎に数え、指定した位置の成分を返します。
`double` | `getDoubleElement(int row, int column)` `row`行`column`列の成分を返します。
`DoubleNumber` | `getElement(int index)` 成分を行毎に数え`index`で指定した成分を返します。
`DoubleNumber` | `getElement(int row, int column)` `row`行`column`列の成分を返します。
`protected String` | `getGridClassName()` 出力するクラスの名前を返します。
`DoubleMatrix` | `getImaginaryPart()` 虚部行列を返します。
`DoubleMatrix` | `getRealPart()` 実部行列を返します。
`DoubleMatrix` | `getSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax)` 部分行列`this(rowMinimum:rowMaximum,columnMinimum:columnMaximum)`を生成します。
`DoubleMatrix` | `getSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex)` `rowMinimum`行から`rowMaximum`行目で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`DoubleMatrix` | `getSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax)` `columnMinimum`列から`columnMaximum`列まで、 `rowIndex`で指定された行を成分とする部分行列を生成します。
`DoubleMatrix` | `getSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex)` `rowIndex`で指定された行で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`DoubleMatrix` | `getSubVector(IntMatrix index)` 行毎に数え`index`で指定した成分を成分とする部分行列を生成します。
`int` | `hashCode()`
`HessenbergDecomposition<DoubleMatrix>` | `hessenbergDecompose()` ヘッセンベルク分解を返します。
`DoubleComplexMatrix` | `ifft()` 2 のべき乗の長さのベクトルについて、基底が 2 の 逆高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `ifft(int dataCount)` `dataSize`点まで基底が2の逆高速フーリエ変換をします。
`DoubleComplexMatrix` | `ifftColumnWise()` 列毎に基底が 2 の逆高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `ifftColumnWise(int dataCount)` 列毎に`dataSize`点まで、基底が 2 の逆高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `ifftRowWise()` 行毎に基底が 2 の逆高速フーリエ変換を計算します。
`DoubleComplexMatrix` | `ifftRowWise(int dataCount)` 行毎に`dataSize`点まで,基底が 2 の逆高速フーリエ変換を計算します。
`DoubleNumber` | `infNorm()` 無限大ノルムを返します。
`DoubleMatrix` | `inverse()` 逆行列(`this` -1 )を返します。
`DoubleMatrix` | `inverse(double tolerance, boolean stopIfSingular)` 逆行列(`this` -1 )を返します。
`DoubleMatrix` | `inverse(NumericalScalar<?> tolerance, boolean stopIfSingular)` 逆行列(`this` -1 )を返します。
`DoubleMatrix` | `inverseElementWise()` 成分毎の逆数からなる行列を返します。
`boolean` | `isComplex()` 複素成分をもつか判定します。
`BooleanMatrix` | `isFiniteElementWise()` 各成分の有限性の真偽を成分にもつ行列を返します。
`boolean` | `isFullRank()` フルランクであるか判定します。
`boolean` | `isFullRank(double tolerance)` フルランクであるか判定します。
`boolean` | `isFullRank(NumericalScalar<?> tolerance)` フルランクであるか判定します。
`BooleanMatrix` | `isInfiniteElementWise()` 各成分の無限性の真偽を成分にもつ行列を返します。
`BooleanMatrix` | `isNanElementWise()` 各成分の非数性の真偽を成分にもつ行列を返します。
`boolean` | `isReal()` 実成分のみをもつか(複素成分をもたないか)判定します。
`boolean` | `isTransformableFrom(Matrix value)` 引数で与えられた型から、この型へ変換可能か判定します。
`boolean` | `isUnit(double tolerance)` 単位行列であるか判定します。
`boolean` | `isUnit(NumericalScalar<?> tolerance)` 単位行列であるか判定します。
`boolean` | `isZero(double tolerance)` 零行列であるか判定します。
`boolean` | `isZero(NumericalScalar<?> tolerance)` 零行列であるか判定します。
`DoubleMatrix` | `kernel()` カーネル(零空間)を張るベクトルからなる行列を返します。
`DoubleMatrix` | `kernel(double tolerance)` カーネル(零空間)を張るベクトルからなる行列を返します。
`DoubleMatrix` | `kernel(NumericalScalar<?> tolerance)` カーネル(零空間)を張るベクトルからなる行列を返します。
`DoubleMatrix` | `leftDivide(DoubleMatrix value)` 自身の逆行列と行列`value`の積(`this` -1 *`value`)を生成します。
`DoubleMatrix` | `leftDivideElementWise(DoubleMatrix value)` 自身と`value`の成分毎の左からの商を成分とする行列を生成します。
`DoubleComplexMatrix` | `log()` 対数行列を返します。
`DoubleMatrix` | `log10ElementWise()` 成分毎の常用対数関数の結果からなる行列を返します。
`DoubleMatrix` | `logElementWise()` 成分毎の対数関数の結果からなる行列を返します。
`LUDecomposition<DoubleMatrix>` | `luDecompose()` LU分解を返します。
`LUDecomposition<DoubleMatrix>` | `luDecompose(double tolerance)` LU分解を返します。
`LUDecomposition<DoubleMatrix>` | `luDecompose(NumericalScalar<?> tolerance)` LU分解を返します。
`LUDecomposition<DoubleMatrix>` | `luDecomposeWithPermutation()` 並べ替え付きLU分解を返します。
`LUDecomposition<DoubleMatrix>` | `luDecomposeWithPermutation(double tolerance)` 並べ替え付きLU分解を返します。
`LUDecomposition<DoubleMatrix>` | `luDecomposeWithPermutation(NumericalScalar<?> tolerance)` 並べ替え付きLU分解を返します。
`DoubleNumber` | `max()` 最大成分を返します。
`DoubleMatrix` | `maxColumnWise()` 列毎の最大値を成分とする行ベクトルを返します。
`DoubleMatrix` | `maxElementWise(DoubleMatrix opponent)` 各成分の大きい方の値を成分とする行列を生成します。
`Matrix` | `maxElementWise(Matrix opponent)` `opponent`と成分毎に比較し、大きいほうを成分にもつ行列を返します。
`ElementHolder<DoubleNumber>` | `maximum()` 最大成分とその指数を返します。
`IndexedMatrix<DoubleMatrix>` | `maximumColumnWise()` 列毎の最大成分とその指数を返します。
`IndexedMatrix<DoubleMatrix>` | `maximumRowWise()` 行毎の最大成分とその指数を返します。
`DoubleMatrix` | `maxRowWise()` 行毎の最大値を成分とする列ベクトルを返します。
`DoubleNumber` | `maxSingularValue()` 最大特異値を返します。
`DoubleNumber` | `mean()` 全ての成分の平均値を返します。
`DoubleMatrix` | `meanColumnWise()` 各成分列毎の平均値行ベクトルを返します。
`DoubleMatrix` | `meanRowWise()` 各成分行毎の平均値列ベクトルを返します。
`DoubleNumber` | `median()` 全ての成分の中間値を返します。
`DoubleMatrix` | `medianColumnWise()` 行列なら、列毎のメジアンを成分とする行ベクトルを返します。
`DoubleMatrix` | `medianRowWise()` 行列なら、行毎のメジアンを成分とする列ベクトルを返します。
`DoubleNumber` | `min()` 最小成分を返します。
`DoubleMatrix` | `minColumnWise()` 列毎の最小値を成分とする行ベクトルを返します。
`DoubleMatrix` | `minElementWise(DoubleMatrix opponent)` 各成分の小さい方の値を成分とする行列を生成します。
`Matrix` | `minElementWise(Matrix opponent)` `opponent`と成分毎に比較し、小さいほうを成分にもつ行列を返します。
`ElementHolder<DoubleNumber>` | `minimum()` 最小成分と指数を返します。
`IndexedMatrix<DoubleMatrix>` | `minimumColumnWise()` 列毎の最小成分とその指数を返します。
`IndexedMatrix<DoubleMatrix>` | `minimumRowWise()` 行毎の最小成分とその指数を返します。
`DoubleMatrix` | `minRowWise()` 行毎の最小値を成分とする列ベクトルを返します。
`DoubleNumber` | `minSingularValue()` 最小特異値を返します。
`DoubleMatrix` | `modulusElementWise(double value)` 各成分の符合付剰余関数の結果を成分とする行列を生成します。
`DoubleMatrix` | `modulusElementWise(DoubleMatrix matrix)` 各成分の符号付剰余関数の結果を成分とする行列を生成します。
`DoubleMatrix` | `modulusElementWise(Matrix order)` 各成分の符合付剰余を成分とする行列を生成します。
`DoubleMatrix` | `modulusElementWise(NumericalScalar<?> value)` 各成分の符合付剰余を成分とする行列を生成します。
`DoubleMatrix` | `multiply(double value)` 各成分と実数`value`の積を(`this`*`value`)を返します。
`DoubleMatrix` | `multiply(DoubleMatrix value)` 行列`value`との積行列を生成します。
`DoubleMatrix` | `multiply(int value)` 各成分と整数`value`の積を(`this`*`value`)を返します。
`Matrix` | `multiply(Scalar<?> value)` 各成分とスカラー`value`の積を返します。
`DoubleMatrix` | `multiplyElementWise(DoubleMatrix value)` 自身と`value`の成分毎の積を成分とする行列を生成します。
`DoubleNumber` | `norm(NormType type)` norm(`NormType.FROBENIUS`)でフロベニウスノルム、 norm( `NormType.INFINITY`)で無限大ノルム、 norm( `NormType.ONE`)で1-ノルムを、 norm(`NormType.TWO`)で最大特異値を返します。
`static DoubleMatrix` | `normalRandom(Grid matrix)` 0以上1より小さい正規分布のランダムな成分をもつ`matrix`と同じ大きさの実行列を生成します。
`static DoubleMatrix` | `normalRandom(int size)` 0以上1より小さい正規分布のランダムな成分をもつ`size`*`size`の実行列を生成します。
`static DoubleMatrix` | `normalRandom(int rowSize, int columnSize)` 0以上1より小さい正規分布のランダムな成分をもつ`rowSize`*`columnSize` の実行列を生成します。
`static DoubleMatrix` | `normalRandom(int rowSize, int columnSize, long seed)` 正規乱数の種を`seed`で指定し, その種によって生成される、0以上1未満の正規分布の乱数成分を もつ`rowSize`*`columnSize`の実行列を得る。
`static DoubleMatrix` | `ones(Grid matrix)` 行列`matrix`と同サイズの全成分が1である行列を生成します。
`static DoubleMatrix` | `ones(int size)` `size`*`size`の全成分が1である行列を生成します。
`static DoubleMatrix` | `ones(int rowSize, int columnSize)` `rowSize`*`columnSize`の全成分が1である行列を生成します。
`static DoubleMatrix` | `ones(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber` * `columnNumber`倍の全成分が1である行列を生成します。
`DoubleMatrix` | `powerElementWise(double order)` 成分毎に累乗するした値を成分とする行列を返します。
`static DoubleMatrix` | `powerElementWise(double scalar, DoubleMatrix matrix)` 実数の累乗(行列成分毎)を成分とする行列を生成します。
`static DoubleMatrix` | `powerElementWise(double scalar, IntMatrix matrix)` 1個の実数について、行列の各成分の累乗を成分とする行列を生成します。
`DoubleMatrix` | `powerElementWise(DoubleMatrix value)` 各成分の累乗した値を成分とする行列を生成します。
`static DoubleMatrix` | `powerElementWise(double scalar, Matrix matrix)` 実数の累乗(行列成分毎)を成分とする行列を生成します。
`DoubleMatrix` | `powerElementWise(int order)` 成分毎に累乗します。
`static DoubleMatrix` | `powerElementWise(int scalar, DoubleMatrix matrix)` 整数の累乗(行列成分毎)を成分とする行列を生成します。
`DoubleMatrix` | `powerElementWise(IntMatrix value)` 成分毎に累乗します。
`static DoubleMatrix` | `powerElementWise(int scalar, Matrix matrix)` 整数の累乗(行列成分毎)を成分とする行列を生成します。
`NumericalMatrixOperator<?>` | `powerElementWise(Matrix order)` 成分毎に累乗します。
`NumericalMatrix<?>` | `powerElementWise(NumericalMatrix<?> value)` 各成分の累乗した値を成分とする行列を生成します。
`NumericalMatrixOperator<?>` | `powerElementWise(NumericalScalar<?> order)` 成分毎に累乗するした値を成分とする行列を返します。
`void` | `printElements(Writer output)` ライターに成分を出力します。
`void` | `printElements(Writer output, int maxColumnSize)` ライターに成分を出力します。
`DoubleNumber` | `product()` 全ての成分積を返します。
`DoubleMatrix` | `productColumnWise()` 列毎に掛けた行ベクトルを返します。
`DoubleMatrix` | `productRowWise()` 行毎に掛けた列ベクトルを返します。
`DoubleMatrix` | `pseudoInverse()` 擬似逆行列を返します。
`DoubleMatrix` | `pseudoInverse(double tolerance)` 擬似逆行列を返します。
`DoubleMatrix` | `pseudoInverse(NumericalScalar<?> tolerance)` 擬似逆行列を返します。
`QRDecomposition<DoubleMatrix>` | `qrDecompose()` QR分解を返します。
`QRDecomposition<DoubleMatrix>` | `qrDecomposeWithPermutation()` 推奨されていません。
`QZDecomposition<NumericalMatrixOperator<?>>` | `qzDecompose(DoubleMatrix b)` QZ分解を返します。
`QZDecomposition<NumericalMatrixOperator<?>>` | `qzDecompose(NumericalMatrixOperator<?> b)` QZ分解を返します。
`int` | `rank()` ランク(階数)(正の特異値の数)を返します。
`int` | `rank(double tolerance)` ランク(階数)(`tolerance`より大きい特異値の数)を返します。
`int` | `rank(NumericalScalar<?> tolerance)` ランク(階数)(`tolerance`より大きい特異値の数)を返します。
`static DoubleMatrix` | `readMatFormat(int rowSize, int columnSize, StreamTokenizer stringTokennizer)` `MatxMatrix.readMatFormat(String)`用の中間メソッドです。
`static DoubleMatrix` | `readMxFormat(InputStream input, MxDataHead head)` `MatxMatrix.readMxFormat(InputStream)` から呼ばれる中間メソッドです。
`DoubleMatrix` | `remainderElementWise(double value)` 各成分の剰余関数の結果を成分とする行列を生成します。
`DoubleMatrix` | `remainderElementWise(DoubleMatrix matrix)` 各成分の剰余関数の結果を成分とする行列を生成します。
`DoubleMatrix` | `remainderElementWise(Matrix order)` 各成分の剰余を成分とする行列を生成します。
`DoubleMatrix` | `remainderElementWise(NumericalScalar<?> value)` 各成分の剰余を成分とする行列を生成します。
`void` | `removeColumnVectors(int columnMin, int columnMax)` `columnMin`列から`columnMax`列までを削除します。
`void` | `removeColumnVectors(IntMatrix columnIndex)` `columnIndex`で指定された列を削除します。
`void` | `removeRowVectors(int rowMin, int rowMax)` `rowMin`行から`rowMax`行までを削除します。
`void` | `removeRowVectors(IntMatrix rowIndex)` `rowIndex`で指定された行を削除します。
`DoubleMatrix` | `reshape(int newRowSize, int newColumnSize)` サイズを`newRowSize`*`newColumnSize`に変更した行列を生成します。
`DoubleMatrix` | `resize(int newRowSize, int newColumnSize)` `newRowSize`*`newColumnSize`にサイズ変更します。
`DoubleMatrix` | `roundElementWise()` 最も近い整数に丸めます。
`DoubleMatrix` | `roundToZeroElementWise(double tolerance)` 絶対値が小さい成分を0に丸めます。
`DoubleMatrix` | `roundToZeroElementWise(NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`SchurDecomposition<DoubleMatrix>` | `schurDecompose()` Schur分解を返します。
`static DoubleMatrix` | `series(double from, double to)` `from`から`to`までの連続する実数を成分に持つ行ベクトルを生成します。
`static DoubleMatrix` | `series(double from, double to, double by)` `from`から`to`までの`by`飛びの実数を成分に持つ行ベクトルを生成します。
`static void` | `setDefaultElementFormat(String format)` 成分のデフォルト出力フォーマットを設定します。
`void` | `setElement(int index, double value)` 成分を行毎に数え`index`で指定した位置に`value`を代入します。
`void` | `setElement(int index, int value)` 成分を行毎に数え`index`で指定した位置に`value`を代入します。
`void` | `setElement(int row, int column, double value)` 指定した成分に`value`を代入します。``
`void` | `setElement(int row, int column, int value)` 指定した成分に`value`を代入します。
`void` | `setElement(int row, int column, Scalar<?> value)` 指定した成分に`value`を代入します。
`void` | `setElement(int index, Scalar<?> value)` 成分を行毎に数え`index`で指定した位置に`value`を代入します。
`void` | `setImaginaryPart(BaseMatrix<?,?> imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(DoubleMatrix imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(IntMatrix imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(Matrix imaginaryPart)` 虚部行列を設定します。
`void` | `setRealPart(BaseMatrix<?,?> realPart)` 実部行列を設定します。
`void` | `setRealPart(DoubleMatrix realPart)` 実部行列を設定します。
`void` | `setRealPart(IntMatrix realPart)` 実部行列を設定します。
`void` | `setRealPart(Matrix realPart)` 実部行列を設定します。
`void` | `setSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax, DoubleMatrix source)` 指定した成分に行列`source`を代入します。
`void` | `setSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax, Matrix source)` 指定した成分に行列`source`を代入します。
`void` | `setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, DoubleMatrix source)` `rowMin`列から`rowMax`列目の成分の`columnIndex` で指定された行に行列`value`の成分を代入します。
`void` | `setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, Matrix source)` `rowMinimum`列目から`rowMaximum`列目の成分の`columnIndex` で指定された行の成分に行列`source`を代入します。
`void` | `setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, DoubleMatrix source)` `rowIndex`で指定した行の`columnMin`列から`columnMax` 列までの行列`value`を代入します。
`void` | `setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, Matrix source)` `rowIndex`で指定した行の`columnMinimum`列から`columnMaximum` 列までの行列`source`を代入します。
`void` | `setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, DoubleMatrix source)` `rowIndex`で指定した行の`columnIndex`で指定した列に行列`valueを代入します。`
`void` | `setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)` `rowIndex`で指定した行の`columnIndex`で指定した列に行列`source`を代入します。
`void` | `setSubVector(int min, int max, DoubleMatrix source)` 成分を行毎に数え、`min`から`max`までに`source`の成分を代入します。
`void` | `setSubVector(int min, int max, Matrix source)` 成分を行毎に数え、`minimum`から`maximum`までに`source`の成分を代入します。
`void` | `setSubVector(IntMatrix index, DoubleMatrix source)` `index`で指定した各成分に行列`value`の成分を代入します。
`void` | `setSubVector(IntMatrix index, Matrix source)` `index`で指定した各成分に行列`source`の成分を代入します。
`DoubleMatrix` | `signumElementWise()` 各成分の符合(-1,0,1)を成分に持つ行列を返します。
`DoubleMatrix` | `sinElementWise()` 成分毎の正弦関数の結果からなる行列を返します。
`DoubleMatrix` | `singularValue()` 特異値を成分とする列ベクトルを返します。
`SingularValueDecomposition<DoubleMatrix>` | `singularValueDecompose()` 特異値分解で得られる各行列を返します。
`DoubleMatrix` | `sinhElementWise()` 成分毎の双曲線正弦関数の結果からなる行列を返します。
`IndexedMatrix<DoubleMatrix>` | `sort()` 全ての成分を昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。
`IndexedMatrix<DoubleMatrix>` | `sortColumnWise()` 列毎に昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。
`IndexedMatrix<DoubleMatrix>` | `sortRowWise()` 行毎に昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。
`DoubleComplexMatrix` | `sqrt()` 平方根行列を返します。
`DoubleMatrix` | `sqrtElementWise()` 成分毎の平方根の結果からなる行列を返します。
`DoubleNumber` | `std()` 標準偏差を返します。
`DoubleMatrix` | `stdColumnWise()` 各成分列毎の標準偏差行ベクトルを返します。
`DoubleMatrix` | `stdRowWise()` 各成分行毎の標準偏差列ベクトルを返します。
`DoubleMatrix` | `subtract(DoubleMatrix value)` 行列`value`との差行列を生成します。
`DoubleMatrix` | `subtractElementWise(double value)` 成分毎に実数を引きます。
`DoubleMatrix` | `subtractElementWise(int value)` 成分毎に実数を引きます。
`Matrix` | `subtractElementWise(Scalar<?> value)` 成分毎にスカラーを引きます。
`DoubleNumber` | `sum()` 全ての成分の合計を返します。
`DoubleMatrix` | `sumColumnWise()` 列毎に加えた行ベクトルを返します。
`DoubleMatrix` | `sumRowWise()` 行毎に加えた列ベクトルを返します。
`DoubleMatrix` | `tanElementWise()` 成分毎の正接関数の結果からなる行列を返します。
`DoubleMatrix` | `tanhElementWise()` 成分毎の双曲線正接関数の結果からなる行列を返します。
`DoubleComplexMatrix` | `toComplex()` 複素成分行列へ変換します。
`String` | `toMmString()` MM形式の文字列を生成します。
`String` | `toMmString(String format)` MM形式の文字列を生成します。
`DoubleNumber` | `trace()` 全対角成分の和を返します。
`DoubleMatrix` | `transformFrom(Matrix value)` 引数で与えられた型からこの型へ変換します。
`DoubleMatrix` | `transpose()` 転置行列(`this` T )を生成します。
`DoubleMatrix` | `unaryMinus()` 符号を反転した値(-this)を返します。
`static DoubleMatrix` | `uniformRandom(Grid matrix)` 0以上1より小さい一様分布のランダムな成分を持つ`matrix`と同じ大きさの実行列を生成します。
`static DoubleMatrix` | `uniformRandom(int size)` 0以上1より小さい一様分布のランダムな成分を持つ`size`*`size`の実行列を生成します。
`static DoubleMatrix` | `uniformRandom(int rowSize, int columnSize)` 0以上1より小さい一様分布のランダムな成分を持つ`rowSize`*`columnSize` の実行列を生成します。
`static DoubleMatrix` | `uniformRandom(int rowSize, int columnSize, long seed)` 一様乱数の種をseedで指定し, その種によって生成される、0以上1未満の一様分布の 乱数成分をもつ`rowSize`*`columnSize`の 実行列を生成します。
`static DoubleMatrix` | `unit(int size)` `size`*`size`の単位行列を生成します。
`static DoubleMatrix` | `unit(int rowSize, int columnSize)` `rowSize`*`columnSize`の実単位行列を生成します。
`static DoubleMatrix` | `unit(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber`*`columnNumber` 倍の実単位行列を生成します。
`static DoubleMatrix` | `unit(Matrix matrix)` 行列`matrix`と同サイズの実単位行列を生成します。
`DoubleNumber` | `variance()` 全ての成分の分散を返します。
`DoubleMatrix` | `vectorToDiagonal()` 列ベクトルまたは行ベクトルの各成分を対角成分に持つ行列を生成します。
`void` | `writeMatFormat(OutputStream output)` データをMATフォーマットで出力ストリームに出力します。
`void` | `writeMatFormat(String fileName)` データを指定したファイルにMATフォーマットで保存します。
`void` | `writeMmFormat(String fileName, String name)` MMファイル形式で行列データをファイルに出力します。
`void` | `writeMmFormat(Writer output, String name, boolean withNewLine)` MMフォーマット行列データをライターに出力します。
`void` | `writeMxFormat(OutputStream output, String name)` データをMX形式で出力ストリームへ出力します。
`void` | `writeMxFormat(String fileName, String name)` データをMX形式でファイルへ出力します。
`static DoubleMatrix` | `zero(Grid matrix)` 行列`matrix`と同サイズの零行列を生成します。
`static DoubleMatrix` | `zero(int rowNumber, int columnNumber, Grid block)` 行列`block`の`rowNumber` * `columnNumber`倍の零行列を生成します。

クラス org.mklab.nfc.matrix.AbstractMatrix から継承されたメソッド
`add, covariance, createOnes, createOnes, createOnes, createUnit, createUnit, createUnit, createZero, createZero, createZero, divide, divideElementWise, isTransformableTo, isUnit, isZero, leftDivide, leftDivide, leftDivide, leftDivide, leftDivideElementWise, multiply, multiplyElementWise, power, roundToZeroElementWise, shiftLeft, shiftUp, subtract, transformTo, transformToSameClass`

クラス org.mklab.nfc.matrix.AbstractFundamentalMatrix から継承されたメソッド
`appendDown, appendRight, flipLeftRight, flipUpDown, getColumnVector, getColumnVectors, getColumnVectors, getRowVector, getRowVectors, getRowVectors, getSubMatrix, getSubMatrix, getSubMatrix, getSubVector, getSubVector, rotateLeft, rotateUp, setColumnVector, setColumnVectors, setColumnVectors, setRowVector, setRowVectors, setRowVectors, setSubMatrix, setSubMatrix, setSubMatrix, setSubVector`

クラス org.mklab.nfc.matrix.AbstractGrid から継承されたメソッド
`count, getColumnSize, getDefaultElementAlignment, getElementAlignment, getElementFormat, getPrintingElementsString, getPrintingString, getRowSize, hasSameColumnSize, hasSameRowSize, isEmpty, isSameSize, isSquare, length, print, print, print, removeColumnVector, removeRowVector, setColumnSize, setDefaultElementAlignment, setElementAlignment, setElementFormat, setRowSize, toString`

クラス java.lang.Object から継承されたメソッド
`finalize, getClass, notify, notifyAll, wait, wait, wait`

インタフェース org.mklab.nfc.matrix.Matrix から継承されたメソッド
`add, covariance, createOnes, createOnes, createOnes, createUnit, createUnit, createUnit, createZero, createZero, createZero, divide, isTransformableTo, isUnit, leftDivide, leftDivide, leftDivide, leftDivide, multiply, power, shiftLeft, shiftUp, subtract, transformTo`

インタフェース org.mklab.nfc.matrix.FundamentalMatrix から継承されたメソッド
`appendDown, appendRight, flipLeftRight, flipUpDown, getColumnVector, getColumnVectors, getColumnVectors, getRowVector, getRowVectors, getRowVectors, getSubMatrix, getSubMatrix, getSubMatrix, getSubVector, getSubVector, rotateLeft, rotateUp, setColumnVector, setColumnVectors, setColumnVectors, setRowVector, setRowVectors, setRowVectors, setSubMatrix, setSubMatrix, setSubMatrix, setSubVector`

インタフェース org.mklab.nfc.matrix.Grid から継承されたメソッド
`count, getColumnSize, getElementAlignment, getElementFormat, getPrintingElementsString, getPrintingString, getRowSize, hasSameColumnSize, hasSameRowSize, isEmpty, isSameSize, isSquare, isZero, length, print, print, print, removeColumnVector, removeRowVector, setElementAlignment, setElementFormat`

インタフェース org.mklab.nfc.matrix.MatrixElementWiseOperator から継承されたメソッド
`divideElementWise, leftDivideElementWise, multiplyElementWise, roundToZeroElementWise`

コンストラクタの詳細

### DoubleMatrix

    public DoubleMatrix()

  0*0の`DoubleMatrix`を生成します。

### DoubleMatrix

    public DoubleMatrix(double[] elements)

  `elements`で与えられた成分を持つ行ベクトルを生成します。

  パラメータ:
    `elements` - ベクトルの成分をもつ配列

### DoubleMatrix

    public DoubleMatrix(DoubleNumber[] elements)

  `elements`で与えられた成分を持つ行ベクトルを生成します。

  パラメータ:
    `elements` - ベクトルの成分をもつ配列

### DoubleMatrix

    public DoubleMatrix(int rowSize,
                        int columnSize)

  `rowSize * columnSize` の`DoubleMatrix`零行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数

### DoubleMatrix

    public DoubleMatrix(double[][] elements)

  与えられた成分をもつ`DoubleMatrix`を生成します。

  パラメータ:
    `elements` - 行列の成分

### DoubleMatrix

    public DoubleMatrix(DoubleNumber[][] elements)

  与えられた成分をもつ`DoubleMatrix`を生成します。

  パラメータ:
    `elements` - 行列の成分

### DoubleMatrix

    public DoubleMatrix(int rowSize,
                        int columnSize,
                        double[][] elements)

  与えられた成分をもつ `rowSize * columnSize` の `DoubleMatrix`を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `elements` - 行列の成分

### DoubleMatrix

    public DoubleMatrix(int rowSize,
                        int columnSize,
                        DoubleNumber[][] elements)

  与えられた成分をもつ `rowSize * columnSize` の `DoubleMatrix`を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `elements` - 行列の成分

### DoubleMatrix

    public DoubleMatrix(IntMatrix matrix)

  新しく生成された`DoubleMatrix`オブジェクトを初期化します。

  パラメータ:
    `matrix` - 整数行列

メソッドの詳細

### setDefaultElementFormat

    public static void setDefaultElementFormat(String format)

  成分のデフォルト出力フォーマットを設定します。

  パラメータ:
    `format` - 成分のデフォルト出力フォーマット

### getDefaultElementFormat

    public static String getDefaultElementFormat()

  成分のデフォルト出力フォーマットを返します。

  戻り値:
    成分のデフォルト出力フォーマット

### clone

    public DoubleMatrix clone()

  クラス `AbstractGrid` の記述:
  Object#clone()

  定義:
    インタフェース `Grid` 内の `clone`
  オーバーライド:
    クラス `AbstractGrid<DoubleMatrix>` 内の `clone`
  戻り値:
    複製(クローン)
  関連項目:
    `AbstractGrid.clone()`

### equals

    public boolean equals(Object opponent)

  オーバーライド:
    クラス `Object` 内の `equals`
  関連項目:
    `Object.equals(java.lang.Object)`

### equals

    public boolean equals(Matrix opponent,
                          double tolerance)

  インタフェース `FundamentalMatrix` の記述:
  行列`opponent`と値が許容誤差以内で等しいか判定します。

  定義:
    インタフェース `FundamentalMatrix` 内の `equals`
  パラメータ:
    `opponent` - 比較する行列
    `tolerance` - 許容誤差
  戻り値:
    等しければtrue、そうでなければfalse
  関連項目:
    `FundamentalMatrix.equals(org.mklab.nfc.matrix.Matrix, double)`

### equals

    public boolean equals(DoubleMatrix opponent,
                          double tolerance)

  許容誤差内で行列`opponent`と等しいか判定します。

  パラメータ:
    `opponent` - 実行列
    `tolerance` - 許容誤差
  戻り値:
    `opponent`と等しければtrue、そうでなければfalse

### hashCode

    public int hashCode()

  オーバーライド:
    クラス `AbstractGrid<DoubleMatrix>` 内の `hashCode`
  関連項目:
    `AbstractGrid.hashCode()`

### isTransformableFrom

    public boolean isTransformableFrom(Matrix value)

  インタフェース `Matrix` の記述:
  引数で与えられた型から、この型へ変換可能か判定します。

  定義:
    インタフェース `Matrix` 内の `isTransformableFrom`
  オーバーライド:
    クラス `AbstractMatrix<DoubleMatrix>` 内の `isTransformableFrom`
  パラメータ:
    `value` - 変換元
  戻り値:
    変換可能ならtrue、そうでなければfalse
  関連項目:
    `Matrix.isTransformableFrom(org.mklab.nfc.matrix.Matrix)`

### transformFrom

    public DoubleMatrix transformFrom(Matrix value)

  インタフェース `Matrix` の記述:
  引数で与えられた型からこの型へ変換します。

  定義:
    インタフェース `Matrix` 内の `transformFrom`
  オーバーライド:
    クラス `AbstractMatrix<DoubleMatrix>` 内の `transformFrom`
  パラメータ:
    `value` - 変換元
  戻り値:
    変換で生成された値
  関連項目:
    `Matrix.transformFrom(org.mklab.nfc.matrix.Matrix)`

### add

    public DoubleMatrix add(DoubleMatrix value)

  行列`value`との和行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    `value`との和

### subtract

    public DoubleMatrix subtract(DoubleMatrix value)

  行列`value`との差行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    `value`との差

### multiply

    public DoubleMatrix multiply(int value)

  インタフェース `Matrix` の記述:
  各成分と整数`value`の積を(`this`*`value`)を返します。

  定義:
    インタフェース `Matrix` 内の `multiply`
  パラメータ:
    `value` - 整数
  戻り値:
    各成分と整数`value`の積
  関連項目:
    `Matrix.multiply(int)`

### multiply

    public DoubleMatrix multiply(double value)

  インタフェース `Matrix` の記述:
  各成分と実数`value`の積を(`this`*`value`)を返します。

  定義:
    インタフェース `Matrix` 内の `multiply`
  パラメータ:
    `value` - 実数
  戻り値:
    各成分と実数`value`の積
  関連項目:
    `Matrix.multiply(double)`

### multiply

    public Matrix multiply(Scalar<?> value)

  インタフェース `Matrix` の記述:
  各成分とスカラー`value`の積を返します。

  定義:
    インタフェース `Matrix` 内の `multiply`
  パラメータ:
    `value` - スカラー
  戻り値:
    各成分と`value`の積
  関連項目:
    `Matrix.multiply(org.mklab.nfc.scalar.Scalar)`

### multiply

    public DoubleMatrix multiply(DoubleMatrix value)

  行列`value`との積行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    `value`との積

### conjugate

    public DoubleMatrix conjugate()

  インタフェース `Matrix` の記述:
  共役複素行列を返します。

  定義:
    インタフェース `Matrix` 内の `conjugate`
  戻り値:
    共役複素行列
  関連項目:
    `Matrix.conjugate()`

### transpose

    public DoubleMatrix transpose()

  インタフェース `FundamentalMatrix` の記述:
  転置行列(`this` T )を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `transpose`
  戻り値:
    転置行列
  関連項目:
    `FundamentalMatrix.transpose()`

### conjugateTranspose

    public DoubleMatrix conjugateTranspose()

  インタフェース `Matrix` の記述:
  各成分の共役複素数の転置行列を返します。

  定義:
    インタフェース `Matrix` 内の `conjugateTranspose`
  戻り値:
    複素共役転置
  関連項目:
    `Matrix.conjugateTranspose()`

### determinant

    public DoubleNumber determinant()

  インタフェース `MatrixElementOperator` の記述:
  行列式を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `determinant`
  戻り値:
    行列式
  関連項目:
    `MatrixElementOperator.determinant()`

### determinant

    public double determinant(NumericalScalar<?> tolerance,
                              boolean stopIfSingular)

  行列式を返します。

  パラメータ:
    `tolerance` - 許容誤差
    `stopIfSingular` - trueならば、正則でない場合、処理を中止し、例外を投げます。
  戻り値:
    行列式

### inverse

    public DoubleMatrix inverse(double tolerance,
                                boolean stopIfSingular)

  インタフェース `Matrix` の記述:
  逆行列(`this` -1 )を返します。

  定義:
    インタフェース `Matrix` 内の `inverse`
  パラメータ:
    `tolerance` - 許容誤差
    `stopIfSingular` - trueならば、正則でない場合、処理を中止し、例外を投げます。
  戻り値:
    逆行列
  関連項目:
    `Matrix.inverse(double, boolean)`

### inverse

    public DoubleMatrix inverse(NumericalScalar<?> tolerance,
                                boolean stopIfSingular)

  インタフェース `NumericalMatrixOperator` の記述:
  逆行列(`this` -1 )を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `inverse`
  パラメータ:
    `tolerance` - 許容誤差
    `stopIfSingular` - trueならば、正則でない場合、処理を中止し、例外を投げます。
  戻り値:
    逆行列
  関連項目:
    `NumericalMatrixOperator.inverse(org.mklab.nfc.scalar.NumericalScalar, boolean)`

### inverseElementWise

    public DoubleMatrix inverseElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎の逆数からなる行列を返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `inverseElementWise`
  戻り値:
    成分毎逆数行列
  関連項目:
    `MatrixElementWiseOperator.inverseElementWise()`

### divide

    public DoubleMatrix divide(int value)

  インタフェース `Matrix` の記述:
  各成分と整数valueの商(`this`/`value`)を返します。

  定義:
    インタフェース `Matrix` 内の `divide`
  パラメータ:
    `value` - 割る整数
  戻り値:
    各成分と`value`との商
  関連項目:
    `Matrix.divide(int)`

### divide

    public DoubleMatrix divide(double value)

  インタフェース `Matrix` の記述:
  各成分と実数valueの商(`this`/`value`)を返します。

  定義:
    インタフェース `Matrix` 内の `divide`
  パラメータ:
    `value` - 割る実数
  戻り値:
    各成分と`value`との商
  関連項目:
    `Matrix.divide(double)`

### divide

    public Matrix divide(Scalar<?> value)

  インタフェース `Matrix` の記述:
  各成分とスカラーの商からなる行列を返します。

  定義:
    インタフェース `Matrix` 内の `divide`
  パラメータ:
    `value` - スカラー
  戻り値:
    各成分と`value`の商
  関連項目:
    `Matrix.divide(org.mklab.nfc.scalar.Scalar)`

### divide

    public DoubleMatrix divide(DoubleMatrix value)

  行列`value`の逆行列との積(`this`*`value` -1 )を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    `value`の逆行列との積

### leftDivide

    public DoubleMatrix leftDivide(DoubleMatrix value)

  自身の逆行列と行列`value`の積(`this` -1 *`value`)を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    自身の逆行列と`value`の積

### unaryMinus

    public DoubleMatrix unaryMinus()

  インタフェース `Matrix` の記述:
  符号を反転した値(-this)を返します。

  定義:
    インタフェース `Matrix` 内の `unaryMinus`
  戻り値:
    符号を反転した値
  関連項目:
    `Matrix.unaryMinus()`

### getSubMatrix

    public DoubleMatrix getSubMatrix(int rowMin,
                                     int rowMax,
                                     int columnMin,
                                     int columnMax)

  インタフェース `FundamentalMatrix` の記述:
  部分行列`this(rowMinimum:rowMaximum,columnMinimum:columnMaximum)`を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `getSubMatrix`
  パラメータ:
    `rowMin` - 開始行番号(1から始まります)
    `rowMax` - 終了行番号(1から始まります)
    `columnMin` - 開始列番号(1から始まります)
    `columnMax` - 終了列番号(1から始まります)
  戻り値:
    自身の部分行列
  関連項目:
    `FundamentalMatrix.getSubMatrix(int, int, int, int)`

### removeRowVectors

    public void removeRowVectors(int rowMin,
                                 int rowMax)

  インタフェース `Grid` の記述:
  `rowMin`行から`rowMax`行までを削除します。

  定義:
    インタフェース `Grid` 内の `removeRowVectors`
  パラメータ:
    `rowMin` - 行の始まり
    `rowMax` - 行の終わり
  関連項目:
    `Grid.removeRowVectors(int, int)`

### removeRowVectors

    public void removeRowVectors(IntMatrix rowIndex)

  インタフェース `Grid` の記述:
  `rowIndex`で指定された行を削除します。

  定義:
    インタフェース `Grid` 内の `removeRowVectors`
  パラメータ:
    `rowIndex` - 行指定ベクトル
  関連項目:
    `Grid.removeRowVectors(org.mklab.nfc.matrix.IntMatrix)`

### removeColumnVectors

    public void removeColumnVectors(int columnMin,
                                    int columnMax)

  インタフェース `Grid` の記述:
  `columnMin`列から`columnMax`列までを削除します。

  定義:
    インタフェース `Grid` 内の `removeColumnVectors`
  パラメータ:
    `columnMin` - 列の始まり
    `columnMax` - 列の終わり
  関連項目:
    `Grid.removeColumnVectors(int, int)`

### removeColumnVectors

    public void removeColumnVectors(IntMatrix columnIndex)

  インタフェース `Grid` の記述:
  `columnIndex`で指定された列を削除します。

  定義:
    インタフェース `Grid` 内の `removeColumnVectors`
  パラメータ:
    `columnIndex` - 列指定ベクトル
  関連項目:
    `Grid.removeColumnVectors(org.mklab.nfc.matrix.IntMatrix)`

### getSubMatrix

    public DoubleMatrix getSubMatrix(IntMatrix rowIndex,
                                     int columnMin,
                                     int columnMax)

  インタフェース `FundamentalMatrix` の記述:
  `columnMinimum`列から`columnMaximum`列まで、 `rowIndex`で指定された行を成分とする部分行列を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `getSubMatrix`
  パラメータ:
    `rowIndex` - 行指定ベクトル
    `columnMin` - 開始列番号(1から始まります)
    `columnMax` - 終了列番号(1から始まります)
  戻り値:
    部分行列
  関連項目:
    `FundamentalMatrix.getSubMatrix(org.mklab.nfc.matrix.IntMatrix, int, int)`

### getSubMatrix

    public DoubleMatrix getSubMatrix(int rowMin,
                                     int rowMax,
                                     IntMatrix columnIndex)

  インタフェース `FundamentalMatrix` の記述:
  `rowMinimum`行から`rowMaximum`行目で、`columnIndex` で指定された列を成分とする部分行列を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `getSubMatrix`
  パラメータ:
    `rowMin` - 開始行番号(1から始まります)
    `rowMax` - 終了行番号(1から始まります)
    `columnIndex` - 列指定ベクトル
  戻り値:
    部分行列
  関連項目:
    `FundamentalMatrix.getSubMatrix(int, int, org.mklab.nfc.matrix.IntMatrix)`

### getSubMatrix

    public DoubleMatrix getSubMatrix(IntMatrix rowIndex,
                                     IntMatrix columnIndex)

  インタフェース `FundamentalMatrix` の記述:
  `rowIndex`で指定された行で、`columnIndex` で指定された列を成分とする部分行列を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `getSubMatrix`
  パラメータ:
    `rowIndex` - 行指定ベクトル
    `columnIndex` - 列指定ベクトル
  戻り値:
    部分行列
  関連項目:
    `FundamentalMatrix.getSubMatrix(org.mklab.nfc.matrix.IntMatrix, org.mklab.nfc.matrix.IntMatrix)`

### getSubVector

    public DoubleMatrix getSubVector(IntMatrix index)

  インタフェース `FundamentalMatrix` の記述:
  行毎に数え`index`で指定した成分を成分とする部分行列を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `getSubVector`
  パラメータ:
    `index` - 行番号を含むベクトル
  戻り値:
    部分行列
  関連項目:
    `FundamentalMatrix.getSubVector(org.mklab.nfc.matrix.IntMatrix)`

### getDoubleElement

    public double getDoubleElement(int row,
                                   int column)

  `row`行`column`列の成分を返します。

  パラメータ:
    `row` - 行番号(1から始まる)
    `column` - 列番号(1から始まる)
  戻り値:
    row行column列の成分

### getElement

    public DoubleNumber getElement(int row,
                                   int column)

  インタフェース `MatrixElementOperator` の記述:
  `row`行`column`列の成分を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `getElement`
  パラメータ:
    `row` - 行番号(1から始まる)
    `column` - 列番号(1から始まる)
  戻り値:
    row行column列の成分
  関連項目:
    `MatrixElementOperator.getElement(int, int)`

### getDoubleElement

    public double getDoubleElement(int index)

  成分を行毎に数え、指定した位置の成分を返します。

  パラメータ:
    `index` - 成分の番号(1から始まる)
  戻り値:
    指定した成分

### getElement

    public DoubleNumber getElement(int index)

  インタフェース `MatrixElementOperator` の記述:
  成分を行毎に数え`index`で指定した成分を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `getElement`
  パラメータ:
    `index` - 成分の番号(1から始まる)
  戻り値:
    指定された成分
  関連項目:
    `MatrixElementOperator.getElement(int)`

### setSubMatrix

    public void setSubMatrix(IntMatrix rowIndex,
                             int columnMin,
                             int columnMax,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  `rowIndex`で指定した行の`columnMinimum`列から`columnMaximum` 列までの行列`source`を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubMatrix`
  パラメータ:
    `rowIndex` - 行番号のリスト
    `columnMin` - 開始列番号(1から始まります)
    `columnMax` - 終了列番号(1から始まります)
    `source` - 代入する行列
  関連項目:
    `FundamentalMatrix.setSubMatrix(org.mklab.nfc.matrix.IntMatrix, int, int, org.mklab.nfc.matrix.Matrix)`

### setSubMatrix

    public void setSubMatrix(IntMatrix rowIndex,
                             int columnMin,
                             int columnMax,
                             DoubleMatrix source)

  `rowIndex`で指定した行の`columnMin`列から`columnMax` 列までの行列`value`を代入します。

  パラメータ:
    `rowIndex` - 行番号を指定する指数(1から始まる)
    `columnMin` - 列の始まり
    `columnMax` - 列の終わり
    `source` - 代入する行列

### setSubMatrix

    public void setSubMatrix(IntMatrix rowIndex,
                             IntMatrix columnIndex,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  `rowIndex`で指定した行の`columnIndex`で指定した列に行列`source`を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubMatrix`
  パラメータ:
    `rowIndex` - 行番号のリスト
    `columnIndex` - 列番号のリスト
    `source` - 代入する行列
  関連項目:
    `FundamentalMatrix.setSubMatrix(org.mklab.nfc.matrix.IntMatrix, org.mklab.nfc.matrix.IntMatrix, org.mklab.nfc.matrix.Matrix)`

### setSubMatrix

    public void setSubMatrix(IntMatrix rowIndex,
                             IntMatrix columnIndex,
                             DoubleMatrix source)

  `rowIndex`で指定した行の`columnIndex`で指定した列に行列`valueを代入します。

  `
  パラメータ:
    `rowIndex` - 行番号を指定する指数(1から始まる)
    `columnIndex` - 列番号を指定する指数(1から始まる)
    `source` - 代入する行列

### setSubMatrix

    public void setSubMatrix(int rowMin,
                             int rowMax,
                             IntMatrix columnIndex,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  `rowMinimum`列目から`rowMaximum`列目の成分の`columnIndex` で指定された行の成分に行列`source`を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubMatrix`
  パラメータ:
    `rowMin` - 開始行番号(1から始まります)
    `rowMax` - 終了行番号(1から始まります)
    `columnIndex` - 列番号のリスト
    `source` - 代入する行列
  関連項目:
    `FundamentalMatrix.setSubMatrix(int, int, org.mklab.nfc.matrix.IntMatrix, org.mklab.nfc.matrix.Matrix)`

### setSubMatrix

    public void setSubMatrix(int rowMin,
                             int rowMax,
                             IntMatrix columnIndex,
                             DoubleMatrix source)

  `rowMin`列から`rowMax`列目の成分の`columnIndex` で指定された行に行列`value`の成分を代入します。

  パラメータ:
    `rowMin` - 行指定
    `rowMax` - 行指定
    `columnIndex` - 列指定ベクトル
    `source` - 行列

### setSubMatrix

    public void setSubMatrix(int rowMin,
                             int rowMax,
                             int columnMin,
                             int columnMax,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  指定した成分に行列`source`を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubMatrix`
  パラメータ:
    `rowMin` - 開始行番号(1から始まります)
    `rowMax` - 終了行番号(1から始まります)
    `columnMin` - 開始列番号(1から始まります)
    `columnMax` - 終了列番号(1から始まります)
    `source` - 代入する行列
  関連項目:
    `FundamentalMatrix.setSubMatrix(int, int, int, int, org.mklab.nfc.matrix.Matrix)`

### setSubMatrix

    public void setSubMatrix(int rowMin,
                             int rowMax,
                             int columnMin,
                             int columnMax,
                             DoubleMatrix source)

  指定した成分に行列`source`を代入します。

  パラメータ:
    `rowMin` - 開始行番号(1から始まります)
    `rowMax` - 終了行番号(1から始まります)
    `columnMin` - 開始列番号(1から始まります)
    `columnMax` - 終了列番号(1から始まります)
    `source` - 代入する行列

### setSubVector

    public void setSubVector(int min,
                             int max,
                             DoubleMatrix source)

  成分を行毎に数え、`min`から`max`までに`source`の成分を代入します。

  パラメータ:
    `min` - 開始位置(1から始まります)
    `max` - 終了位置(1から始まります)
    `source` - 代入するベクトル

### setSubVector

    public void setSubVector(int min,
                             int max,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  成分を行毎に数え、`minimum`から`maximum`までに`source`の成分を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubVector`
  パラメータ:
    `min` - 開始位置(1から始まります)
    `max` - 終了位置(1から始まります)
    `source` - 代入するベクトル
  関連項目:
    `FundamentalMatrix.setSubVector(int, int, org.mklab.nfc.matrix.Matrix)`

### setSubVector

    public void setSubVector(IntMatrix index,
                             Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  `index`で指定した各成分に行列`source`の成分を代入します。

  定義:
    インタフェース `FundamentalMatrix` 内の `setSubVector`
  パラメータ:
    `index` - 成分の番号のリスト
    `source` - 代入する行列
  関連項目:
    `FundamentalMatrix.setSubVector(org.mklab.nfc.matrix.IntMatrix, org.mklab.nfc.matrix.Matrix)`

### setSubVector

    public void setSubVector(IntMatrix index,
                             DoubleMatrix source)

  `index`で指定した各成分に行列`value`の成分を代入します。

  パラメータ:
    `index` - 位置をもつベクトル
    `source` - 設定する行列

### setElement

    public void setElement(int row,
                           int column,
                           int value)

  インタフェース `MatrixElementOperator` の記述:
  指定した成分に`value`を代入します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `row` - 行番号(1から始まる)
    `column` - 列番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, int, int)`

### setElement

    public void setElement(int row,
                           int column,
                           double value)

  インタフェース `MatrixElementOperator` の記述:
  指定した成分に`value`を代入します。

  ``
  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `row` - 行番号(1から始まる)
    `column` - 列番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, int, double)`

### setElement

    public void setElement(int row,
                           int column,
                           Scalar<?> value)

  インタフェース `MatrixElementOperator` の記述:
  指定した成分に`value`を代入します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `row` - 行番号(1から始まる)
    `column` - 列番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, int, org.mklab.nfc.scalar.Scalar)`

### setElement

    public void setElement(int index,
                           int value)

  インタフェース `MatrixElementOperator` の記述:
  成分を行毎に数え`index`で指定した位置に`value`を代入します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `index` - 成分の番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, int)`

### setElement

    public void setElement(int index,
                           Scalar<?> value)

  インタフェース `MatrixElementOperator` の記述:
  成分を行毎に数え`index`で指定した位置に`value`を代入します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `index` - 成分の番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, org.mklab.nfc.scalar.Scalar)`

### setElement

    public void setElement(int index,
                           double value)

  インタフェース `MatrixElementOperator` の記述:
  成分を行毎に数え`index`で指定した位置に`value`を代入します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `setElement`
  パラメータ:
    `index` - 成分の番号(1から始まる)
    `value` - 代入する値
  関連項目:
    `MatrixElementOperator.setElement(int, double)`

### appendRight

    public DoubleMatrix appendRight(DoubleMatrix value)

  右側に`value`を連結した行列を生成します。

  パラメータ:
    `value` - 連結する行列
  戻り値:
    右側に`value`を連結行列した

### appendDown

    public DoubleMatrix appendDown(DoubleMatrix value)

  下側に実数行列`value`を連結した行列を生成します。

  パラメータ:
    `value` - 連結する実数行列
  戻り値:
    下側に`value`を連結した行列

### writeMatFormat

    public void writeMatFormat(String fileName)
                        throws IOException

  データを指定したファイルにMATフォーマットで保存します。

  パラメータ:
    `fileName` - ファイル名
  例外:
    `IOException` - ファイルに出力できない場合

### writeMatFormat

    public void writeMatFormat(OutputStream output)
                        throws IOException

  データをMATフォーマットで出力ストリームに出力します。

  パラメータ:
    `output` - 出力ストリーム
  例外:
    `IOException` - 入出力エラーが発生した場合

### readMatFormat

    public static DoubleMatrix readMatFormat(int rowSize,
                                             int columnSize,
                                             StreamTokenizer stringTokennizer)
                                      throws IOException

  `MatxMatrix.readMatFormat(String)`用の中間メソッドです。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `stringTokennizer` - matファイルから読み込んだ `StreamTokenizer`
  戻り値:
    matファイルから読み込み,生成された行列
  例外:
    `IOException` - 入出力エラーが発生した場合

### writeMxFormat

    public void writeMxFormat(OutputStream output,
                              String name)
                       throws IOException

  インタフェース `MatxObject` の記述:
  データをMX形式で出力ストリームへ出力します。 outputがcloseされるまで、いくつでも出力可能です。

  定義:
    インタフェース `MatxObject` 内の `writeMxFormat`
  パラメータ:
    `output` - 出力ストリーム
    `name` - データの名前
  例外:
    `IOException` - 出力ストリームに出力できない場合
  関連項目:
    `MatxObject.writeMxFormat(java.io.OutputStream, java.lang.String)`

### writeMxFormat

    public void writeMxFormat(String fileName,
                              String name)
                       throws IOException

  インタフェース `MatxObject` の記述:
  データをMX形式でファイルへ出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMxFormat`
  パラメータ:
    `fileName` - ファイル名
    `name` - データの名前
  例外:
    `IOException` - ファイルに出力できない場合
  関連項目:
    `MatxObject.writeMxFormat(java.lang.String, java.lang.String)`

### readMxFormat

    public static DoubleMatrix readMxFormat(InputStream input,
                                            MxDataHead head)
                                     throws IOException

  `MatxMatrix.readMxFormat(InputStream)` から呼ばれる中間メソッドです。

  このメソッドは直接使わず

  > `Matrix`A = Matrix. `MatxMatrix.readMxFormat(String)`

  の形で`Matrix`の `MatxMatrix.readMxFormat(String)`を使う

  パラメータ:
    `input` - 入力ストリーム
    `head` - ヘッダー
  戻り値:
    mxファイルから読み込み,生成された行列
  例外:
    `IOException` - 入力ストリームから読み込めない場合

### toMmString

    public String toMmString()

  インタフェース `MatxObject` の記述:
  MM形式の文字列を生成します。

  定義:
    インタフェース `MatxObject` 内の `toMmString`
  戻り値:
    MM形式の文字列
  関連項目:
    `MatxObject.toMmString()`

### toMmString

    public String toMmString(String format)

  インタフェース `MatxObject` の記述:
  MM形式の文字列を生成します。

  定義:
    インタフェース `MatxObject` 内の `toMmString`
  パラメータ:
    `format` - 出力フォーマット
  戻り値:
    MM形式の文字列
  関連項目:
    `MatxObject.toMmString(java.lang.String)`

### writeMmFormat

    public void writeMmFormat(String fileName,
                              String name)
                       throws IOException

  インタフェース `MatxObject` の記述:
  MMファイル形式で行列データをファイルに出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMmFormat`
  パラメータ:
    `fileName` - ファイル名
    `name` - 名前
  例外:
    `IOException` - ファイルに出力できない場合
  関連項目:
    `MatxObject.writeMmFormat(java.lang.String, java.lang.String)`

### writeMmFormat

    public void writeMmFormat(Writer output,
                              String name,
                              boolean withNewLine)
                       throws IOException

  インタフェース `MatxObject` の記述:
  MMフォーマット行列データをライターに出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMmFormat`
  パラメータ:
    `output` - ライター
    `name` - 名前
    `withNewLine` - セミコロンと改行コードを出力するならばtrue、そうでなければfalse
  例外:
    `IOException` - ライターに出力できない場合
  関連項目:
    `MatxObject.writeMmFormat(java.io.Writer, java.lang.String, boolean)`

### zero

    public static DoubleMatrix zero(Grid matrix)

  行列`matrix`と同サイズの零行列を生成します。

  パラメータ:
    `matrix` - 行列
  戻り値:
    `value`と同サイズの零行列

### zero

    public static DoubleMatrix zero(int rowNumber,
                                    int columnNumber,
                                    Grid block)

  行列`block`の`rowNumber` * `columnNumber`倍の零行列を生成します。

  パラメータ:
    `rowNumber` - 行方向の倍数
    `columnNumber` - 列方向の倍数
    `block` - 基本となる行列
  戻り値:
    `block`の`rowNumber` * `columnNumber`倍の零行列

### ones

    public static DoubleMatrix ones(int size)

  `size`*`size`の全成分が1である行列を生成します。

  パラメータ:
    `size` - サイズ指定
  戻り値:
    size*sizeの全成分が1である行列

### ones

    public static DoubleMatrix ones(int rowSize,
                                    int columnSize)

  `rowSize`*`columnSize`の全成分が1である行列を生成します。

  パラメータ:
    `rowSize` - 行番号の指定
    `columnSize` - 列番号の指定
  戻り値:
    `rowSize`*`columnSize`の全成分が1である行列

### ones

    public static DoubleMatrix ones(Grid matrix)

  行列`matrix`と同サイズの全成分が1である行列を生成します。

  パラメータ:
    `matrix` - 行列
  戻り値:
    `matrix`と同サイズの全成分が1である行列

### ones

    public static DoubleMatrix ones(int rowNumber,
                                    int columnNumber,
                                    Grid block)

  行列`block`の`rowNumber` * `columnNumber`倍の全成分が1である行列を生成します。

  パラメータ:
    `rowNumber` - 行方向の倍数
    `columnNumber` - 列方向の倍数
    `block` - 基本となる行列
  戻り値:
    `block`の`rowNumber` * `columnNumber`倍の全成分が1である行列

### uniformRandom

    public static DoubleMatrix uniformRandom(Grid matrix)

  0以上1より小さい一様分布のランダムな成分を持つ`matrix`と同じ大きさの実行列を生成します。

  パラメータ:
    `matrix` - 行列
  戻り値:
    ランダムな成分をもつ実行列

### uniformRandom

    public static DoubleMatrix uniformRandom(int size)

  0以上1より小さい一様分布のランダムな成分を持つ`size`*`size`の実行列を生成します。

  パラメータ:
    `size` - 次数
  戻り値:
    ランダムな成分をもつ実行列

### uniformRandom

    public static DoubleMatrix uniformRandom(int rowSize,
                                             int columnSize)

  0以上1より小さい一様分布のランダムな成分を持つ`rowSize`*`columnSize` の実行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    ランダムな成分をもつ実行列

### uniformRandom

    public static DoubleMatrix uniformRandom(int rowSize,
                                             int columnSize,
                                             long seed)

  一様乱数の種をseedで指定し, その種によって生成される、0以上1未満の一様分布の 乱数成分をもつ`rowSize`*`columnSize`の 実行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 一様乱数の種
  戻り値:
    ランダムな成分をもつ実行列

### normalRandom

    public static DoubleMatrix normalRandom(int size)

  0以上1より小さい正規分布のランダムな成分をもつ`size`*`size`の実行列を生成します。

  パラメータ:
    `size` - 次数
  戻り値:
    ランダムな成分をもつ実行列

### normalRandom

    public static DoubleMatrix normalRandom(int rowSize,
                                            int columnSize)

  0以上1より小さい正規分布のランダムな成分をもつ`rowSize`*`columnSize` の実行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    ランダムな成分をもつ実行列

### normalRandom

    public static DoubleMatrix normalRandom(Grid matrix)

  0以上1より小さい正規分布のランダムな成分をもつ`matrix`と同じ大きさの実行列を生成します。

  パラメータ:
    `matrix` - 行列
  戻り値:
    ランダムな成分をもつ実行列

### normalRandom

    public static DoubleMatrix normalRandom(int rowSize,
                                            int columnSize,
                                            long seed)

  正規乱数の種を`seed`で指定し, その種によって生成される、0以上1未満の正規分布の乱数成分を もつ`rowSize`*`columnSize`の実行列を得る。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 正規乱数の種
  戻り値:
    ランダムな成分をもつ実行列

### series

    public static DoubleMatrix series(double from,
                                      double to)

  `from`から`to`までの連続する実数を成分に持つ行ベクトルを生成します。

  パラメータ:
    `from` - 始点
    `to` - 終点
  戻り値:
    連続する実数を成分とする行ベクトル

### series

    public static DoubleMatrix series(double from,
                                      double to,
                                      double by)

  `from`から`to`までの`by`飛びの実数を成分に持つ行ベクトルを生成します。

  パラメータ:
    `from` - 始点
    `to` - 終点
    `by` - 間隔
  戻り値:
    fromからtoまでのby飛びの実数をもつ行ベクトル

### diagonal

    public static DoubleMatrix diagonal(double[] diagonalElements)

  対角行列を生成します。

  パラメータ:
    `diagonalElements` - 対角成分
  戻り値:
    対角行列

### printElements

    public void printElements(Writer output)

  インタフェース `Grid` の記述:
  ライターに成分を出力します。

  定義:
    インタフェース `Grid` 内の `printElements`
  パラメータ:
    `output` - ライター
  関連項目:
    `Grid.printElements(java.io.Writer)`

### printElements

    public void printElements(Writer output,
                              int maxColumnSize)

  インタフェース `Grid` の記述:
  ライターに成分を出力します。

  定義:
    インタフェース `Grid` 内の `printElements`
  パラメータ:
    `output` - ライター
    `maxColumnSize` - 1行の出力する列の最大数
  関連項目:
    `Grid.printElements(java.io.Writer, int)`

### getGridClassName

    protected String getGridClassName()

  クラス `AbstractGrid` の記述:
  出力するクラスの名前を返します。

  オーバーライド:
    クラス `AbstractGrid<DoubleMatrix>` 内の `getGridClassName`
  戻り値:
    出力するクラスの名前
  関連項目:
    `AbstractGrid.getGridClassName()`

### exchangeRow

    public void exchangeRow(int row1,
                            int row2)

  インタフェース `Grid` の記述:
  `row1`行と`row2`行を入れ替えます。

  定義:
    インタフェース `Grid` 内の `exchangeRow`
  パラメータ:
    `row1` - 行番号1
    `row2` - 行番号1
  関連項目:
    `Grid.exchangeRow(int, int)`

### exchangeColumn

    public void exchangeColumn(int column1,
                               int column2)

  インタフェース `Grid` の記述:
  `column1`列と`column2`列を入れ替えます。

  定義:
    インタフェース `Grid` 内の `exchangeColumn`
  パラメータ:
    `column1` - 列番号1
    `column2` - 列番号2
  関連項目:
    `Grid.exchangeColumn(int, int)`

### copy

    public void copy(Matrix source)

  インタフェース `FundamentalMatrix` の記述:
  `source`の成分をコピーします。

  定義:
    インタフェース `FundamentalMatrix` 内の `copy`
  パラメータ:
    `source` - コピー元の行列
  関連項目:
    `FundamentalMatrix.copy(org.mklab.nfc.matrix.Matrix)`

### copy

    public void copy(DoubleMatrix source)

  実数行列`source`の各成分をコピーします。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `copy`
  パラメータ:
    `source` - コピー元の実数行列

### copy

    public void copy(IntMatrix source)

  整数行列`source`の各成分をコピーします。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `copy`
  パラメータ:
    `source` - コピー元の整数行列

### diagonalToVector

    public DoubleMatrix diagonalToVector()

  インタフェース `FundamentalMatrix` の記述:
  対角成分をからなる列ベクトルを生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `diagonalToVector`
  戻り値:
    対角成分からなる列ベクトル
  関連項目:
    `FundamentalMatrix.diagonalToVector()`

### vectorToDiagonal

    public DoubleMatrix vectorToDiagonal()

  インタフェース `FundamentalMatrix` の記述:
  列ベクトルまたは行ベクトルの各成分を対角成分に持つ行列を生成します。

  定義:
    インタフェース `FundamentalMatrix` 内の `vectorToDiagonal`
  戻り値:
    対角成分からなる縦ベクトル
  関連項目:
    `FundamentalMatrix.vectorToDiagonal()`

### reshape

    public DoubleMatrix reshape(int newRowSize,
                                int newColumnSize)

  インタフェース `FundamentalMatrix` の記述:
  サイズを`newRowSize`*`newColumnSize`に変更した行列を生成します。

  成分は、行方向の成分順に並べ替えられます。 `newRowSize` * `newColumnSize`個の成分を持っていないと、エラーになる。

  定義:
    インタフェース `FundamentalMatrix` 内の `reshape`
  パラメータ:
    `newRowSize` - 行の数
    `newColumnSize` - 列の数
  戻り値:
    サイズ変更された行列
  関連項目:
    `FundamentalMatrix.reshape(int, int)`

### isZero

    public boolean isZero(double tolerance)

  インタフェース `Matrix` の記述:
  零行列であるか判定します。

  定義:
    インタフェース `Matrix` 内の `isZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零行列ならばtrue、そうでなければfalse
  関連項目:
    `Matrix.isZero(double)`

### isZero

    public boolean isZero(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  零行列であるか判定します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `isZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零行列ならばtrue、そうでなければfalse
  関連項目:
    `NumericalMatrixOperator.isZero(org.mklab.nfc.scalar.NumericalScalar)`

### isUnit

    public boolean isUnit(double tolerance)

  インタフェース `Matrix` の記述:
  単位行列であるか判定します。

  定義:
    インタフェース `Matrix` 内の `isUnit`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    単位行列ならばtrue、そうでなければfalse
  関連項目:
    `Matrix.isUnit(double)`

### isUnit

    public boolean isUnit(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  単位行列であるか判定します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `isUnit`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    単位行列ならばtrue、そうでなければfalse
  関連項目:
    `NumericalMatrixOperator.isUnit(org.mklab.nfc.scalar.NumericalScalar)`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            int value)

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `compareElementWise`
  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `value` - 比較対象
  戻り値:
    各成分に比較結果が入ったBooleanMatrix
  関連項目:
    `MatrixElementWiseOperator.compareElementWise(java.lang.String, int)`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            double value)

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `compareElementWise`
  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `value` - 比較対象
  戻り値:
    各成分に比較結果が入ったBooleanMatrix
  関連項目:
    `MatrixElementWiseOperator.compareElementWise(java.lang.String, double)`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            Scalar<?> value)

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分と`value`を`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `compareElementWise`
  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `value` - 比較対象
  戻り値:
    各成分に比較結果が入ったBooleanMatrix
  関連項目:
    `MatrixElementWiseOperator.compareElementWise(java.lang.String, org.mklab.nfc.scalar.Scalar)`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            DoubleMatrix opponent)

  `opponent`と成分毎に`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。

  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==",".!=")
    `opponent` - 比較対象
  戻り値:
    各成分に比較結果が入った`BooleanMatrix`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            IntMatrix opponent)

  `opponent`と成分毎に`operator`で指定された演算子で比較し, `BooleanMatrix`で返します。

  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==",".!=")
    `opponent` - 比較対象
  戻り値:
    各成分に比較結果が入った`BooleanMatrix`

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            Matrix opponent)

  インタフェース `FundamentalMatrix` の記述:
  `opponent`と成分毎に`operator`で指定された演算子で比較した結果を `BooleanMatrix`で返します。

  定義:
    インタフェース `FundamentalMatrix` 内の `compareElementWise`
  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    各成分に比較結果が入った`BooleanMatrix`
  関連項目:
    `FundamentalMatrix.compareElementWise(java.lang.String, org.mklab.nfc.matrix.Matrix)`

### multiplyElementWise

    public DoubleMatrix multiplyElementWise(DoubleMatrix value)

  自身と`value`の成分毎の積を成分とする行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    掛け算の結果

### divideElementWise

    public DoubleMatrix divideElementWise(DoubleMatrix value)

  自身と`value`の成分毎の商を成分とする行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    割り算の結果

### leftDivideElementWise

    public DoubleMatrix leftDivideElementWise(DoubleMatrix value)

  自身と`value`の成分毎の左からの商を成分とする行列を生成します。

  パラメータ:
    `value` - 実数行列
  戻り値:
    割り算の結果

### resize

    public DoubleMatrix resize(int newRowSize,
                               int newColumnSize)

  インタフェース `FundamentalMatrix` の記述:
  `newRowSize`*`newColumnSize`にサイズ変更します。

  `FundamentalMatrix.reshape(int, int)`とは異なり、成分位置の変更はせず, 自身より大きなサイズに変更する時は、0で埋められ、 自身より小さなサイズに変更する時は余分な成分は切り取られます。

  定義:
    インタフェース `FundamentalMatrix` 内の `resize`
  パラメータ:
    `newRowSize` - 指定行の数
    `newColumnSize` - 指定列の数
  戻り値:
    サイズ変更後の行列
  関連項目:
    `FundamentalMatrix.resize(int, int)`

### powerElementWise

    public DoubleMatrix powerElementWise(int order)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に累乗します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `powerElementWise`
  パラメータ:
    `order` - 累乗の指数
  戻り値:
    累乗の結果
  関連項目:
    `MatrixElementWiseOperator.powerElementWise(int)`

### powerElementWise

    public DoubleMatrix powerElementWise(IntMatrix value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に累乗します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `powerElementWise`
  パラメータ:
    `value` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果
  関連項目:
    `MatrixElementWiseOperator.powerElementWise(org.mklab.nfc.matrix.IntMatrix)`

### powerElementWise

    public static DoubleMatrix powerElementWise(int scalar,
                                                Matrix matrix)

  整数の累乗(行列成分毎)を成分とする行列を生成します。

  パラメータ:
    `scalar` - 累乗の対象
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### powerElementWise

    public static DoubleMatrix powerElementWise(double scalar,
                                                Matrix matrix)

  実数の累乗(行列成分毎)を成分とする行列を生成します。

  パラメータ:
    `scalar` - 実数
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### powerElementWise

    public static DoubleMatrix powerElementWise(int scalar,
                                                DoubleMatrix matrix)

  整数の累乗(行列成分毎)を成分とする行列を生成します。

  パラメータ:
    `scalar` - 累乗の対象
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### powerElementWise

    public static DoubleMatrix powerElementWise(double scalar,
                                                DoubleMatrix matrix)

  実数の累乗(行列成分毎)を成分とする行列を生成します。

  パラメータ:
    `scalar` - 実数
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### powerElementWise

    public static DoubleMatrix powerElementWise(double scalar,
                                                IntMatrix matrix)

  1個の実数について、行列の各成分の累乗を成分とする行列を生成します。

  パラメータ:
    `scalar` - 累乗の対象
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### cumulativeSum

    public DoubleMatrix cumulativeSum()

  インタフェース `Matrix` の記述:
  各要の累積和からなる行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeSum`
  戻り値:
    累積和行列
  関連項目:
    `Matrix.cumulativeSum()`

### cumulativeProduct

    public DoubleMatrix cumulativeProduct()

  インタフェース `Matrix` の記述:
  各要の累積積からなる行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeProduct`
  戻り値:
    累積積行列
  関連項目:
    `Matrix.cumulativeProduct()`

### cumulativeSumRowWise

    public DoubleMatrix cumulativeSumRowWise()

  インタフェース `Matrix` の記述:
  行毎の累積和行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeSumRowWise`
  戻り値:
    行毎の累積和行列
  関連項目:
    `Matrix.cumulativeSumRowWise()`

### cumulativeSumColumnWise

    public DoubleMatrix cumulativeSumColumnWise()

  インタフェース `Matrix` の記述:
  列毎の累積和行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeSumColumnWise`
  戻り値:
    列毎の累積和行列
  関連項目:
    `Matrix.cumulativeSumColumnWise()`

### cumulativeProductRowWise

    public DoubleMatrix cumulativeProductRowWise()

  インタフェース `Matrix` の記述:
  行毎の累積積行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeProductRowWise`
  戻り値:
    行毎の累積積行列
  関連項目:
    `Matrix.cumulativeProductRowWise()`

### cumulativeProductColumnWise

    public DoubleMatrix cumulativeProductColumnWise()

  インタフェース `Matrix` の記述:
  列毎の累積積行列を返します。

  定義:
    インタフェース `Matrix` 内の `cumulativeProductColumnWise`
  戻り値:
    列毎の累積積行列
  関連項目:
    `Matrix.cumulativeProductColumnWise()`

### meanColumnWise

    public DoubleMatrix meanColumnWise()

  インタフェース `Matrix` の記述:
  各成分列毎の平均値行ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `meanColumnWise`
  戻り値:
    列毎行平均値ベクトル
  関連項目:
    `Matrix.meanColumnWise()`

### meanRowWise

    public DoubleMatrix meanRowWise()

  インタフェース `Matrix` の記述:
  各成分行毎の平均値列ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `meanRowWise`
  戻り値:
    行毎平均値ベクトル
  関連項目:
    `Matrix.meanRowWise()`

### sumColumnWise

    public DoubleMatrix sumColumnWise()

  インタフェース `Matrix` の記述:
  列毎に加えた行ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `sumColumnWise`
  戻り値:
    列毎加算行ベクトル
  関連項目:
    `Matrix.sumColumnWise()`

### sumRowWise

    public DoubleMatrix sumRowWise()

  インタフェース `Matrix` の記述:
  行毎に加えた列ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `sumRowWise`
  戻り値:
    行毎加算列ベクトル
  関連項目:
    `Matrix.sumRowWise()`

### productColumnWise

    public DoubleMatrix productColumnWise()

  インタフェース `Matrix` の記述:
  列毎に掛けた行ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `productColumnWise`
  戻り値:
    列毎積行ベクトル
  関連項目:
    `Matrix.productColumnWise()`

### productRowWise

    public DoubleMatrix productRowWise()

  インタフェース `Matrix` の記述:
  行毎に掛けた列ベクトルを返します。

  定義:
    インタフェース `Matrix` 内の `productRowWise`
  戻り値:
    行毎積列ベクトル
  関連項目:
    `Matrix.productRowWise()`

### addElementWise

    public DoubleMatrix addElementWise(int value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に整数を加えます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `addElementWise`
  パラメータ:
    `value` - 加える整数
  戻り値:
    加算の結果
  関連項目:
    `MatrixElementWiseOperator.addElementWise(int)`

### addElementWise

    public DoubleMatrix addElementWise(double value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に実数を加えます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `addElementWise`
  パラメータ:
    `value` - 加える実数
  戻り値:
    加算の結果
  関連項目:
    `MatrixElementWiseOperator.addElementWise(double)`

### addElementWise

    public Matrix addElementWise(Scalar<?> value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎にスカラーを加えます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `addElementWise`
  パラメータ:
    `value` - 加えるスカラー
  戻り値:
    加算の結果
  関連項目:
    `MatrixElementWiseOperator.addElementWise(org.mklab.nfc.scalar.Scalar)`

### subtractElementWise

    public DoubleMatrix subtractElementWise(int value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に実数を引きます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `subtractElementWise`
  パラメータ:
    `value` - 引く実数
  戻り値:
    減算の結果
  関連項目:
    `MatrixElementWiseOperator.subtractElementWise(int)`

### subtractElementWise

    public DoubleMatrix subtractElementWise(double value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に実数を引きます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `subtractElementWise`
  パラメータ:
    `value` - 引く実数
  戻り値:
    減算の結果
  関連項目:
    `MatrixElementWiseOperator.subtractElementWise(double)`

### subtractElementWise

    public Matrix subtractElementWise(Scalar<?> value)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎にスカラーを引きます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `subtractElementWise`
  パラメータ:
    `value` - 引くスカラー
  戻り値:
    減算の結果
  関連項目:
    `MatrixElementWiseOperator.subtractElementWise(org.mklab.nfc.scalar.Scalar)`

### max

    public DoubleNumber max()

  インタフェース `NumericalMatrixOperator` の記述:
  最大成分を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `max`
  戻り値:
    最大成分
  関連項目:
    `NumericalMatrixOperator.max()`

### min

    public DoubleNumber min()

  インタフェース `NumericalMatrixOperator` の記述:
  最小成分を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `min`
  戻り値:
    最小成分
  関連項目:
    `NumericalMatrixOperator.min()`

### sum

    public DoubleNumber sum()

  インタフェース `MatrixElementOperator` の記述:
  全ての成分の合計を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `sum`
  戻り値:
    全ての成分の合計
  関連項目:
    `MatrixElementOperator.sum()`

### product

    public DoubleNumber product()

  インタフェース `MatrixElementOperator` の記述:
  全ての成分積を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `product`
  戻り値:
    全ての成分積
  関連項目:
    `MatrixElementOperator.product()`

### mean

    public DoubleNumber mean()

  インタフェース `MatrixElementOperator` の記述:
  全ての成分の平均値を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `mean`
  戻り値:
    全ての成分の平均値
  関連項目:
    `MatrixElementOperator.mean()`

### median

    public DoubleNumber median()

  インタフェース `NumericalMatrixOperator` の記述:
  全ての成分の中間値を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `median`
  戻り値:
    全ての成分の中間値
  関連項目:
    `NumericalMatrixOperator.median()`

### variance

    public DoubleNumber variance()

  インタフェース `MatrixElementOperator` の記述:
  全ての成分の分散を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `variance`
  戻り値:
    分散
  関連項目:
    `MatrixElementOperator.variance()`

### covariance

    public DoubleMatrix covariance(DoubleMatrix opponent)

  yとの共分散行列を返します。

  パラメータ:
    `opponent` - 対となるベクトル
  戻り値:
    共分散行列 (Covariance)

### std

    public DoubleNumber std()

  インタフェース `NumericalMatrixOperator` の記述:
  標準偏差を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `std`
  戻り値:
    標準偏差
  関連項目:
    `NumericalMatrixOperator.std()`

### trace

    public DoubleNumber trace()

  インタフェース `MatrixElementOperator` の記述:
  全対角成分の和を返します。

  定義:
    インタフェース `MatrixElementOperator<DoubleNumber>` 内の `trace`
  戻り値:
    対角成分の合計
  関連項目:
    `MatrixElementOperator.trace()`

### isFiniteElementWise

    public BooleanMatrix isFiniteElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分の有限性の真偽を成分にもつ行列を返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `isFiniteElementWise`
  戻り値:
    有限性のboolean行列
  関連項目:
    `MatrixElementWiseOperator.isFiniteElementWise()`

### isInfiniteElementWise

    public BooleanMatrix isInfiniteElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分の無限性の真偽を成分にもつ行列を返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `isInfiniteElementWise`
  戻り値:
    無限性のboolean行列
  関連項目:
    `MatrixElementWiseOperator.isInfiniteElementWise()`

### isNanElementWise

    public BooleanMatrix isNanElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  各成分の非数性の真偽を成分にもつ行列を返します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `isNanElementWise`
  戻り値:
    非数性のboolean行列
  関連項目:
    `MatrixElementWiseOperator.isNanElementWise()`

### floorElementWise

    public DoubleMatrix floorElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  小さい整数に丸めます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `floorElementWise`
  戻り値:
    丸められた結果
  関連項目:
    `MatrixElementWiseOperator.floorElementWise()`

### ceilElementWise

    public DoubleMatrix ceilElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  大きい整数に丸めます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `ceilElementWise`
  戻り値:
    丸められた結果
  関連項目:
    `MatrixElementWiseOperator.ceilElementWise()`

### fixElementWise

    public DoubleMatrix fixElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  ゼロ方向の整数に丸めます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `fixElementWise`
  戻り値:
    丸められた結果
  関連項目:
    `MatrixElementWiseOperator.fixElementWise()`

### roundElementWise

    public DoubleMatrix roundElementWise()

  インタフェース `MatrixElementWiseOperator` の記述:
  最も近い整数に丸めます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `roundElementWise`
  戻り値:
    丸められた結果
  関連項目:
    `MatrixElementWiseOperator.roundElementWise()`

### roundToZeroElementWise

    public DoubleMatrix roundToZeroElementWise(double tolerance)

  インタフェース `MatrixElementWiseOperator` の記述:
  絶対値が小さい成分を0に丸めます。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `roundToZeroElementWise`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸められた結果
  関連項目:
    `MatrixElementWiseOperator.roundToZeroElementWise(double)`

### roundToZeroElementWise

    public DoubleMatrix roundToZeroElementWise(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  絶対値が小さい成分を0に丸めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `roundToZeroElementWise`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸められた結果
  関連項目:
    `NumericalMatrixOperator.roundToZeroElementWise(org.mklab.nfc.scalar.NumericalScalar)`

### sqrtElementWise

    public DoubleMatrix sqrtElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の平方根の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sqrtElementWise`
  戻り値:
    成分毎平方根行列
  関連項目:
    `NumericalMatrixOperator.sqrtElementWise()`

### remainderElementWise

    public DoubleMatrix remainderElementWise(double value)

  各成分の剰余関数の結果を成分とする行列を生成します。

  パラメータ:
    `value` - 割る数
  戻り値:
    成分剰余関数行列

### remainderElementWise

    public DoubleMatrix remainderElementWise(DoubleMatrix matrix)

  各成分の剰余関数の結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 割る数を成分とする行列
  戻り値:
    成分剰余関数行列

### modulusElementWise

    public DoubleMatrix modulusElementWise(double value)

  各成分の符合付剰余関数の結果を成分とする行列を生成します。

  パラメータ:
    `value` - 割る数
  戻り値:
    成分符号付剰余関数行列

### modulusElementWise

    public DoubleMatrix modulusElementWise(DoubleMatrix matrix)

  各成分の符号付剰余関数の結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 割る数を成分とする行列
  戻り値:
    成分符号付剰余関数行列

### atan2ElementWise

    public DoubleMatrix atan2ElementWise(DoubleMatrix matrix)

  各成分の正接(2)関数の結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 分母側の数を成分とする行列
  戻り値:
    成分毎正接(2)関数行列

### atan2ElementWise

    public NumericalMatrixOperator<?> atan2ElementWise(NumericalScalar<?> value)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の逆正接(2)関数の結果を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `atan2ElementWise`
  パラメータ:
    `value` - 分母側の数
  戻り値:
    成分毎逆正接(2)関数行列
  関連項目:
    `NumericalMatrixOperator.atan2ElementWise(org.mklab.nfc.scalar.NumericalScalar)`

### remainderElementWise

    public DoubleMatrix remainderElementWise(NumericalScalar<?> value)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の剰余を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `remainderElementWise`
  パラメータ:
    `value` - 割る数
  戻り値:
    各成分の剰余を成分とする行列
  関連項目:
    `NumericalMatrixOperator.remainderElementWise(org.mklab.nfc.scalar.NumericalScalar)`

### modulusElementWise

    public DoubleMatrix modulusElementWise(NumericalScalar<?> value)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の符合付剰余を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `modulusElementWise`
  パラメータ:
    `value` - 割る数
  戻り値:
    各成分の符合付剰余を成分とする行列
  関連項目:
    `NumericalMatrixOperator.modulusElementWise(org.mklab.nfc.scalar.NumericalScalar)`

### atan2ElementWise

    public NumericalMatrixOperator<?> atan2ElementWise(Matrix order)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の逆正接(2)関数の結果を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `atan2ElementWise`
  パラメータ:
    `order` - 分母側の数を成分とする行列
  戻り値:
    成分毎逆正接(2)関数行列
  関連項目:
    `NumericalMatrixOperator.atan2ElementWise(org.mklab.nfc.matrix.Matrix)`

### remainderElementWise

    public DoubleMatrix remainderElementWise(Matrix order)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の剰余を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `remainderElementWise`
  パラメータ:
    `order` - 割る数を成分とする行列
  戻り値:
    各成分の剰余を成分とする行列
  関連項目:
    `NumericalMatrixOperator.remainderElementWise(org.mklab.nfc.matrix.Matrix)`

### modulusElementWise

    public DoubleMatrix modulusElementWise(Matrix order)

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の符合付剰余を成分とする行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `modulusElementWise`
  パラメータ:
    `order` - 割る数を成分とする行列
  戻り値:
    各成分の符合付剰余を成分とする行列
  関連項目:
    `NumericalMatrixOperator.modulusElementWise(org.mklab.nfc.matrix.Matrix)`

### eigenValue

    public DoubleComplexMatrix eigenValue()

  インタフェース `NumericalMatrixOperator` の記述:
  固有値を成分とする列ベクトルを返します。

  固有値は、実部の降順に並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenValue`
  戻り値:
    固有値を成分とする列ベクトル(実部について降順)
  関連項目:
    `NumericalMatrixOperator.eigenValue()`

### eigenVector

    public DoubleComplexMatrix eigenVector()

  インタフェース `NumericalMatrixOperator` の記述:
  (右)固有ベクトルを列とする行列を返します。

  固有ベクトルはノルムが1.0となるよう正規化されます。 固有ベクトルは、固有値の実部の降順に並べられます。固有ベクトルは、固有値に対応して並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenVector`
  戻り値:
    固有ベクトル
  関連項目:
    `NumericalMatrixOperator.eigenVector()`

### eigenDecompose

    public EigenSolution<DoubleComplexMatrix> eigenDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  固有値を対角成分とする対角行列D、固有値に対応する固有ベクトルを横方向に並べた行列Xを返します。

  これらの行列の間には、

  > A * X = X * D

  の関係が成り立ちます。固有ベクトルはノルムが1.0となるよう正規化されます。 固有値は実部の降順に並べられます。固有ベクトルは、固有値に対応して並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenDecompose`
  戻り値:
    第1成分D、第2成分Xとする`Matrix`の配列
  関連項目:
    `NumericalMatrixOperator.eigenDecompose()`

### eigenValue

    public DoubleComplexMatrix eigenValue(NumericalMatrixOperator b)

  インタフェース `NumericalMatrixOperator` の記述:
  一般化固有値からなる列ベクトルを返します。

  固有値は、実部の降順に並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenValue`
  パラメータ:
    `b` - 一般化固有値を求める対となる行列
  戻り値:
    固有値を降順に並べた列ベクトル
  関連項目:
    `NumericalMatrixOperator.eigenValue(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### eigenValueReal

    public DoubleComplexMatrix eigenValueReal(DoubleMatrix b)

  一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を成分とする配列を返します。

  パラメータ:
    `b` - 一般化固有分解を求める対となる行列
  戻り値:
    第1成分D,第2成分Xとする `Matrix`の配列
  関連項目:
    `NumericalMatrixOperator.eigenValue(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### eigenVector

    public NumericalMatrix<DoubleComplexNumber> eigenVector(NumericalMatrixOperator b)

  インタフェース `NumericalMatrixOperator` の記述:
  一般化固有ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenVector`
  パラメータ:
    `b` - 一般化固有ベクトルを求める対となる行列
  戻り値:
    一般化固有ベクトル
  関連項目:
    `NumericalMatrixOperator.eigenVector(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### eigenVector

    public DoubleComplexMatrix eigenVector(DoubleMatrix b)

  一般化固有ベクトルを返します。

  パラメータ:
    `b` - 一般化固有ベクトルを求める対となる行列
  戻り値:
    一般化固有ベクトル
  関連項目:
    `NumericalMatrixOperator.eigenVector(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### eigenDecompose

    public EigenSolution<NumericalMatrix<?>> eigenDecompose(NumericalMatrixOperator<?> b)

  インタフェース `NumericalMatrixOperator` の記述:
  一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を返します。

  これらの行列の間には、

  > A * X = X * D

  の関係が成り立ちます。固有ベクトルはノルムが1.0となるよう正規化されます。 固有値は、実部の降順に並べられます。固有ベクトルは、固有値に対応して並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `eigenDecompose`
  パラメータ:
    `b` - 一般化固有分解を求める対となる行列
  戻り値:
    第1成分D,第2成分Xとする `Matrix`の配列
  関連項目:
    `NumericalMatrixOperator.eigenDecompose(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### eigenDecompose

    public EigenSolution<NumericalMatrix<?>> eigenDecompose(DoubleMatrix b)

  一般化固有値を対角成分とする対角行列 D と対応する一般化固有ベクトルを列とする行列 X を成分とする配列を返します。

  パラメータ:
    `b` - 一般化固有分解を求める対となる行列
  戻り値:
    第1成分D,第2成分Xとする `Matrix`の配列
  関連項目:
    `NumericalMatrixOperator.eigenDecompose(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### qrDecompose

    public QRDecomposition<DoubleMatrix> qrDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  QR分解を返します。

  行列Aを直交行列(ユニタリー行列)Qと上三角行列Rの積に分解します。これらの行列の間には、

  > A = Q * R

  > Q# * Q = I

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `qrDecompose`
  戻り値:
    QR分解
  関連項目:
    `NumericalMatrixOperator.qrDecompose()`

### qrDecomposeWithPermutation

    @Deprecated
    public QRDecomposition<DoubleMatrix> qrDecomposeWithPermutation()

  推奨されていません。

  インタフェース `NumericalMatrixOperator` の記述:
  並べ替え付きQR分解を返します。

  行列Aを置換行列 P、直交行列(ユニタリー行列)Q、上三角行列Rの積に分解します。これらの行列の間には、

  > A * P = Q * R

  > Q# * Q = I

  の関係が成り立ちます。上三角行列 R の対角成分は、減少する順に並べられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `qrDecomposeWithPermutation`
  戻り値:
    並べ替え付きQR分解
  関連項目:
    `NumericalMatrixOperator.qrDecomposeWithPermutation()`

### qzDecompose

    public QZDecomposition<NumericalMatrixOperator<?>> qzDecompose(NumericalMatrixOperator<?> b)

  インタフェース `NumericalMatrixOperator` の記述:
  QZ分解を返します。

  行列Aと行列Bを上三角行列 AA, BB、左変換のための 行列 Q、右変換のための行列Zの積に分解します。 これらの行列の間には、

  > A = Q * AA * Z#

  > B = Q * BB * Z#

  > Q# * Q = I

  > Z# * Z = I

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `qzDecompose`
  パラメータ:
    `b` - QZ分解をする対となる行列
  戻り値:
    QZ分解
  関連項目:
    `NumericalMatrixOperator.qzDecompose(org.mklab.nfc.matrix.NumericalMatrixOperator)`

### qzDecompose

    public QZDecomposition<NumericalMatrixOperator<?>> qzDecompose(DoubleMatrix b)

  QZ分解を返します。

  パラメータ:
    `b` - 対象行列
  戻り値:
    QZ分解

### schurDecompose

    public SchurDecomposition<DoubleMatrix> schurDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  Schur分解を返します。

  行列をAを直交行列(ユニタリ行列)U、Schur行列 Tの積に分解します。 Schur行列Tは対角成分に行列の実固有値を持っています。 これらの行列の間には、

  > A = U * T * U#

  > U# * U = I

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `schurDecompose`
  戻り値:
    Schur分解
  関連項目:
    `NumericalMatrixOperator.schurDecompose()`

### choleskyDecompose

    public DoubleMatrix choleskyDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  対称行列のコレスキー分解を返します。

  もし、`X`が正定なら、

  > R'*R = X

  を満たす、上三角行列`R`を求めます。 このメソッドは`X`の対角と上三角部分のみを利用します。 下三角部分は、上三角部分の転置であると仮定されます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `choleskyDecompose`
  戻り値:
    コレスキー分解
  関連項目:
    `NumericalMatrixOperator.choleskyDecompose()`

### balancedDecompose

    public BalancedDecomposition<DoubleMatrix> balancedDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  非対称行列のバランス化分解を返します。

  対角成分が 2 のべき乗である対角行列 D と、 次式のバランス化された行列 B を求め、 `Matrix`の配列として返します。

  > B = D -1 * A * D

  > A = D * B * D -1

  行列B は、行列 A より対称行列に近く、各行のノルムが対応する 列のノルムに近いです。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `balancedDecompose`
  戻り値:
    バランス化分解
  関連項目:
    `NumericalMatrixOperator.balancedDecompose()`

### kernel

    public DoubleMatrix kernel()

  インタフェース `NumericalMatrixOperator` の記述:
  カーネル(零空間)を張るベクトルからなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `kernel`
  戻り値:
    カーネル
  関連項目:
    `NumericalMatrixOperator.kernel()`

### kernel

    public DoubleMatrix kernel(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  カーネル(零空間)を張るベクトルからなる行列を返します。

  `tolerance`より小さい特異値をゼロと見なします。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `kernel`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    カーネル
  関連項目:
    `NumericalMatrixOperator.kernel(double)`

### kernel

    public DoubleMatrix kernel(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  カーネル(零空間)を張るベクトルからなる行列を返します。

  `tolerance`より小さい特異値をゼロと見なします。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `kernel`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    カーネル
  関連項目:
    `NumericalMatrixOperator.kernel(org.mklab.nfc.scalar.NumericalScalar)`

### hessenbergDecompose

    public HessenbergDecomposition<DoubleMatrix> hessenbergDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  ヘッセンベルク分解を返します。

  行列Aを直交行列(ユニタリ行列)Q、 ヘッセンベルグ行列 H の積に分解します。 これらの行列の間には、

  > A = Q * H * Q#

  > Q# * Q = I

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `hessenbergDecompose`
  戻り値:
    ヘッセンベルク分解
  関連項目:
    `NumericalMatrixOperator.hessenbergDecompose()`

### luDecompose

    public LUDecomposition<DoubleMatrix> luDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  LU分解を返します。

  行列Aを下三角行を行置換した行列 L、上三角行列 U の積に分解します。 これらの行列の間には、

  > A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecompose`
  戻り値:
    LU分解
  関連項目:
    `NumericalMatrixOperator.luDecompose()`

### luDecomposeWithPermutation

    public LUDecomposition<DoubleMatrix> luDecomposeWithPermutation()

  インタフェース `NumericalMatrixOperator` の記述:
  並べ替え付きLU分解を返します。

  行列 Aを置換行列 P、下三角行列 L、上三角行列 Uの積に分解します。 これらの行列の間には、

  > P * A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecomposeWithPermutation`
  戻り値:
    並べ替え付きLU分解
  関連項目:
    `NumericalMatrixOperator.luDecomposeWithPermutation()`

### luDecompose

    public LUDecomposition<DoubleMatrix> luDecompose(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  LU分解を返します。

  行列Aを下三角行を行置換した行列 L、上三角行列 U の積に分解します。 これらの行列の間には、

  > A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecompose`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    LU分解
  関連項目:
    `NumericalMatrixOperator.luDecompose(double)`

### luDecompose

    public LUDecomposition<DoubleMatrix> luDecompose(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  LU分解を返します。

  行列Aを下三角行を行置換した行列 L、上三角行列 U の積に分解します。 これらの行列の間には、

  > A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecompose`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    LU分解
  関連項目:
    `NumericalMatrixOperator.luDecompose(org.mklab.nfc.scalar.NumericalScalar)`

### luDecomposeWithPermutation

    public LUDecomposition<DoubleMatrix> luDecomposeWithPermutation(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  並べ替え付きLU分解を返します。

  行列 Aを置換行列 P、下三角行列 L、上三角行列 Uの積に分解します。 これらの行列の間には、

  > P * A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecomposeWithPermutation`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    並べ替え付きLU分解
  関連項目:
    `NumericalMatrixOperator.luDecomposeWithPermutation(double)`

### luDecomposeWithPermutation

    public LUDecomposition<DoubleMatrix> luDecomposeWithPermutation(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  並べ替え付きLU分解を返します。

  行列 Aを置換行列 P、下三角行列 L、上三角行列 Uの積に分解します。 これらの行列の間には、

  > P * A = L * U

  の関係が成り立ちます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `luDecomposeWithPermutation`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    並べ替え付きLU分解
  関連項目:
    `NumericalMatrixOperator.luDecomposeWithPermutation(org.mklab.nfc.scalar.NumericalScalar)`

### pseudoInverse

    public DoubleMatrix pseudoInverse()

  インタフェース `NumericalMatrixOperator` の記述:
  擬似逆行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `pseudoInverse`
  戻り値:
    擬似逆行列
  関連項目:
    `NumericalMatrixOperator.pseudoInverse()`

### pseudoInverse

    public DoubleMatrix pseudoInverse(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  擬似逆行列を返します。

  `tolerance`より小さい A の特異値をゼロとみなし、行列 A のランクを決定し、 擬似逆行列を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `pseudoInverse`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    擬似逆行列
  関連項目:
    `NumericalMatrixOperator.pseudoInverse(double)`

### pseudoInverse

    public DoubleMatrix pseudoInverse(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  擬似逆行列を返します。

  `tolerance`より小さい A の特異値をゼロとみなし、行列 A のランクを決定し、 擬似逆行列を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `pseudoInverse`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    擬似逆行列
  関連項目:
    `NumericalMatrixOperator.pseudoInverse(org.mklab.nfc.scalar.NumericalScalar)`

### rank

    public int rank()

  インタフェース `NumericalMatrixOperator` の記述:
  ランク(階数)(正の特異値の数)を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `rank`
  戻り値:
    ランク
  関連項目:
    `NumericalMatrixOperator.rank()`

### rank

    public int rank(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  ランク(階数)(`tolerance`より大きい特異値の数)を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `rank`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    ランク
  関連項目:
    `NumericalMatrixOperator.rank(double)`

### rank

    public int rank(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  ランク(階数)(`tolerance`より大きい特異値の数)を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `rank`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    ランク
  関連項目:
    `NumericalMatrixOperator.rank(org.mklab.nfc.scalar.NumericalScalar)`

### isFullRank

    public boolean isFullRank()

  インタフェース `NumericalMatrixOperator` の記述:
  フルランクであるか判定します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `isFullRank`
  戻り値:
    フルランクならばtrue、そうでなければfalse
  関連項目:
    `NumericalMatrixOperator.isFullRank()`

### isFullRank

    public boolean isFullRank(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  フルランクであるか判定します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `isFullRank`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    フルランクならばtrue、そうでなければfalse
  関連項目:
    `NumericalMatrixOperator.isFullRank(double)`

### isFullRank

    public boolean isFullRank(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  フルランクであるか判定します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `isFullRank`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    フルランクならばtrue、そうでなければfalse
  関連項目:
    `NumericalMatrixOperator.isFullRank(org.mklab.nfc.scalar.NumericalScalar)`

### singularValueDecompose

    public SingularValueDecomposition<DoubleMatrix> singularValueDecompose()

  インタフェース `NumericalMatrixOperator` の記述:
  特異値分解で得られる各行列を返します。

  自身と同じ大きさで、負でない実数(特異値) を対角成分にもつ行列を Dとすると、

  > A = U * D * V#

  を満たす直交行列(ユニタリ 行列) U と V を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `singularValueDecompose`
  戻り値:
    特異値分解
  関連項目:
    `NumericalMatrixOperator.singularValueDecompose()`

### singularValue

    public DoubleMatrix singularValue()

  インタフェース `NumericalMatrixOperator` の記述:
  特異値を成分とする列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `singularValue`
  戻り値:
    特異値を成分とする列ベクトル
  関連項目:
    `NumericalMatrixOperator.singularValue()`

### maxSingularValue

    public DoubleNumber maxSingularValue()

  インタフェース `NumericalMatrixOperator` の記述:
  最大特異値を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maxSingularValue`
  戻り値:
    最大特異値
  関連項目:
    `NumericalMatrixOperator.maxSingularValue()`

### minSingularValue

    public DoubleNumber minSingularValue()

  インタフェース `NumericalMatrixOperator` の記述:
  最小特異値を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minSingularValue`
  戻り値:
    最小特異値
  関連項目:
    `NumericalMatrixOperator.minSingularValue()`

### conditionNumber

    public DoubleNumber conditionNumber()

  インタフェース `NumericalMatrixOperator` の記述:
  条件数(2-ノルム)を返します。

  行列の2-ノルムに関する条件数を求めます。条件数は、 最大特異値と最小特異値の比で与えられ、1 以上です。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `conditionNumber`
  戻り値:
    条件数
  関連項目:
    `NumericalMatrixOperator.conditionNumber()`

### fft

    public DoubleComplexMatrix fft()

  インタフェース `NumericalMatrixOperator` の記述:
  2 のべき乗の長さのベクトルについて、基底が 2 の 高速フーリエ変換を計算します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fft`
  戻り値:
    高速フーリエ変換結果
  関連項目:
    `NumericalMatrixOperator.fft()`

### fft

    public DoubleComplexMatrix fft(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  `dataSize`点まで基底が 2 の高速フーリエ変換をします。

  自身 の長さが`dataSize`より短いとき、ゼロが後ろに付け加えられ、 自身 の長さが`dataSize`より長いとき、`dataSize` 番目以降が切り捨てられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fft`
  パラメータ:
    `dataCount` - データの個数
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.fft(int)`

### fftRowWise

    public DoubleComplexMatrix fftRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎に基底が 2 の高速フーリエ変換を計算します。

  列の数は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fftRowWise`
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.fftRowWise()`

### fftRowWise

    public DoubleComplexMatrix fftRowWise(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  行毎に`dataSize`点まで,基底が 2 の高速フーリエ変換を計算します。

  `dataSize`は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fftRowWise`
  パラメータ:
    `dataCount` - データの個数
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.fftRowWise(int)`

### fftColumnWise

    public DoubleComplexMatrix fftColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎に基底が 2 の高速フーリエ変換を計算します。

  行の数は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fftColumnWise`
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.fftColumnWise()`

### fftColumnWise

    public DoubleComplexMatrix fftColumnWise(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  列毎に`dataSize`点まで、基底が 2 の高速フーリエ変換を計算します。

  `dataSize`は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `fftColumnWise`
  パラメータ:
    `dataCount` - データの個数
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.fftColumnWise(int)`

### ifft

    public DoubleComplexMatrix ifft()

  インタフェース `NumericalMatrixOperator` の記述:
  2 のべき乗の長さのベクトルについて、基底が 2 の 逆高速フーリエ変換を計算します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifft`
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifft()`

### ifft

    public DoubleComplexMatrix ifft(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  `dataSize`点まで基底が2の逆高速フーリエ変換をします。

  自身の長さが`dataSize`より短いとき、ゼロが後ろに付け加えられ、 自身 の長さが`dataSize`より長いとき、`dataSize` 番目以降が切り捨てられます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifft`
  パラメータ:
    `dataCount` - データの個数
  戻り値:
    フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifft(int)`

### ifftRowWise

    public DoubleComplexMatrix ifftRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎に基底が 2 の逆高速フーリエ変換を計算します。

  列の数は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifftRowWise`
  戻り値:
    逆フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifftRowWise()`

### ifftRowWise

    public DoubleComplexMatrix ifftRowWise(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  行毎に`dataSize`点まで,基底が 2 の逆高速フーリエ変換を計算します。

  `dataSize`は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifftRowWise`
  パラメータ:
    `dataCount` - 変換するデータの数
  戻り値:
    逆フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifftRowWise(int)`

### ifftColumnWise

    public DoubleComplexMatrix ifftColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎に基底が 2 の逆高速フーリエ変換を計算します。

  行の数は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifftColumnWise`
  戻り値:
    逆フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifftColumnWise()`

### ifftColumnWise

    public DoubleComplexMatrix ifftColumnWise(int dataCount)

  インタフェース `NumericalMatrixOperator` の記述:
  列毎に`dataSize`点まで、基底が 2 の逆高速フーリエ変換を計算します。

  `dataSize`は2のべき乗でなければならない。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `ifftColumnWise`
  パラメータ:
    `dataCount` - データの個数
  戻り値:
    逆フーリエ変換の結果
  関連項目:
    `NumericalMatrixOperator.ifftColumnWise(int)`

### log

    public DoubleComplexMatrix log()

  インタフェース `NumericalMatrixOperator` の記述:
  対数行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `log`
  戻り値:
    対数行列
  関連項目:
    `NumericalMatrixOperator.log()`

### sqrt

    public DoubleComplexMatrix sqrt()

  インタフェース `NumericalMatrixOperator` の記述:
  平方根行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sqrt`
  戻り値:
    平方根行列
  関連項目:
    `NumericalMatrixOperator.sqrt()`

### exp

    public DoubleMatrix exp()

  インタフェース `NumericalMatrixOperator` の記述:
  指数関数行列を返します。

  自身をAとするとき、このメソッドは、

  > I + A + A^2/(2!) + ... + A^n/(n!) + ...

  を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `exp`
  戻り値:
    行列指数関数
  関連項目:
    `NumericalMatrixOperator.exp()`

### exp

    public DoubleMatrix exp(double tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  指数関数行列を返します。

  自身をAとするとき、このメソッドは、

  > I + A + A^2/(2!) + ... + A^n/(n!) + ...

  を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `exp`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    行列指数関数
  関連項目:
    `NumericalMatrixOperator.exp(double)`

### exp

    public DoubleMatrix exp(NumericalScalar<?> tolerance)

  インタフェース `NumericalMatrixOperator` の記述:
  指数関数行列を返します。

  自身をAとするとき、このメソッドは、

  > I + A + A^2/(2!) + ... + A^n/(n!) + ...

  を求めます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `exp`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    行列指数関数
  関連項目:
    `NumericalMatrixOperator.exp(org.mklab.nfc.scalar.NumericalScalar)`

### sinElementWise

    public DoubleMatrix sinElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の正弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sinElementWise`
  戻り値:
    成分毎正弦関数行列
  関連項目:
    `NumericalMatrixOperator.sinElementWise()`

### sinhElementWise

    public DoubleMatrix sinhElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の双曲線正弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sinhElementWise`
  戻り値:
    成分毎双曲線正弦関数行列
  関連項目:
    `NumericalMatrixOperator.sinhElementWise()`

### asinElementWise

    public DoubleMatrix asinElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆正弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `asinElementWise`
  戻り値:
    成分毎逆正弦関数行列
  関連項目:
    `NumericalMatrixOperator.asinElementWise()`

### asinhElementWise

    public DoubleMatrix asinhElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆双曲線正弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `asinhElementWise`
  戻り値:
    成分毎逆双曲線正弦関数行列
  関連項目:
    `NumericalMatrixOperator.asinhElementWise()`

### cosElementWise

    public DoubleMatrix cosElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の余弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `cosElementWise`
  戻り値:
    成分毎余弦関数行列
  関連項目:
    `NumericalMatrixOperator.cosElementWise()`

### coshElementWise

    public DoubleMatrix coshElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の双曲線余弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `coshElementWise`
  戻り値:
    成分毎双曲線余弦関数行列
  関連項目:
    `NumericalMatrixOperator.coshElementWise()`

### acosElementWise

    public DoubleMatrix acosElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆余弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `acosElementWise`
  戻り値:
    成分毎逆余弦関数行列
  関連項目:
    `NumericalMatrixOperator.acosElementWise()`

### acoshElementWise

    public DoubleMatrix acoshElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆双曲線余弦関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `acoshElementWise`
  戻り値:
    成分毎逆双曲線余弦関数行列
  関連項目:
    `NumericalMatrixOperator.acoshElementWise()`

### tanElementWise

    public DoubleMatrix tanElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の正接関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `tanElementWise`
  戻り値:
    成分毎正接関数行列
  関連項目:
    `NumericalMatrixOperator.tanElementWise()`

### tanhElementWise

    public DoubleMatrix tanhElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の双曲線正接関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `tanhElementWise`
  戻り値:
    成分毎双曲線正接関数行列
  関連項目:
    `NumericalMatrixOperator.tanhElementWise()`

### atanElementWise

    public DoubleMatrix atanElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆正接関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `atanElementWise`
  戻り値:
    成分毎逆正接関数行列
  関連項目:
    `NumericalMatrixOperator.atanElementWise()`

### atanhElementWise

    public DoubleMatrix atanhElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の逆双曲線正接関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `atanhElementWise`
  戻り値:
    成分毎逆双曲線正接関数行列
  関連項目:
    `NumericalMatrixOperator.atanhElementWise()`

### expElementWise

    public DoubleMatrix expElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の指数関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `expElementWise`
  戻り値:
    成分毎指数関数行列
  関連項目:
    `NumericalMatrixOperator.expElementWise()`

### logElementWise

    public DoubleMatrix logElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の対数関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `logElementWise`
  戻り値:
    成分毎自然対数関数行列
  関連項目:
    `NumericalMatrixOperator.logElementWise()`

### log10ElementWise

    public DoubleMatrix log10ElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎の常用対数関数の結果からなる行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `log10ElementWise`
  戻り値:
    成分毎常用対数関数行列
  関連項目:
    `NumericalMatrixOperator.log10ElementWise()`

### argumentElementWise

    public DoubleMatrix argumentElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の偏角を成分に持つ行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `argumentElementWise`
  戻り値:
    偏角行列
  関連項目:
    `NumericalMatrixOperator.argumentElementWise()`

### signumElementWise

    public DoubleMatrix signumElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の符合(-1,0,1)を成分に持つ行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `signumElementWise`
  戻り値:
    符合行列
  関連項目:
    `NumericalMatrixOperator.signumElementWise()`

### absElementWise

    public DoubleMatrix absElementWise()

  インタフェース `NumericalMatrixOperator` の記述:
  各成分の絶対値を成分に持つ行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `absElementWise`
  戻り値:
    絶対値行列
  関連項目:
    `NumericalMatrixOperator.absElementWise()`

### stdRowWise

    public DoubleMatrix stdRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  各成分行毎の標準偏差列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `stdRowWise`
  戻り値:
    行毎標準偏差ベクトル
  関連項目:
    `NumericalMatrixOperator.stdRowWise()`

### stdColumnWise

    public DoubleMatrix stdColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  各成分列毎の標準偏差行ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `stdColumnWise`
  戻り値:
    列毎行標準偏差ベクトル
  関連項目:
    `NumericalMatrixOperator.stdColumnWise()`

### sortRowWise

    public IndexedMatrix<DoubleMatrix> sortRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎に昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。

  複素行列のときは、絶対値でソートします。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sortRowWise`
  戻り値:
    ソート結果と元の位置を示す指数
  関連項目:
    `NumericalMatrixOperator.sortRowWise()`

### sortColumnWise

    public IndexedMatrix<DoubleMatrix> sortColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎に昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。

  自身が複素行列のときは、絶対値でソートします。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sortColumnWise`
  戻り値:
    ソート結果と元の位置を示す指数
  関連項目:
    `NumericalMatrixOperator.sortColumnWise()`

### maxRowWise

    public DoubleMatrix maxRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎の最大値を成分とする列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maxRowWise`
  戻り値:
    行毎最大値ベクトル
  関連項目:
    `NumericalMatrixOperator.maxRowWise()`

### maxColumnWise

    public DoubleMatrix maxColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎の最大値を成分とする行ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maxColumnWise`
  戻り値:
    列毎行最大値ベクトル
  関連項目:
    `NumericalMatrixOperator.maxColumnWise()`

### maximum

    public ElementHolder<DoubleNumber> maximum()

  インタフェース `NumericalMatrixOperator` の記述:
  最大成分とその指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maximum`
  戻り値:
    最大成分とその指数
  関連項目:
    `NumericalMatrixOperator.maximum()`

### maximumRowWise

    public IndexedMatrix<DoubleMatrix> maximumRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎の最大成分とその指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maximumRowWise`
  戻り値:
    行毎最大成分とその指数
  関連項目:
    `NumericalMatrixOperator.maximumRowWise()`

### maximumColumnWise

    public IndexedMatrix<DoubleMatrix> maximumColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎の最大成分とその指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maximumColumnWise`
  戻り値:
    列毎最大成分とその指数
  関連項目:
    `NumericalMatrixOperator.maximumColumnWise()`

### minRowWise

    public DoubleMatrix minRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎の最小値を成分とする列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minRowWise`
  戻り値:
    行毎最小値ベクトル
  関連項目:
    `NumericalMatrixOperator.minRowWise()`

### minColumnWise

    public DoubleMatrix minColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎の最小値を成分とする行ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minColumnWise`
  戻り値:
    列毎行最小値ベクトル
  関連項目:
    `NumericalMatrixOperator.minColumnWise()`

### minimum

    public ElementHolder<DoubleNumber> minimum()

  インタフェース `NumericalMatrixOperator` の記述:
  最小成分と指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minimum`
  戻り値:
    最小成分とその指数
  関連項目:
    `NumericalMatrixOperator.minimum()`

### minimumRowWise

    public IndexedMatrix<DoubleMatrix> minimumRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎の最小成分とその指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minimumRowWise`
  戻り値:
    行毎最小成分とその指数
  関連項目:
    `NumericalMatrixOperator.minimumRowWise()`

### minimumColumnWise

    public IndexedMatrix<DoubleMatrix> minimumColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎の最小成分とその指数を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minimumColumnWise`
  戻り値:
    列毎最小成分とその指数
  関連項目:
    `NumericalMatrixOperator.minimumColumnWise()`

### maxElementWise

    public Matrix maxElementWise(Matrix opponent)

  インタフェース `NumericalMatrixOperator` の記述:
  `opponent`と成分毎に比較し、大きいほうを成分にもつ行列を返します。 複素行列のときは、絶対値で比較されます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `maxElementWise`
  パラメータ:
    `opponent` - 比較する行列
  戻り値:
    最大値を成分とする行列
  関連項目:
    `NumericalMatrixOperator.maxElementWise(org.mklab.nfc.matrix.Matrix)`

### minElementWise

    public Matrix minElementWise(Matrix opponent)

  インタフェース `NumericalMatrixOperator` の記述:
  `opponent`と成分毎に比較し、小さいほうを成分にもつ行列を返します。 複素行列のときは、絶対値で比較されます。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `minElementWise`
  パラメータ:
    `opponent` - 比較する行列
  戻り値:
    最小値を成分とする行列
  関連項目:
    `NumericalMatrixOperator.minElementWise(org.mklab.nfc.matrix.Matrix)`

### maxElementWise

    public DoubleMatrix maxElementWise(DoubleMatrix opponent)

  各成分の大きい方の値を成分とする行列を生成します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    各成分の最大値を持つ行列

### minElementWise

    public DoubleMatrix minElementWise(DoubleMatrix opponent)

  各成分の小さい方の値を成分とする行列を生成します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    各成分の最小値を持つ行列

### medianColumnWise

    public DoubleMatrix medianColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行列なら、列毎のメジアンを成分とする行ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `medianColumnWise`
  戻り値:
    中間値(メジアン) (median vector)
  関連項目:
    `NumericalMatrixOperator.medianColumnWise()`

### medianRowWise

    public DoubleMatrix medianRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行列なら、行毎のメジアンを成分とする列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `medianRowWise`
  戻り値:
    中間値(メジアン) (median vector)
  関連項目:
    `NumericalMatrixOperator.medianRowWise()`

### norm

    public DoubleNumber norm(NormType type)

  インタフェース `NumericalMatrixOperator` の記述:
  norm(`NormType.FROBENIUS`)でフロベニウスノルム、 norm( `NormType.INFINITY`)で無限大ノルム、 norm( `NormType.ONE`)で1-ノルムを、 norm(`NormType.TWO`)で最大特異値を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `norm`
  パラメータ:
    `type` - ノルムの種類を指定
  戻り値:
    指令された種類のノルム
  関連項目:
    `NumericalMatrixOperator.norm(org.mklab.nfc.matrix.NormType)`

### frobNorm

    public DoubleNumber frobNorm()

  インタフェース `NumericalMatrixOperator` の記述:
  フロベニウスノルムを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `frobNorm`
  戻り値:
    フロベニウスノルム
  関連項目:
    `NumericalMatrixOperator.frobNorm()`

### frobNormRowWise

    public DoubleMatrix frobNormRowWise()

  インタフェース `NumericalMatrixOperator` の記述:
  行毎のフロベニウスノルムを成分とする列ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `frobNormRowWise`
  戻り値:
    行毎のフロベニウスノルムを成分とする列ベクトル
  関連項目:
    `NumericalMatrixOperator.frobNormRowWise()`

### frobNormColumnWise

    public DoubleMatrix frobNormColumnWise()

  インタフェース `NumericalMatrixOperator` の記述:
  列毎のフロベニウスノルムを成分とする行ベクトルを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `frobNormColumnWise`
  戻り値:
    列毎のフロベニウスノルムを成分とする行ベクトル
  関連項目:
    `NumericalMatrixOperator.frobNormColumnWise()`

### infNorm

    public DoubleNumber infNorm()

  インタフェース `NumericalMatrixOperator` の記述:
  無限大ノルムを返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `infNorm`
  戻り値:
    無限大ノルム
  関連項目:
    `NumericalMatrixOperator.infNorm()`

### powerElementWise

    public DoubleMatrix powerElementWise(double order)

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎に累乗するした値を成分とする行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `powerElementWise`
  パラメータ:
    `order` - 累乗の指数
  戻り値:
    累乗の結果
  関連項目:
    `NumericalMatrixOperator.powerElementWise(double)`

### powerElementWise

    public NumericalMatrixOperator<?> powerElementWise(NumericalScalar<?> order)

  インタフェース `NumericalMatrixOperator` の記述:
  成分毎に累乗するした値を成分とする行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `powerElementWise`
  パラメータ:
    `order` - 累乗の指数(複素数)
  戻り値:
    累乗の結果
  関連項目:
    `NumericalMatrixOperator.powerElementWise(org.mklab.nfc.scalar.NumericalScalar)`

### powerElementWise

    public DoubleMatrix powerElementWise(DoubleMatrix value)

  各成分の累乗した値を成分とする行列を生成します。

  パラメータ:
    `value` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### powerElementWise

    public NumericalMatrix<?> powerElementWise(NumericalMatrix<?> value)

  各成分の累乗した値を成分とする行列を生成します。

  パラメータ:
    `value` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果

### sort

    public IndexedMatrix<DoubleMatrix> sort()

  インタフェース `NumericalMatrixOperator` の記述:
  全ての成分を昇順に並び替えた行列と元の位置を示す指数(`IntMatrix`)を返します。

  複素行列のときは、絶対値でソートします。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `sort`
  戻り値:
    ソートした結果元の位置を示す指数(`IntMatrix`)
  関連項目:
    `NumericalMatrixOperator.sort()`

### inverse

    public DoubleMatrix inverse()

  インタフェース `Matrix` の記述:
  逆行列(`this` -1 )を返します。

  定義:
    インタフェース `Matrix` 内の `inverse`
  戻り値:
    逆行列
  関連項目:
    `Matrix.inverse()`

### powerElementWise

    public NumericalMatrixOperator<?> powerElementWise(Matrix order)

  インタフェース `MatrixElementWiseOperator` の記述:
  成分毎に累乗します。

  定義:
    インタフェース `MatrixElementWiseOperator` 内の `powerElementWise`
  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `powerElementWise`
  オーバーライド:
    クラス `AbstractMatrix<DoubleMatrix>` 内の `powerElementWise`
  パラメータ:
    `order` - 累乗の指数を成分とする行列
  戻り値:
    累乗の結果
  関連項目:
    `MatrixElementWiseOperator.powerElementWise(org.mklab.nfc.matrix.Matrix)`

### unit

    public static DoubleMatrix unit(int size)

  `size`*`size`の単位行列を生成します。

  パラメータ:
    `size` - サイズ指定
  戻り値:
    size*sizeの単位行列

### unit

    public static DoubleMatrix unit(int rowSize,
                                    int columnSize)

  `rowSize`*`columnSize`の実単位行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    `rowSize`*`columnSize`の単位行列

### unit

    public static DoubleMatrix unit(Matrix matrix)

  行列`matrix`と同サイズの実単位行列を生成します。

  パラメータ:
    `matrix` - 行列
  戻り値:
    単位行列

### unit

    public static DoubleMatrix unit(int rowNumber,
                                    int columnNumber,
                                    Grid block)

  行列`block`の`rowNumber`*`columnNumber` 倍の実単位行列を生成します。

  パラメータ:
    `rowNumber` - 行方向の倍数
    `columnNumber` - 列方向の倍数
    `block` - 基本となる行列
  戻り値:
    `block`の`rowNumber`* `columnNumber`倍の実単位行列

### createUnit

    public DoubleMatrix createUnit(int rowSize,
                                   int columnSize)

  インタフェース `Matrix` の記述:
  `rowSize`*`columnSize`の単位行列を生成します。

  定義:
    インタフェース `Matrix` 内の `createUnit`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    `rowSize`*`columnSize`の単位行列
  関連項目:
    `Matrix.createUnit(int, int)`

### createZero

    public DoubleMatrix createZero(int rowSize,
                                   int columnSize)

  インタフェース `Matrix` の記述:
  `rowSize`*`columnSize`の零行列を生成します。

  定義:
    インタフェース `Matrix` 内の `createZero`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    `rowSize`*`columnSize`の零行列
  関連項目:
    `Matrix.createZero(int, int)`

### createOnes

    public DoubleMatrix createOnes(int rowSize,
                                   int columnSize)

  インタフェース `Matrix` の記述:
  `rowSize`*`columnSize`の全成分が1である行列を生成します。

  定義:
    インタフェース `Matrix` 内の `createOnes`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    `rowSize`*`columnSize`の全成分が1である行列
  関連項目:
    `Matrix.createOnes(int, int)`

### createUniformRandom

    public DoubleMatrix createUniformRandom()

  インタフェース `NumericalMatrixOperator` の記述:
  同サイズの0〜1の範囲の一様分布のランダムな成分を持つ行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createUniformRandom`
  戻り値:
    同サイズの0〜1の範囲の一様分布のランダムな成分を持つ行列
  関連項目:
    `NumericalMatrixOperator.createUniformRandom()`

### createUniformRandom

    public DoubleMatrix createUniformRandom(int rowNumber,
                                            int columnNumber,
                                            Grid block)

  インタフェース `NumericalMatrixOperator` の記述:
  行列`block`の`rowNumber`*`columnNumber`倍の 0〜1の範囲の一様分布のランダムな成分を持つ `rowSize`*`columnSize`の行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createUniformRandom`
  パラメータ:
    `rowNumber` - 行方向の倍数
    `columnNumber` - 列方向の倍数
    `block` - 基本となる行列
  戻り値:
    `block`の`rowNumber`* `columnNumber`倍の 0〜1の範囲の一様分布のランダムな成分を持つ`rowSize`*`columnSize`の行列
  関連項目:
    `NumericalMatrixOperator.createUniformRandom(int, int, org.mklab.nfc.matrix.Grid)`

### createUniformRandom

    public DoubleMatrix createUniformRandom(int rowSize,
                                            int columnSize)

  インタフェース `NumericalMatrixOperator` の記述:
  0〜1の範囲の一様分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します 。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createUniformRandom`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    ランダムな成分をもつ行列
  関連項目:
    `NumericalMatrixOperator.createUniformRandom(int, int)`

### createUniformRandom

    public DoubleMatrix createUniformRandom(int rowSize,
                                            int columnSize,
                                            long seed)

  インタフェース `NumericalMatrixOperator` の記述:
  0〜1の範囲の一様分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します 。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createUniformRandom`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 乱数の種
  戻り値:
    ランダムな成分をもつ行列
  関連項目:
    `NumericalMatrixOperator.createUniformRandom(int, int, long)`

### createNormalRandom

    public DoubleMatrix createNormalRandom()

  インタフェース `NumericalMatrixOperator` の記述:
  同サイズの平均0、分散1の正規分布のランダムな成分を持つ行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createNormalRandom`
  戻り値:
    同サイズの平均0、分散1の正規分布のランダムな成分を持つ行列
  関連項目:
    `NumericalMatrixOperator.createNormalRandom()`

### createNormalRandom

    public DoubleMatrix createNormalRandom(int rowNumber,
                                           int columnNumber,
                                           Grid block)

  インタフェース `NumericalMatrixOperator` の記述:
  行列`block`の`rowNumber`*`columnNumber`倍の 平均0、 分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize`の行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createNormalRandom`
  パラメータ:
    `rowNumber` - 行方向の倍数
    `columnNumber` - 列方向の倍数
    `block` - 基本となる行列
  戻り値:
    `block`の`rowNumber`* `columnNumber`倍の 平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize`の行列
  関連項目:
    `NumericalMatrixOperator.createNormalRandom(int, int, org.mklab.nfc.matrix.Grid)`

### createNormalRandom

    public DoubleMatrix createNormalRandom(int rowSize,
                                           int columnSize)

  インタフェース `NumericalMatrixOperator` の記述:
  平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize` の行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createNormalRandom`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize`の行列
  関連項目:
    `NumericalMatrixOperator.createNormalRandom(int, int)`

### createNormalRandom

    public DoubleMatrix createNormalRandom(int rowSize,
                                           int columnSize,
                                           long seed)

  インタフェース `NumericalMatrixOperator` の記述:
  平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize` の行列を生成します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createNormalRandom`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 乱数の種
  戻り値:
    平均0、分散1の正規分布のランダムな成分を持つ`rowSize`*`columnSize`の行列
  関連項目:
    `NumericalMatrixOperator.createNormalRandom(int, int, long)`

### isComplex

    public boolean isComplex()

  インタフェース `Matrix` の記述:
  複素成分をもつか判定します。

  定義:
    インタフェース `Matrix` 内の `isComplex`
  戻り値:
    複素成分をもつならばtrue、そうでなければfalse
  関連項目:
    `Matrix.isComplex()`

### isReal

    public boolean isReal()

  インタフェース `Matrix` の記述:
  実成分のみをもつか(複素成分をもたないか)判定します。

  定義:
    インタフェース `Matrix` 内の `isReal`
  戻り値:
    実成分のみをもつならばtrue、そうでなければfalse
  関連項目:
    `Matrix.isReal()`

### getImaginaryPart

    public DoubleMatrix getImaginaryPart()

  インタフェース `Matrix` の記述:
  虚部行列を返します。

  定義:
    インタフェース `Matrix` 内の `getImaginaryPart`
  戻り値:
    虚部行列
  関連項目:
    `Matrix.getImaginaryPart()`

### getRealPart

    public DoubleMatrix getRealPart()

  インタフェース `Matrix` の記述:
  実部行列を返します。

  定義:
    インタフェース `Matrix` 内の `getRealPart`
  戻り値:
    実部行列
  関連項目:
    `Matrix.getRealPart()`

### setRealPart

    public void setRealPart(Matrix realPart)

  インタフェース `Matrix` の記述:
  実部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部行列
  関連項目:
    `Matrix.setRealPart(org.mklab.nfc.matrix.Matrix)`

### setRealPart

    public void setRealPart(IntMatrix realPart)

  インタフェース `Matrix` の記述:
  実部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部行列
  関連項目:
    `Matrix.setRealPart(org.mklab.nfc.matrix.IntMatrix)`

### setRealPart

    public void setRealPart(DoubleMatrix realPart)

  インタフェース `Matrix` の記述:
  実部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部行列
  関連項目:
    `Matrix.setRealPart(org.mklab.nfc.matrix.DoubleMatrix)`

### setRealPart

    public void setRealPart(BaseMatrix<?,?> realPart)

  インタフェース `Matrix` の記述:
  実部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部行列
  関連項目:
    `Matrix.setRealPart(org.mklab.nfc.matrix.BaseMatrix)`

### setImaginaryPart

    public void setImaginaryPart(Matrix imaginaryPart)

  インタフェース `Matrix` の記述:
  虚部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setImaginaryPart`
  パラメータ:
    `imaginaryPart` - 虚部行列
  関連項目:
    `Matrix.setImaginaryPart(org.mklab.nfc.matrix.Matrix)`

### setImaginaryPart

    public void setImaginaryPart(IntMatrix imaginaryPart)

  インタフェース `Matrix` の記述:
  虚部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setImaginaryPart`
  パラメータ:
    `imaginaryPart` - 虚部行列
  関連項目:
    `Matrix.setImaginaryPart(org.mklab.nfc.matrix.IntMatrix)`

### setImaginaryPart

    public void setImaginaryPart(DoubleMatrix imaginaryPart)

  インタフェース `Matrix` の記述:
  虚部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setImaginaryPart`
  パラメータ:
    `imaginaryPart` - 虚部行列
  関連項目:
    `Matrix.setImaginaryPart(org.mklab.nfc.matrix.DoubleMatrix)`

### setImaginaryPart

    public void setImaginaryPart(BaseMatrix<?,?> imaginaryPart)

  インタフェース `Matrix` の記述:
  虚部行列を設定します。

  定義:
    インタフェース `Matrix` 内の `setImaginaryPart`
  パラメータ:
    `imaginaryPart` - 虚部行列
  関連項目:
    `Matrix.setImaginaryPart(org.mklab.nfc.matrix.BaseMatrix)`

### toComplex

    public DoubleComplexMatrix toComplex()

  インタフェース `Matrix` の記述:
  複素成分行列へ変換します。

  定義:
    インタフェース `Matrix` 内の `toComplex`
  戻り値:
    複素成分行列
  関連項目:
    `Matrix.toComplex()`

### createComplexMatrix

    public DoubleComplexMatrix createComplexMatrix(NumericalMatrixOperator<?> realPart,
                                                   NumericalMatrixOperator<?> imagPart)

  インタフェース `NumericalMatrixOperator` の記述:
  複素行列を返します。

  定義:
    インタフェース `NumericalMatrixOperator<DoubleNumber>` 内の `createComplexMatrix`
  パラメータ:
    `realPart` - 実部行列
    `imagPart` - 虚部行列
  戻り値:
    複素行列
  関連項目:
    `NumericalMatrixOperator.createComplexMatrix(org.mklab.nfc.matrix.NumericalMatrixOperator, org.mklab.nfc.matrix.NumericalMatrixOperator)`

概要 | パッケージ | クラス | 使用 | 階層ツリー | 非推奨 API | 索引 | ヘルプ
前のクラス 次のクラス | フレームあり フレームなし
概要: 入れ子 | フィールド | コンストラクタ | メソッド | 詳細: フィールド | コンストラクタ | メソッド