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

## org.mklab.nfc.matrix
クラス BaseMatrix<M extends BaseMatrix<M,E>,E extends Scalar<E>>

    java.lang.Object
      org.mklab.nfc.matrix.AbstractGrid<M>
          org.mklab.nfc.matrix.AbstractFundamentalMatrix<M>
              org.mklab.nfc.matrix.AbstractMatrix<M>
                  org.mklab.nfc.matrix.BaseMatrix<M,E>

型パラメータ:
  `M` - 行列の型
  `E` - 成分の型

すべての実装されたインタフェース:
  Serializable, Cloneable, FundamentalMatrix, Grid, Matrix, MatrixElementOperator<E>, MatrixElementWiseOperator, TransformableMatrix<BaseMatrix<?,?>>

直系の既知のサブクラス:
  NumericalMatrix, SymbolicMatrix

    public class BaseMatrix<M extends BaseMatrix<M,E>,E extends Scalar<E>>

extends AbstractMatrix<M>
implements MatrixElementOperator<E>, TransformableMatrix<BaseMatrix<?,?>>

`Scalar`を成分とする行列を表わすクラスです。

バージョン:
  $Revision: 1.31 $, 2004/07/05
作成者:
  Koga Laboratory
関連項目:
  直列化された形式

コンストラクタの概要
`BaseMatrix()` 0*0の行列を生成します。
`BaseMatrix(E[] elements)` `elements`で与えられた成分をもつ行ベクトルを生成します。
`BaseMatrix(E[][] elements)` `elements`で与えられた成分をもつ行列を生成します。
`BaseMatrix(int rowSize, int columnSize)` 新しく生成された`MatrixObject`オブジェクトを初期化します。
`BaseMatrix(int rowSize, int columnSize, Scalar<?>[][] elements)` `elements`で与えられた成分をもつ`rowSize`*`columnSize`の行列を生成します。

メソッドの概要
`BaseMatrix<?,?>` | `add(BaseMatrix<?,?> value)` 行列`value`との和を求めます。
`BaseMatrix<?,?>` | `add(TransformableMatrix<?> value)` `value`との和を返します。
`M` | `addElementWise(double value)` 成分毎に実数を加えます。
`BaseMatrix<?,?>` | `addElementWise(int value)` 成分毎に整数を加えます。
`BaseMatrix<?,?>` | `addElementWise(Scalar<?> scalar)` 成分毎にスカラーを加えます。
`BaseMatrix<?,?>` | `appendDown(BaseMatrix<?,?> value)` 行列`value`を下側に連結した行列を生成します。
`BaseMatrix<?,?>` | `appendDown(TransformableMatrix<?> value)` 下側に行列`value`を付けた行列を生成します。
`BaseMatrix<?,?>` | `appendRight(BaseMatrix<?,?> value)` `value`を右側に連結した行列を生成します。
`BaseMatrix<?,?>` | `appendRight(TransformableMatrix<?> value)` 右側に`value`を付けた行列を生成します。
`M` | `ceilElementWise()` 大きい整数に丸めます。
`M` | `clone()` Object#clone()
`BooleanMatrix` | `compareElementWise(String operator, BaseMatrix<?,?> opponent)` 行列`opponent`の各成分と成分毎に`operator`で指定された演算子で比較し, それぞれの結果を成分とする`BooleanMatrix`を生成します。
`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`で返します。
`M` | `conjugate()` 共役複素行列を返します。
`M` | `conjugateTranspose()` 各成分の共役複素数の転置行列を返します。
`void` | `copy(BaseMatrix<?,?> source)` 各成分に行列`source`各成分をコピーします。
`void` | `copy(DoubleMatrix source)` 行列`source`の成分をコピーします。
`void` | `copy(IntMatrix source)` 行列`source`の成分をコピーします。
`void` | `copy(Matrix source)` `source`の成分をコピーします。
`BaseMatrix<?,?>` | `covariance(BaseMatrix<?,?> opponent)` ベクトル`opponent`との共分散行列を返します。
`BaseMatrix<?,?>` | `covariance(TransformableMatrix<?> value)` `opponent`との共分散行列を返します。
`M` | `createOnes(int rowSize, int columnSize)` `rowSize`*`columnSize`の全成分が1である行列を生成します。
`M` | `createUnit(int rowSize, int columnSize)` `rowSize`*`columnSize`の単位行列を生成します。
`M` | `createZero(int rowSize, int columnSize)` `rowSize`*`columnSize`の零行列を生成します。
`M` | `cumulativeProduct()` 各要の累積積からなる行列を返します。
`M` | `cumulativeProductColumnWise()` 列毎の累積積行列を返します。
`M` | `cumulativeProductRowWise()` 行毎の累積積行列を返します。
`M` | `cumulativeSum()` 各要の累積和からなる行列を返します。
`M` | `cumulativeSumColumnWise()` 列毎の累積和行列を返します。
`M` | `cumulativeSumRowWise()` 行毎の累積和行列を返します。
`E` | `determinant()` 行列式を返します。
`static
`<E extends Scalar<E>> BaseMatrix<?,E>`
` | `diagonal(E[] diagonalElements)` 対角行列を生成します。
`M` | `diagonalToVector()` 対角成分をからなる列ベクトルを生成します。
`BaseMatrix<?,?>` | `divide(BaseMatrix<?,?> value)` 行列`value`との商を求めます。
`BaseMatrix<?,?>` | `divide(double value)` 各成分と実数valueの商(`this`/`value`)を返します。
`BaseMatrix<?,?>` | `divide(int value)` 各成分と整数valueの商(`this`/`value`)を返します。
`BaseMatrix<?,?>` | `divide(Scalar<?> value)` 各成分とスカラーの商からなる行列を返します。
`BaseMatrix<?,?>` | `divide(TransformableMatrix<?> value)` 行列`value`の逆行列との積(`this`*value -1 )を返します。
`BaseMatrix<?,?>` | `divideElementWise(BaseMatrix<?,?> value)` 行列`value`との成分毎の商を求めます。
`BaseMatrix<?,?>` | `divideElementWise(TransformableMatrix<?> value)` `value`との成分毎の商を成分にもつ行列を返します。
`boolean` | `equals(BaseMatrix<?,?> 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`行を入れ替えます。
`M` | `fixElementWise()` ゼロ方向の整数に丸めます。
`M` | `floorElementWise()` 小さい整数に丸めます。
`E` | `getElement(int index)` 成分を行毎に数え`index`で指定した成分を返します。
`E` | `getElement(int row, int column)` `row`行`column`列の成分を返します。
`protected E[][]` | `getElements()` 全ての成分の2次元配列を返します。
`Matrix` | `getImaginaryPart()` 虚部行列を返します。
`Matrix` | `getRealPart()` 実部行列を返します。
`M` | `getSubMatrix(int rowMin, int rowMax, int columnMin, int columnMax)` 部分行列`this(rowMinimum:rowMaximum,columnMinimum:columnMaximum)`を生成します。
`M` | `getSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex)` `rowMinimum`行から`rowMaximum`行目で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`M` | `getSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax)` `columnMinimum`列から`columnMaximum`列まで、 `rowIndex`で指定された行を成分とする部分行列を生成します。
`M` | `getSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex)` `rowIndex`で指定された行で、`columnIndex` で指定された列を成分とする部分行列を生成します。
`M` | `getSubVector(IntMatrix index)` 行毎に数え`index`で指定した成分を成分とする部分行列を生成します。
`int` | `hashCode()` Override hashCode.
`M` | `inverse()` 逆行列(`this` -1 )を返します。
`M` | `inverse(double tolerance, boolean stopIfSingular)` 逆行列(`this` -1 )を返します。
`BaseMatrix<?,?>` | `inverseElementWise()` 成分毎の逆数からなる行列を返します。
`boolean` | `isComplex()` 複素成分をもつか判定します。
`BooleanMatrix` | `isFiniteElementWise()` 各成分の有限性の真偽を成分にもつ行列を返します。
`BooleanMatrix` | `isInfiniteElementWise()` 各成分の無限性の真偽を成分にもつ行列を返します。
`BooleanMatrix` | `isNanElementWise()` 各成分の非数性の真偽を成分にもつ行列を返します。
`boolean` | `isReal()` 実成分のみをもつか(複素成分をもたないか)判定します。
`boolean` | `isTransformableFrom(Matrix value)` 引数で与えられた型から、この型へ変換可能か判定します。
`boolean` | `isTransformableTo(Matrix value)` この型から引数で与えられた型へ変換可能か判定します。
`boolean` | `isUnit(double tolerance)` 単位行列であるか判定します。
`boolean` | `isZero()` 零行列(全ての成分がデフォルトの初期値)であるか判定します。
`boolean` | `isZero(double tolerance)` 零行列であるか判定します。
`BaseMatrix<?,?>` | `leftDivide(BaseMatrix<?,?> value)` 行列`value`との左商を求めます。
`BaseMatrix<?,?>` | `leftDivide(TransformableMatrix<?> value)` 逆行列と行列`value`の積(`this` -1 *`value`)を返します。
`BaseMatrix<?,?>` | `leftDivideElementWise(BaseMatrix<?,?> value)` 行列`value`との成分毎の左商(`this`*`value`)を求めます。
`BaseMatrix<?,?>` | `leftDivideElementWise(TransformableMatrix<?> value)` `value`との成分毎の左からの商を成分にもつ行列を返します。
`E` | `mean()` 全ての成分の平均値を返します。
`M` | `meanColumnWise()` 各成分列毎の平均値行ベクトルを返します。
`M` | `meanRowWise()` 各成分行毎の平均値列ベクトルを返します。
`BaseMatrix<?,?>` | `multiply(BaseMatrix<?,?> value)` 行列`value`との積を求めます。
`M` | `multiply(double value)` 各成分と実数`value`の積を(`this`*`value`)を返します。
`M` | `multiply(int value)` 各成分と整数`value`の積を(`this`*`value`)を返します。
`BaseMatrix<?,?>` | `multiply(Scalar<?> value)` 各成分とスカラー`value`の積を返します。
`BaseMatrix<?,?>` | `multiply(TransformableMatrix<?> value)` 行列`value`との積(`this`*`value`)を返します。
`BaseMatrix<?,?>` | `multiplyElementWise(BaseMatrix<?,?> value)` 行列`value`との成分毎の積を求めます。
`BaseMatrix<?,?>` | `multiplyElementWise(TransformableMatrix<?> value)` `value`との成分毎の積を成分にもつ行列を返します。
`M` | `powerElementWise(int num)` 成分毎に累乗します。
`M` | `powerElementWise(IntMatrix matrix)` 成分毎に累乗します。
`void` | `printElements(Writer output)` ライターに成分を出力します。
`void` | `printElements(Writer output, int maxColumnSize)` ライターに成分を出力します。
`E` | `product()` 全ての成分積を返します。
`M` | `productColumnWise()` 列毎に掛けた行ベクトルを返します。
`M` | `productRowWise()` 行毎に掛けた列ベクトルを返します。
`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`で指定された行を削除します。
`M` | `reshape(int newRowSize, int newColumnSize)` サイズを`newRowSize`*`newColumnSize`に変更した行列を生成します。
`M` | `resize(int newRowSize, int newColumnSize)` `newRowSize`*`newColumnSize`にサイズ変更します。
`M` | `roundElementWise()` 最も近い整数に丸めます。
`M` | `roundToZeroElementWise(double tolerance)` 絶対値が小さい成分を0に丸めます。
`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`を代入します。
`protected void` | `setElements(E[][] elements)` 全ての成分を設定します。
`void` | `setImaginaryPart(BaseMatrix<?,?> imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(DoubleMatrix imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(IntMatrix imaginaryPart)` 虚部行列を設定します。
`void` | `setImaginaryPart(Matrix imagPart)` 虚部行列を設定します。
`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, Matrix source)` 指定した成分に行列`source`を代入します。
`void` | `setSubMatrix(int rowMin, int rowMax, IntMatrix columnIndex, Matrix source)` `rowMinimum`列目から`rowMaximum`列目の成分の`columnIndex` で指定された行の成分に行列`source`を代入します。
`void` | `setSubMatrix(IntMatrix rowIndex, int columnMin, int columnMax, Matrix source)` `rowIndex`で指定した行の`columnMinimum`列から`columnMaximum` 列までの行列`source`を代入します。
`void` | `setSubMatrix(IntMatrix rowIndex, IntMatrix columnIndex, Matrix source)` `rowIndex`で指定した行の`columnIndex`で指定した列に行列`source`を代入します。
`void` | `setSubVector(int min, int max, Matrix source)` 成分を行毎に数え、`minimum`から`maximum`までに`source`の成分を代入します。
`void` | `setSubVector(IntMatrix index, Matrix source)` `index`で指定した各成分に行列`source`の成分を代入します。
`BaseMatrix<?,?>` | `subtract(BaseMatrix<?,?> value)` 行列`value`との差を求めます。
`BaseMatrix<?,?>` | `subtract(TransformableMatrix<?> value)` `value`との差を返します。
`M` | `subtractElementWise(double value)` 成分毎に実数を引きます。
`BaseMatrix<?,?>` | `subtractElementWise(int value)` 成分毎に実数を引きます。
`BaseMatrix<?,?>` | `subtractElementWise(Scalar<?> value)` 成分毎にスカラーを引きます。
`E` | `sum()` 全ての成分の合計を返します。
`M` | `sumColumnWise()` 列毎に加えた行ベクトルを返します。
`M` | `sumRowWise()` 行毎に加えた列ベクトルを返します。
`Matrix` | `toComplex()` 複素成分行列へ変換します。
`E` | `trace()` 全対角成分の和を返します。
`Matrix` | `transformFrom(Matrix value)` 引数で与えられた型からこの型へ変換します。
`Matrix` | `transformTo(Matrix value)` この型から引数で与えられた型へ変換します。
`M` | `transpose()` 転置行列(`this` T )を生成します。
`M` | `unaryMinus()` 符号を反転した値(-this)を返します。
`E` | `variance()` 全ての成分の分散を返します。
`M` | `vectorToDiagonal()` 列ベクトルまたは行ベクトルの各成分を対角成分に持つ行列を生成します。

クラス org.mklab.nfc.matrix.AbstractMatrix から継承されたメソッド
`add, covariance, createOnes, createOnes, createOnes, createUnit, createUnit, createUnit, createZero, createZero, createZero, divide, divideElementWise, isUnit, leftDivide, leftDivide, leftDivide, leftDivide, leftDivideElementWise, multiply, multiplyElementWise, power, powerElementWise, roundToZeroElementWise, shiftLeft, shiftUp, subtract, 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, getDefaultElementFormat, getElementAlignment, getElementFormat, getGridClassName, getPrintingElementsString, getPrintingString, getRowSize, hasSameColumnSize, hasSameRowSize, isEmpty, isSameSize, isSquare, length, print, print, print, removeColumnVector, removeRowVector, setColumnSize, setDefaultElementAlignment, setDefaultElementFormat, 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, isUnit, leftDivide, leftDivide, leftDivide, leftDivide, multiply, power, shiftLeft, shiftUp, subtract`

インタフェース 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, length, print, print, print, removeColumnVector, removeRowVector, setElementAlignment, setElementFormat`

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

コンストラクタの詳細

### BaseMatrix

    public BaseMatrix()

  0*0の行列を生成します。

### BaseMatrix

    public BaseMatrix(int rowSize,
                      int columnSize)

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

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

### BaseMatrix

    public BaseMatrix(E[] elements)

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

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

### BaseMatrix

    public BaseMatrix(E[][] elements)

  `elements`で与えられた成分をもつ行列を生成します。

  パラメータ:
    `elements` - 行列の成分をもつ配列

### BaseMatrix

    public BaseMatrix(int rowSize,
                      int columnSize,
                      Scalar<?>[][] elements)

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

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

メソッドの詳細

### equals

    public boolean equals(Object opponent)

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

### hashCode

    public int hashCode()

  Override hashCode.

  オーバーライド:
    クラス `AbstractGrid<M extends BaseMatrix<M,E>>` 内の `hashCode`
  戻り値:
    the Objects hashcode.
  関連項目:
    `Object.hashCode()`

### 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(BaseMatrix<?,?> opponent,
                          double tolerance)

  行列`opponent`と全ての成分の値が等しい(差の絶対値が許容誤差以下である)か判定します。

  パラメータ:
    `opponent` - 比較対象の行列
    `tolerance` - 許容誤差
  戻り値:
    全ての成分の値が等しければtrue、そうでなければfalse

### clone

    public M clone()

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

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

### 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(IntMatrix source)

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

  定義:
    インタフェース `MatrixElementOperator<E extends Scalar<E>>` 内の `copy`
  パラメータ:
    `source` - コピー元の整数行列
  関連項目:
    `MatrixElementOperator.copy(org.mklab.nfc.matrix.IntMatrix)`

### copy

    public void copy(DoubleMatrix source)

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

  定義:
    インタフェース `MatrixElementOperator<E extends Scalar<E>>` 内の `copy`
  パラメータ:
    `source` - コピー元の実数行列
  関連項目:
    `MatrixElementOperator.copy(org.mklab.nfc.matrix.DoubleMatrix)`

### copy

    public void copy(BaseMatrix<?,?> source)

  各成分に行列`source`各成分をコピーします。

  パラメータ:
    `source` - コピー元の行列

### copy

    public void copy(Matrix source)

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

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

### isZero

    public boolean isZero()

  インタフェース `Grid` の記述:
  零行列(全ての成分がデフォルトの初期値)であるか判定します。

  定義:
    インタフェース `Grid` 内の `isZero`
  オーバーライド:
    クラス `AbstractMatrix<M extends BaseMatrix<M,E>>` 内の `isZero`
  戻り値:
    零行列(全ての成分がデフォルトの初期値)ならばtrue、そうでなければfalse
  関連項目:
    `Grid.isZero()`

### appendDown

    public BaseMatrix<?,?> appendDown(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  下側に行列`value`を付けた行列を生成します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `appendDown`
  パラメータ:
    `value` - 付ける行列
  戻り値:
    下側に`value`をつけた行列
  関連項目:
    `TransformableMatrix.appendDown(org.mklab.nfc.matrix.TransformableMatrix)`

### appendDown

    public BaseMatrix<?,?> appendDown(BaseMatrix<?,?> value)

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

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

### appendRight

    public BaseMatrix<?,?> appendRight(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  右側に`value`を付けた行列を生成します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `appendRight`
  パラメータ:
    `value` - 付ける複素数
  戻り値:
    右側に`value`を付けた行列
  関連項目:
    `TransformableMatrix.appendRight(org.mklab.nfc.matrix.TransformableMatrix)`

### appendRight

    public BaseMatrix<?,?> appendRight(BaseMatrix<?,?> value)

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

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

### transpose

    public M transpose()

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

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

### 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 M 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)`

### getSubMatrix

    public M 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 M 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 M 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 M getSubVector(IntMatrix index)

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

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

### diagonalToVector

    public M diagonalToVector()

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

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

### vectorToDiagonal

    public M vectorToDiagonal()

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

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

### diagonal

    public static <E extends Scalar<E>> BaseMatrix<?,E> diagonal(E[] diagonalElements)

  対角行列を生成します。

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

### reshape

    public M reshape(int newRowSize,
                     int newColumnSize)

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

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

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

### resize

    public M resize(int newRowSize,
                    int newColumnSize)

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

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

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

### compareElementWise

    public BooleanMatrix compareElementWise(String operator,
                                            BaseMatrix<?,?> opponent)

  行列`opponent`の各成分と成分毎に`operator`で指定された演算子で比較し, それぞれの結果を成分とする`BooleanMatrix`を生成します。

  パラメータ:
    `operator` - 比較演算子(".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    比較結果を成分とする`BooleanMatrix`

### 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)`

### 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(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(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(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)`

### 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(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)`

### getElement

    public E getElement(int row,
                        int column)

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

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

### getElement

    public E getElement(int index)

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

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

### getElements

    protected final E[][] getElements()

  全ての成分の2次元配列を返します。

  戻り値:
    全ての成分の2次元配列

### setElements

    protected final void setElements(E[][] elements)

  全ての成分を設定します。

  パラメータ:
    `elements` - 全ての成分の2次元配列

### setElement

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

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

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

### setElement

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

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

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

### setElement

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

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

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

### setElement

    public void setElement(int index,
                           double value)

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

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

### setElement

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

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

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

### add

    public BaseMatrix<?,?> add(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `value`との和を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `add`
  パラメータ:
    `value` - 行列
  戻り値:
    `value`との和
  関連項目:
    `TransformableMatrix.add(org.mklab.nfc.matrix.TransformableMatrix)`

### add

    public BaseMatrix<?,?> add(BaseMatrix<?,?> value)

  行列`value`との和を求めます。

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

### subtract

    public BaseMatrix<?,?> subtract(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `value`との差を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `subtract`
  パラメータ:
    `value` - 引く行列
  戻り値:
    `value`との差
  関連項目:
    `TransformableMatrix.subtract(org.mklab.nfc.matrix.TransformableMatrix)`

### subtract

    public BaseMatrix<?,?> subtract(BaseMatrix<?,?> value)

  行列`value`との差を求めます。

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

### multiply

    public BaseMatrix<?,?> multiply(Scalar<?> value)

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

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

### multiply

    public M multiply(int value)

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

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

### multiply

    public M multiply(double value)

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

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

### multiply

    public BaseMatrix<?,?> multiply(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  行列`value`との積(`this`*`value`)を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `multiply`
  パラメータ:
    `value` - 行列
  戻り値:
    `value`との積
  関連項目:
    `TransformableMatrix.multiply(org.mklab.nfc.matrix.TransformableMatrix)`

### multiply

    public BaseMatrix<?,?> multiply(BaseMatrix<?,?> value)

  行列`value`との積を求めます。

  パラメータ:
    `value` - 掛ける行列
  戻り値:
    行列`value`との積

### divide

    public BaseMatrix<?,?> divide(Scalar<?> value)

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

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

### divide

    public BaseMatrix<?,?> divide(int value)

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

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

### divide

    public BaseMatrix<?,?> divide(double value)

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

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

### divide

    public BaseMatrix<?,?> divide(TransformableMatrix<?> value)

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

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `divide`
  パラメータ:
    `value` - 割る行列
  戻り値:
    `value`の逆行列との積
  関連項目:
    `TransformableMatrix.divide(org.mklab.nfc.matrix.TransformableMatrix)`

### divide

    public BaseMatrix<?,?> divide(BaseMatrix<?,?> value)

  行列`value`との商を求めます。

  パラメータ:
    `value` - 割る行列
  戻り値:
    行列`value`との商

### leftDivide

    public BaseMatrix<?,?> leftDivide(TransformableMatrix<?> value)

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

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `leftDivide`
  パラメータ:
    `value` - 割る行列
  戻り値:
    逆行列と`value`との積
  関連項目:
    `TransformableMatrix.leftDivide(org.mklab.nfc.matrix.TransformableMatrix)`

### leftDivide

    public BaseMatrix<?,?> leftDivide(BaseMatrix<?,?> value)

  行列`value`との左商を求めます。

  パラメータ:
    `value` - 割られる行列
  戻り値:
    行列`value`との左商

### unaryMinus

    public M unaryMinus()

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

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

### inverse

    public M inverse()

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

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

### inverse

    public M inverse(double tolerance,
                     boolean stopIfSingular)

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

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

### conjugate

    public M conjugate()

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

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

### conjugateTranspose

    public M conjugateTranspose()

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

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

### isZero

    public boolean isZero(double tolerance)

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

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

### isUnit

    public boolean isUnit(double tolerance)

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

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

### addElementWise

    public BaseMatrix<?,?> addElementWise(Scalar<?> scalar)

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

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

### addElementWise

    public BaseMatrix<?,?> addElementWise(int value)

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

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

### addElementWise

    public M addElementWise(double value)

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

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

### subtractElementWise

    public BaseMatrix<?,?> subtractElementWise(int value)

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

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

### subtractElementWise

    public BaseMatrix<?,?> subtractElementWise(Scalar<?> value)

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

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

### subtractElementWise

    public M subtractElementWise(double value)

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

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

### multiplyElementWise

    public BaseMatrix<?,?> multiplyElementWise(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `value`との成分毎の積を成分にもつ行列を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `multiplyElementWise`
  パラメータ:
    `value` - 乗じる行列
  戻り値:
    乗算の結果
  関連項目:
    `TransformableMatrix.multiplyElementWise(org.mklab.nfc.matrix.TransformableMatrix)`

### multiplyElementWise

    public BaseMatrix<?,?> multiplyElementWise(BaseMatrix<?,?> value)

  行列`value`との成分毎の積を求めます。

  パラメータ:
    `value` - 掛ける行列
  戻り値:
    行列`value`との成分毎の積

### divideElementWise

    public BaseMatrix<?,?> divideElementWise(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `value`との成分毎の商を成分にもつ行列を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `divideElementWise`
  パラメータ:
    `value` - 割る行列
  戻り値:
    割り算の結果
  関連項目:
    `TransformableMatrix.divideElementWise(org.mklab.nfc.matrix.TransformableMatrix)`

### divideElementWise

    public BaseMatrix<?,?> divideElementWise(BaseMatrix<?,?> value)

  行列`value`との成分毎の商を求めます。

  パラメータ:
    `value` - 割る行列
  戻り値:
    行列`value`との成分毎の商

### leftDivideElementWise

    public BaseMatrix<?,?> leftDivideElementWise(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `value`との成分毎の左からの商を成分にもつ行列を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `leftDivideElementWise`
  パラメータ:
    `value` - 割られる行列
  戻り値:
    割り算の結果
  関連項目:
    `TransformableMatrix.leftDivideElementWise(org.mklab.nfc.matrix.TransformableMatrix)`

### leftDivideElementWise

    public BaseMatrix<?,?> leftDivideElementWise(BaseMatrix<?,?> value)

  行列`value`との成分毎の左商(`this`*`value`)を求めます。

  パラメータ:
    `value` - 割られる行列
  戻り値:
    行列`value`との成分毎の左商

### inverseElementWise

    public BaseMatrix<?,?> inverseElementWise()

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

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

### powerElementWise

    public M powerElementWise(int num)

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

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

### powerElementWise

    public M powerElementWise(IntMatrix matrix)

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

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

### isNanElementWise

    public BooleanMatrix isNanElementWise()

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

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

### isFiniteElementWise

    public BooleanMatrix isFiniteElementWise()

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

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

### isInfiniteElementWise

    public BooleanMatrix isInfiniteElementWise()

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

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

### 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)`

### sumColumnWise

    public M sumColumnWise()

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

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

### sumRowWise

    public M sumRowWise()

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

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

### cumulativeSum

    public M cumulativeSum()

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

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

### cumulativeSumRowWise

    public M cumulativeSumRowWise()

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

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

### cumulativeSumColumnWise

    public M cumulativeSumColumnWise()

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

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

### productRowWise

    public M productRowWise()

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

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

### productColumnWise

    public M productColumnWise()

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

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

### cumulativeProduct

    public M cumulativeProduct()

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

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

### cumulativeProductRowWise

    public M cumulativeProductRowWise()

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

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

### cumulativeProductColumnWise

    public M cumulativeProductColumnWise()

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

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

### meanRowWise

    public M meanRowWise()

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

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

### meanColumnWise

    public M meanColumnWise()

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

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

### covariance

    public BaseMatrix<?,?> covariance(TransformableMatrix<?> value)

  インタフェース `TransformableMatrix` の記述:
  `opponent`との共分散行列を返します。

  定義:
    インタフェース `TransformableMatrix<BaseMatrix<?,?>>` 内の `covariance`
  パラメータ:
    `value` - 対となるベクトル
  戻り値:
    共分散行列 (Covariance)
  関連項目:
    `TransformableMatrix.covariance(org.mklab.nfc.matrix.TransformableMatrix)`

### covariance

    public BaseMatrix<?,?> covariance(BaseMatrix<?,?> opponent)

  ベクトル`opponent`との共分散行列を返します。

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

### sum

    public E sum()

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

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

### mean

    public E mean()

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

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

### variance

    public E variance()

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

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

### trace

    public E trace()

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

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

### product

    public E product()

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

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

### determinant

    public E determinant()

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

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

### ceilElementWise

    public M ceilElementWise()

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

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

### floorElementWise

    public M floorElementWise()

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

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

### fixElementWise

    public M fixElementWise()

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

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

### roundToZeroElementWise

    public M roundToZeroElementWise(double tolerance)

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

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

### roundElementWise

    public M roundElementWise()

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

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

### createUnit

    public M createUnit(int rowSize,
                        int columnSize)

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

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

### createZero

    public M createZero(int rowSize,
                        int columnSize)

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

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

### createOnes

    public M createOnes(int rowSize,
                        int columnSize)

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

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

### isComplex

    public boolean isComplex()

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

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

### isReal

    public boolean isReal()

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

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

### getRealPart

    public Matrix getRealPart()

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

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

### getImaginaryPart

    public Matrix getImaginaryPart()

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

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

### 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 imagPart)

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

  定義:
    インタフェース `Matrix` 内の `setImaginaryPart`
  パラメータ:
    `imagPart` - 虚部行列
  関連項目:
    `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 Matrix toComplex()

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

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

### 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)`

### isTransformableFrom

    public boolean isTransformableFrom(Matrix value)

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

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

### transformFrom

    public Matrix transformFrom(Matrix value)

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

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

### isTransformableTo

    public boolean isTransformableTo(Matrix value)

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

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

### transformTo

    public Matrix transformTo(Matrix value)

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

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

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