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

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

    java.lang.Object
      org.mklab.nfc.matrix.BaseMatrixUtil

    public final class BaseMatrixUtil

extends Object

`BaseMatrix`のユーティリティクラスです。

バージョン:
  $Revision: 1.18 $
作成者:
  koga

メソッドの概要
`static
`<E extends Scalar<E>> E[][]`
` | `add(Scalar<?>[][] a1, Scalar<?>[][] a2)` 行列の和を求めます。
`static
`<E extends Scalar<E>> E[][]`
` | `addElementWise(E[][] matrix, double scalar)` 行列の全ての成分に実数を加えた行列を生成します。
`static Scalar<?>[][]` | `addElementWise(Scalar<?>[][] matrix, Scalar<?> scalar)` 行列の全ての成分にスカラーを加えた行列を生成します。
`static void` | `addSelf(Scalar<?>[][] a1, Scalar<?>[][] a2)` 第一行列に第二行列を加えます。
`static
`<E extends Scalar<E>> boolean`
` | `anyZero(E[][] matrix, double tolerance)` 少なくとも1個は絶対値が許容誤差以下である成分が行列に含まれるか判定します。
`static
`<E extends Scalar<E>> boolean`
` | `anyZero(E[] vector, double tolerance)` 少なくとも1個は絶対値が許容誤差以下である成分がベクトルに含まれるか判定します。
`static boolean[][]` | `compareElementWise(Scalar<?>[][] matrix, String operator, double scalar)` 各成分と`scalar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElementWise(Scalar<?>[][] a1, String operator, double[][] a2)` 2個の行列を成分毎にoperatorで指定された演算子で比較し, 計算結果を成分とするbooleanの行列を生成します。
`static boolean[][]` | `compareElementWise(Scalar<?>[][] matrix, String operator, GridElement<?> scalar)` 各成分と`scalar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElementWise(Scalar<?>[][] matrix, String operator, int scalar)` 各成分と`sclar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElementWise(Scalar<?>[][] a1, String operator, int[][] a2)` 2個の行列を成分毎にoperatorで指定された演算子で比較し, 計算結果を成分とするbooleanの行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `conjugate(E[][] matrix)` 共役行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `conjugateTranspose(E[][] matrix)` 共役複素転置行列を生成します。
`static void` | `copy(double[][] source, Scalar<?>[][] destination)` 行列`source`の各成分を行列`destination`の各成分にコピーします。
`static void` | `copy(int[][] source, Scalar<?>[][] destination)` 行列`source`の各成分を行列`destination`の各成分にコピーします。
`static
`<E extends Scalar<E>> E[][]`
` | `covariance(E[][] a1, E[][] a2)` 共分散行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `createOnes(E[][] matrix, int rowSize, int columnSize)` 全ての成分が１である行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `createUnit(E[][] matrix, int rowSize, int columnSize)` 単位行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeProduct(E[][] matrix)` 全ての成分の累積積を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeProductColumnWise(E[][] matrix)` 列毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeProductRowWise(E[][] matrix)` 行毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeSum(E[][] matrix)` 全ての成分の累積和を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeSumColumnWise(E[][] matrix)` 列毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `cumulativeSumRowWise(E[][] matrix)` 行毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E`
` | `determinant(E[][] matrix)` 行列式を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `divide(E[][] matrix, double scalar)` 行列を実数で割る。
`static
`<E extends Scalar<E>> E[][]`
` | `divide(E[][] matrix, int scalar)` 行列を整数で割る。
`static Scalar<?>[][]` | `divide(Scalar<?>[][] matrix, Scalar<?> scalar)` 全ての成分をスカラーで割る。
`static Scalar<?>[][]` | `divideElementWise(Scalar<?>[][] a1, Scalar<?>[][] a2)` 成分毎の割り算の結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `elementWiseFunction(NumericalScalar<?>[][] matrix, org.mklab.nfc.matrix.NumericalScalarFunction function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static Scalar<?>[][]` | `elementWiseFunction(Scalar<?>[][] matrix, org.mklab.nfc.matrix.ScalarFunction function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static boolean` | `equals(Scalar<?>[][] a1, Scalar<?>[][] a2, double tolerance)` 2個の配列の成分が全て等しか判定します。
`static Scalar<?>[][]` | `getImagPartElements(Scalar<?>[][] matrix)` 虚部の2次元配列を返します。
`static Scalar<?>[][]` | `getRealPartElements(Scalar<?>[][] matrix)` 実部の2次元配列を返します。
`static Scalar<?>[][]` | `inverseElementWise(Scalar<?>[][] matrix)` 行列の全ての成分の逆数を成分とする行列を生成します。
`static boolean` | `isComplex(Scalar<?>[][] matrix)` 複素数成分をもつか判定します。
`static
`<E extends Scalar<E>> boolean[][]`
` | `isFiniteElementWise(E[][] matrix)` 各成分の有限性の真偽を成分にもつ行列を返します。
`static
`<E extends Scalar<E>> boolean[][]`
` | `isInfiniteElementWise(E[][] matrix)` 各成分の無限性の真偽を成分にもつ行列を返します。
`static
`<E extends Scalar<E>> boolean[][]`
` | `isNanElementWise(E[][] matrix)` 各成分の非数性の真偽を成分にもつ行列を生成します。
`static
`<E extends Scalar<E>> boolean`
` | `isUnit(E[][] matrix, double tolerance)` 単位行列であるか判定します。
`static
`<E extends Scalar<E>> boolean`
` | `isZero(E[][] matrix, double tolerance)` 零行列か判定します。
`static Scalar<?>[][]` | `leftDivideElementWise(Scalar<?>[][] a1, Scalar<?>[][] a2)` 成分毎の割り算(左が分母、右が分子)の結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E`
` | `mean(E[][] matrix)` 全ての成分の平均値を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `meanColumnWise(E[][] matrix)` 列毎に全ての成分の平均値を計算し、計算結果を成分とする行ベクトルを生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `meanRowWise(E[][] matrix)` 行毎に全ての成分の平均値を計算し、計算結果を成分とする列ベクトルを生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `multiply(double[][] matrix, E scalar)` 実行列とスカラーの積を求めます。
`static
`<E extends Scalar<E>> E[][]`
` | `multiply(E[][] matrix, double scalar)` 行列に実数を掛けます。
`static
`<E extends Scalar<E>> E[][]`
` | `multiply(E[][] matrix, int scalar)` 行列に整数を掛けます。
`static
`<E extends Scalar<E>> E[][]`
` | `multiply(Scalar<?>[][] matrix, Scalar<?> scalar)` 行列にスカラーを掛けます。
`static
`<E extends Scalar<E>> E[][]`
` | `multiply(Scalar<?>[][] a1, Scalar<?>[][] a2)` 2個の行列の積を求めます。
`static Scalar<?>[][]` | `multiplyElementWise(Scalar<?>[][] a1, Scalar<?>[][] a2)` 成分毎に乗算を行います。
`static
`<E extends Scalar<E>> void`
` | `multiplySelf(E[][] matrix, E scalar)` 行列自身に数を掛けます。
`static
`<E extends Scalar<E>> E[][]`
` | `powerElementWise(E[][] matrix, int scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `powerElementWise(E[][] a1, int[][] a2)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `powerElementWise(E scalar, int[][] matrix)` スカラーの累乗を行列の成分毎に計算し、計算結果を成分とする行列を生成します。
`static
`<E extends Scalar<E>> E`
` | `product(E[][] matrix)` 行列の全ての成分の積を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `productColumnWise(E[][] matrix)` 列毎に全ての成分の積を計算し、計算結果を成分とする行ベクトルを生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `productRowWise(E[][] matrix)` 行毎に全ての成分の積を計算し、計算結果を成分とする列ベクトルを生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `roundToZeroElementWise(E[][] matrix, double tolerance)` 絶対値が小さい成分を0に丸めます。
`static void` | `setElements(Scalar<?>[][] destination, int[] index, double[][] source)` 指定された番号の成分に値を代入します。
`static void` | `setElements(Scalar<?>[][] destination, int[] index, int[][] source)` 指定された番号の成分に値を代入します。
`static void` | `setImagPartElements(Scalar<?>[][] matrix, double[][] imagPart)` 虚部を設定します。
`static void` | `setImagPartElements(Scalar<?>[][] matrix, int[][] imagPart)` 虚部を設定します。
`static void` | `setImagPartElements(Scalar<?>[][] matrix, Scalar<?>[][] imagPart)` 虚部を設定します。
`static void` | `setRealPartElements(Scalar<?>[][] matrix, double[][] realPart)` 実部を設定します。
`static void` | `setRealPartElements(Scalar<?>[][] matrix, int[][] realPart)` 実部を設定します。
`static void` | `setRealPartElements(Scalar<?>[][] matrix, Scalar<?>[][] realPart)` 実部を設定します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int[] rowIndex, int[] columnIndex, double[][] source)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int[] rowIndex, int[] columnIndex, int[][] source)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int[] rowIndex, int columnMin, int columnMax, double[][] soruce)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int[] rowIndex, int columnMin, int columnMax, int[][] source)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowTo, int columnTo, double[][] source, int rowMin, int rowMax, int columnMin, int columnMax)` `rowTo`行`columnTo`列を始点として、 グリッド`source`の`rowMin`行から`rowMax`行、 `columnMin`列から`columnMax`列までの値をコピーします。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowTo, int columnTo, int[][] source, int rowMin, int rowMax, int columnMin, int columnMax)` `rowTo`行`columnTo`列を始点として、 グリッド`source`の`rowMin`行から`rowMax`行、 `columnMin`列から`columnMax`列までの値をコピーします。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowMin, int rowMax, int[] columnIndex, double[][] source)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowMin, int rowMax, int[] columnIndex, int[][] source)` 指定された場所に値を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowMin, int rowMax, int columnMin, int columnMax, double[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowMin, int rowMax, int columnMin, int columnMax, int[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubMatrix(Scalar<?>[][] destination, int rowMin, int rowMax, int columnMin, int columnMax, Scalar<?>[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubVector(Scalar<?>[] destination, int min, int max, double[] source)` 配列`destination`の`min`から`max`まで 配列`source`の値をコピーします。
`static void` | `setSubVector(Scalar<?>[] destination, int min, int max, int[] source)` 配列`destination`の`min`から`max`まで 配列`source`の値をコピーします。
`static
`<E extends Scalar<E>> void`
` | `setUnit(E[][] matrix)` 単位行列に設定します。
`static
`<E extends Scalar<E>> E[][]`
` | `subtract(E[][] a1, E[][] a2)` 行列の差を求めます。
`static
`<E extends Scalar<E>> E[][]`
` | `subtractElementWise(E[][] matrix, double scalar)` 行列の全ての成分に実数を引いた行列を生成します。
`static Scalar<?>[][]` | `subtractElementWise(Scalar<?>[][] matrix, Scalar<?> scalar)` 行列の全ての成分にスカラーを引いた行列を生成します。
`static
`<E extends Scalar<E>> E`
` | `sum(E[][] matrix)` 行列の全ての和を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `sumColumnWise(E[][] matrix)` 列毎に全ての成分の和を計算し、計算結果を成分とする行ベクトルを生成します。
`static
`<E extends Scalar<E>> E[][]`
` | `sumRowWise(E[][] matrix)` 行毎に全ての成分の和を計算し、計算結果を成分とする列ベクトルを生成します。
`static Scalar<?>[][]` | `toComplexElements(Scalar<?>[][] matrix)` 複素成分の2次元配列を返します。
`static
`<E extends Scalar<E>> E`
` | `trace(E[][] matrix)` 全対角成分の和(トレース)を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `unaryMinus(E[][] matrix)` 成分の符号を反転した行列を生成します。
`static
`<E extends Scalar<E>> E`
` | `variance(E[][] matrix)` 分散を返します。

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

メソッドの詳細

### equals

    public static final boolean equals(Scalar<?>[][] a1,
                                       Scalar<?>[][] a2,
                                       double tolerance)

  2個の配列の成分が全て等しか判定します。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列
    `tolerance` - 許容誤差
  戻り値:
    配列の成分が等しければtrue、そうでなければfalseを返します。

### compareElementWise

    public static final boolean[][] compareElementWise(Scalar<?>[][] matrix,
                                                       String operator,
                                                       double scalar)

  各成分と`scalar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `scalar` - 比較対象
  戻り値:
    計算結果を成分とする行列

### compareElementWise

    public static final boolean[][] compareElementWise(Scalar<?>[][] matrix,
                                                       String operator,
                                                       int scalar)

  各成分と`sclar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `scalar` - 比較対象
  戻り値:
    計算結果を成分とする行列

### compareElementWise

    public static final boolean[][] compareElementWise(Scalar<?>[][] matrix,
                                                       String operator,
                                                       GridElement<?> scalar)

  各成分と`scalar`を`operator`で指定された演算子で比較し, 計算結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `scalar` - 比較対象
  戻り値:
    計算結果を成分とする行列

### compareElementWise

    public static final boolean[][] compareElementWise(Scalar<?>[][] a1,
                                                       String operator,
                                                       double[][] a2)

  2個の行列を成分毎にoperatorで指定された演算子で比較し, 計算結果を成分とするbooleanの行列を生成します。

  パラメータ:
    `a1` - 第一行列
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `a2` - 第二行列
  戻り値:
    計算結果を成分とするbooleanの行列

### compareElementWise

    public static final boolean[][] compareElementWise(Scalar<?>[][] a1,
                                                       String operator,
                                                       int[][] a2)

  2個の行列を成分毎にoperatorで指定された演算子で比較し, 計算結果を成分とするbooleanの行列を生成します。

  パラメータ:
    `a1` - 第一行列
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `a2` - 第二行列
  戻り値:
    計算結果を成分とするbooleanの行列

### copy

    public static final void copy(double[][] source,
                                  Scalar<?>[][] destination)

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

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

### copy

    public static final void copy(int[][] source,
                                  Scalar<?>[][] destination)

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

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

### add

    public static final <E extends Scalar<E>> E[][] add(Scalar<?>[][] a1,
                                                        Scalar<?>[][] a2)

  行列の和を求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - 加えられる行列
    `a2` - 加える行列
  戻り値:
    行列の和

### addSelf

    public static final void addSelf(Scalar<?>[][] a1,
                                     Scalar<?>[][] a2)

  第一行列に第二行列を加えます。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列

### subtract

    public static final <E extends Scalar<E>> E[][] subtract(E[][] a1,
                                                             E[][] a2)

  行列の差を求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - 引かれる行列
    `a2` - 引く行列
  戻り値:
    行列の差

### multiply

    public static final <E extends Scalar<E>> E[][] multiply(Scalar<?>[][] a1,
                                                             Scalar<?>[][] a2)

  2個の行列の積を求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - 掛けられる行列
    `a2` - 掛ける行列
  戻り値:
    行列の積

### conjugate

    public static final <E extends Scalar<E>> E[][] conjugate(E[][] matrix)

  共役行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 元の行列
  戻り値:
    共役行列

### unaryMinus

    public static final <E extends Scalar<E>> E[][] unaryMinus(E[][] matrix)

  成分の符号を反転した行列を生成します。

  型パラメータ:
    `E` - 成分の型 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    成分の符号を反転した行列

### createUnit

    public static final <E extends Scalar<E>> E[][] createUnit(E[][] matrix,
                                                               int rowSize,
                                                               int columnSize)

  単位行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    単位行列

### createOnes

    public static final <E extends Scalar<E>> E[][] createOnes(E[][] matrix,
                                                               int rowSize,
                                                               int columnSize)

  全ての成分が１である行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    全ての成分が１である行列

### conjugateTranspose

    public static final <E extends Scalar<E>> E[][] conjugateTranspose(E[][] matrix)

  共役複素転置行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 元の行列
  戻り値:
    共役複素転置行列

### multiply

    public static final <E extends Scalar<E>> E[][] multiply(E[][] matrix,
                                                             int scalar)

  行列に整数を掛けます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 乗じる整数
  戻り値:
    整数を掛けた結果

### multiply

    public static final <E extends Scalar<E>> E[][] multiply(E[][] matrix,
                                                             double scalar)

  行列に実数を掛けます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 乗じる実数
  戻り値:
    実数を掛けた結果

### multiply

    public static final <E extends Scalar<E>> E[][] multiply(double[][] matrix,
                                                             E scalar)

  実行列とスカラーの積を求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 実行列
    `scalar` - スカラー
  戻り値:
    実行列とスカラーの積

### multiplySelf

    public static final <E extends Scalar<E>> void multiplySelf(E[][] matrix,
                                                                E scalar)

  行列自身に数を掛けます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 乗じる数

### multiplyElementWise

    public static final Scalar<?>[][] multiplyElementWise(Scalar<?>[][] a1,
                                                          Scalar<?>[][] a2)

  成分毎に乗算を行います。

  パラメータ:
    `a1` - 掛けられる行列
    `a2` - 掛ける行列
  戻り値:
    掛けた結果の行列

### divideElementWise

    public static final Scalar<?>[][] divideElementWise(Scalar<?>[][] a1,
                                                        Scalar<?>[][] a2)

  成分毎の割り算の結果を成分とする行列を生成します。

  パラメータ:
    `a1` - 割られる行列
    `a2` - 割る行列
  戻り値:
    割り算の結果

### leftDivideElementWise

    public static final Scalar<?>[][] leftDivideElementWise(Scalar<?>[][] a1,
                                                            Scalar<?>[][] a2)

  成分毎の割り算(左が分母、右が分子)の結果を成分とする行列を生成します。

  パラメータ:
    `a1` - 割る行列
    `a2` - 割られる行列
  戻り値:
    割り算の結果

### roundToZeroElementWise

    public static final <E extends Scalar<E>> E[][] roundToZeroElementWise(E[][] matrix,
                                                                           double tolerance)

  絶対値が小さい成分を0に丸めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `tolerance` - 許容誤差
  戻り値:
    丸められた結果

### isZero

    public static final <E extends Scalar<E>> boolean isZero(E[][] matrix,
                                                             double tolerance)

  零行列か判定します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 調べる行列
    `tolerance` - 許容誤差
  戻り値:
    零行列ならばtrue、そうでなければfalse

### isUnit

    public static final <E extends Scalar<E>> boolean isUnit(E[][] matrix,
                                                             double tolerance)

  単位行列であるか判定します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 調べる行列
    `tolerance` - 許容誤差
  戻り値:
    単位行列ならばtrue、そうでなければfalse

### isNanElementWise

    public static final <E extends Scalar<E>> boolean[][] isNanElementWise(E[][] matrix)

  各成分の非数性の真偽を成分にもつ行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    非数性の真偽行列

### isFiniteElementWise

    public static final <E extends Scalar<E>> boolean[][] isFiniteElementWise(E[][] matrix)

  各成分の有限性の真偽を成分にもつ行列を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    有限性の真偽行列

### isInfiniteElementWise

    public static final <E extends Scalar<E>> boolean[][] isInfiniteElementWise(E[][] matrix)

  各成分の無限性の真偽を成分にもつ行列を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    無限性の真偽行列

### setUnit

    public static final <E extends Scalar<E>> void setUnit(E[][] matrix)

  単位行列に設定します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列

### addElementWise

    public static final Scalar<?>[][] addElementWise(Scalar<?>[][] matrix,
                                                     Scalar<?> scalar)

  行列の全ての成分にスカラーを加えた行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 加える値
  戻り値:
    生成された行列

### addElementWise

    public static final <E extends Scalar<E>> E[][] addElementWise(E[][] matrix,
                                                                   double scalar)

  行列の全ての成分に実数を加えた行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 加える実数
  戻り値:
    生成された行列

### subtractElementWise

    public static final Scalar<?>[][] subtractElementWise(Scalar<?>[][] matrix,
                                                          Scalar<?> scalar)

  行列の全ての成分にスカラーを引いた行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 引く値
  戻り値:
    生成された行列

### subtractElementWise

    public static final <E extends Scalar<E>> E[][] subtractElementWise(E[][] matrix,
                                                                        double scalar)

  行列の全ての成分に実数を引いた行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 引く実数
  戻り値:
    生成された行列

### inverseElementWise

    public static final Scalar<?>[][] inverseElementWise(Scalar<?>[][] matrix)

  行列の全ての成分の逆数を成分とする行列を生成します。

  パラメータ:
    `matrix` - 元の行列
  戻り値:
    成分の逆数を成分とする行列

### multiply

    public static final <E extends Scalar<E>> E[][] multiply(Scalar<?>[][] matrix,
                                                             Scalar<?> scalar)

  行列にスカラーを掛けます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 乗じるスカラー
  戻り値:
    スカラーを掛けた結果

### divide

    public static final Scalar<?>[][] divide(Scalar<?>[][] matrix,
                                             Scalar<?> scalar)

  全ての成分をスカラーで割る。

  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 割るスカラー
  戻り値:
    計算結果

### divide

    public static final <E extends Scalar<E>> E[][] divide(E[][] matrix,
                                                           int scalar)

  行列を整数で割る。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 割る整数
  戻り値:
    整数で割った結果

### divide

    public static final <E extends Scalar<E>> E[][] divide(E[][] matrix,
                                                           double scalar)

  行列を実数で割る。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 割る実数
  戻り値:
    実数で割った結果

### powerElementWise

    public static final <E extends Scalar<E>> E[][] powerElementWise(E[][] matrix,
                                                                     int scalar)

  行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 累乗の対象となる値を成分とする行列
    `scalar` - 累乗の指数
  戻り値:
    生成された行列

### powerElementWise

    public static final <E extends Scalar<E>> E[][] powerElementWise(E[][] a1,
                                                                     int[][] a2)

  行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - 累乗の対象となる値を成分とする行列
    `a2` - 累乗の指数を成分とする行列
  戻り値:
    生成された行列

### powerElementWise

    public static final <E extends Scalar<E>> E[][] powerElementWise(E scalar,
                                                                     int[][] matrix)

  スカラーの累乗を行列の成分毎に計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `scalar` - 累乗されるスカラー
    `matrix` - 累乗の指数を成分とする行列
  戻り値:
    生成された行列

### determinant

    public static final <E extends Scalar<E>> E determinant(E[][] matrix)

  行列式を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行列式

### sum

    public static final <E extends Scalar<E>> E sum(E[][] matrix)

  行列の全ての和を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行列の全ての成分も和

### mean

    public static final <E extends Scalar<E>> E mean(E[][] matrix)

  全ての成分の平均値を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    全ての成分の平均値

### sumColumnWise

    public static final <E extends Scalar<E>> E[][] sumColumnWise(E[][] matrix)

  列毎に全ての成分の和を計算し、計算結果を成分とする行ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする横ベクトル

### sumRowWise

    public static final <E extends Scalar<E>> E[][] sumRowWise(E[][] matrix)

  行毎に全ての成分の和を計算し、計算結果を成分とする列ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする縦ベクトル

### cumulativeSum

    public static final <E extends Scalar<E>> E[][] cumulativeSum(E[][] matrix)

  全ての成分の累積和を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### cumulativeSumRowWise

    public static final <E extends Scalar<E>> E[][] cumulativeSumRowWise(E[][] matrix)

  行毎に累積和を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### cumulativeSumColumnWise

    public static final <E extends Scalar<E>> E[][] cumulativeSumColumnWise(E[][] matrix)

  列毎に累積和を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### cumulativeProduct

    public static final <E extends Scalar<E>> E[][] cumulativeProduct(E[][] matrix)

  全ての成分の累積積を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### cumulativeProductRowWise

    public static final <E extends Scalar<E>> E[][] cumulativeProductRowWise(E[][] matrix)

  行毎に累積積を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### cumulativeProductColumnWise

    public static final <E extends Scalar<E>> E[][] cumulativeProductColumnWise(E[][] matrix)

  列毎に累積積を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行列

### meanRowWise

    public static final <E extends Scalar<E>> E[][] meanRowWise(E[][] matrix)

  行毎に全ての成分の平均値を計算し、計算結果を成分とする列ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする縦ベクトル

### meanColumnWise

    public static final <E extends Scalar<E>> E[][] meanColumnWise(E[][] matrix)

  列毎に全ての成分の平均値を計算し、計算結果を成分とする行ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする横ベクトル

### product

    public static final <E extends Scalar<E>> E product(E[][] matrix)

  行列の全ての成分の積を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行列の全ての成分の積

### productRowWise

    public static final <E extends Scalar<E>> E[][] productRowWise(E[][] matrix)

  行毎に全ての成分の積を計算し、計算結果を成分とする列ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする列ベクトル

### productColumnWise

    public static final <E extends Scalar<E>> E[][] productColumnWise(E[][] matrix)

  列毎に全ての成分の積を計算し、計算結果を成分とする行ベクトルを生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    計算結果を成分とする行ベクトル

### trace

    public static final <E extends Scalar<E>> E trace(E[][] matrix)

  全対角成分の和(トレース)を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    対角成分の合計(トレース)

### covariance

    public static <E extends Scalar<E>> E[][] covariance(E[][] a1,
                                                         E[][] a2)

  共分散行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - データ列1 (行ベクトル又は列ベクトル)
    `a2` - データ列2 (行ベクトル又は列ベクトル)
  戻り値:
    共分散 (Covariance)

### variance

    public static <E extends Scalar<E>> E variance(E[][] matrix)

  分散を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - データ列 (行ベクトル又は列ベクトル)
  戻り値:
    分散

### elementWiseFunction

    public static final Scalar<?>[][] elementWiseFunction(Scalar<?>[][] matrix,
                                                          org.mklab.nfc.matrix.ScalarFunction function)

  成分毎に関数の計算をし、計算結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `function` - 行列成分数関数(引数１個)
  戻り値:
    計算結果を成分とする行列

### elementWiseFunction

    public static final NumericalScalar<?>[][] elementWiseFunction(NumericalScalar<?>[][] matrix,
                                                                   org.mklab.nfc.matrix.NumericalScalarFunction function)

  成分毎に関数の計算をし、計算結果を成分とする行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `function` - 数値行列成分数関数(引数１個)
  戻り値:
    計算結果を成分とする行列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowMin,
                                          int rowMax,
                                          int columnMin,
                                          int columnMax,
                                          Scalar<?>[][] source)

  与えられた位置に行列を代入します。

  パラメータ:
    `destination` - 値を設定する行列
    `rowMin` - 行の始まり
    `rowMax` - 行の終わり
    `columnMin` - 列の始まり
    `columnMax` - 列の終わり
    `source` - 設定する行列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowMin,
                                          int rowMax,
                                          int columnMin,
                                          int columnMax,
                                          int[][] source)

  与えられた位置に行列を代入します。

  パラメータ:
    `destination` - 値を設定する行列
    `rowMin` - 行の始まり
    `rowMax` - 行の終わり
    `columnMin` - 列の始まり
    `columnMax` - 列の終わり
    `source` - 設定する行列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowMin,
                                          int rowMax,
                                          int columnMin,
                                          int columnMax,
                                          double[][] source)

  与えられた位置に行列を代入します。

  パラメータ:
    `destination` - 値を設定する行列
    `rowMin` - 行の始まり
    `rowMax` - 行の終わり
    `columnMin` - 列の始まり
    `columnMax` - 列の終わり
    `source` - 設定する行列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowTo,
                                          int columnTo,
                                          int[][] source,
                                          int rowMin,
                                          int rowMax,
                                          int columnMin,
                                          int columnMax)

  `rowTo`行`columnTo`列を始点として、 グリッド`source`の`rowMin`行から`rowMax`行、 `columnMin`列から`columnMax`列までの値をコピーします。

  パラメータ:
    `destination` - コピー先のグリッド
    `rowTo` - 変更開始行
    `columnTo` - 変更開始列
    `source` - コピー元のグリッド
    `rowMin` - コピー開始行
    `rowMax` - コピー終了行
    `columnMin` - コピー開始列
    `columnMax` - コピー終了列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowTo,
                                          int columnTo,
                                          double[][] source,
                                          int rowMin,
                                          int rowMax,
                                          int columnMin,
                                          int columnMax)

  `rowTo`行`columnTo`列を始点として、 グリッド`source`の`rowMin`行から`rowMax`行、 `columnMin`列から`columnMax`列までの値をコピーします。

  パラメータ:
    `destination` - コピー先のグリッド
    `rowTo` - 変更開始行
    `columnTo` - 変更開始列
    `source` - コピー元のグリッド
    `rowMin` - コピー開始行
    `rowMax` - コピー終了行
    `columnMin` - コピー開始列
    `columnMax` - コピー終了列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int[] rowIndex,
                                          int columnMin,
                                          int columnMax,
                                          int[][] source)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を設定するグリッド
    `rowIndex` - 指定する行を含む指数
    `columnMin` - 列の始まり
    `columnMax` - 列の終り
    `source` - 代入するグリッド

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int[] rowIndex,
                                          int columnMin,
                                          int columnMax,
                                          double[][] soruce)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を設定するグリッド
    `rowIndex` - 指定する行を含む指数
    `columnMin` - 列の始まり
    `columnMax` - 列の終り
    `soruce` - 代入するグリッド

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowMin,
                                          int rowMax,
                                          int[] columnIndex,
                                          int[][] source)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を代入するグリッド
    `rowMin` - 行の始まり
    `rowMax` - 行の終り
    `columnIndex` - 指定する列を含む指数
    `source` - 代入するグリッド

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int rowMin,
                                          int rowMax,
                                          int[] columnIndex,
                                          double[][] source)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を代入するグリッド
    `rowMin` - 行の始まり
    `rowMax` - 行の終り
    `columnIndex` - 指定する列を含む指数
    `source` - 代入するグリッド

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int[] rowIndex,
                                          int[] columnIndex,
                                          int[][] source)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を代入する行列
    `rowIndex` - 指定する行を含む指数
    `columnIndex` - 指定する列を含む指数
    `source` - 代入する行列

### setSubMatrix

    public static final void setSubMatrix(Scalar<?>[][] destination,
                                          int[] rowIndex,
                                          int[] columnIndex,
                                          double[][] source)

  指定された場所に値を代入します。

  パラメータ:
    `destination` - 値を代入する行列
    `rowIndex` - 指定する行を含む指数
    `columnIndex` - 指定する列を含む指数
    `source` - 代入する行列

### setSubVector

    public static final void setSubVector(Scalar<?>[] destination,
                                          int min,
                                          int max,
                                          int[] source)

  配列`destination`の`min`から`max`まで 配列`source`の値をコピーします。

  パラメータ:
    `destination` - コピー先
    `min` - コピー先の開始番号
    `max` - コピー先の終了番号
    `source` - コピー元

### setSubVector

    public static final void setSubVector(Scalar<?>[] destination,
                                          int min,
                                          int max,
                                          double[] source)

  配列`destination`の`min`から`max`まで 配列`source`の値をコピーします。

  パラメータ:
    `destination` - コピー先
    `min` - コピー先の開始番号
    `max` - コピー先の終了番号
    `source` - コピー元

### setElements

    public static final void setElements(Scalar<?>[][] destination,
                                         int[] index,
                                         int[][] source)

  指定された番号の成分に値を代入します。

  パラメータ:
    `destination` - 値を設定するグリッド
    `index` - 指定する成分番号を含む指数
    `source` - 代入するグリッド

### setElements

    public static final void setElements(Scalar<?>[][] destination,
                                         int[] index,
                                         double[][] source)

  指定された番号の成分に値を代入します。

  パラメータ:
    `destination` - 値を設定するグリッド
    `index` - 指定する成分番号を含む指数
    `source` - 代入するグリッド

### isComplex

    public static boolean isComplex(Scalar<?>[][] matrix)

  複素数成分をもつか判定します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    複素数成分をもつならばtrue、そうでなければfalse

### getRealPartElements

    public static Scalar<?>[][] getRealPartElements(Scalar<?>[][] matrix)

  実部の2次元配列を返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    実部の2次元配列

### getImagPartElements

    public static Scalar<?>[][] getImagPartElements(Scalar<?>[][] matrix)

  虚部の2次元配列を返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    虚部の2次元配列

### setRealPartElements

    public static void setRealPartElements(Scalar<?>[][] matrix,
                                           int[][] realPart)

  実部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `realPart` - 変更値

### setImagPartElements

    public static void setImagPartElements(Scalar<?>[][] matrix,
                                           int[][] imagPart)

  虚部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `imagPart` - 変更値

### setRealPartElements

    public static void setRealPartElements(Scalar<?>[][] matrix,
                                           double[][] realPart)

  実部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `realPart` - 変更値

### setImagPartElements

    public static void setImagPartElements(Scalar<?>[][] matrix,
                                           double[][] imagPart)

  虚部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `imagPart` - 変更値

### setRealPartElements

    public static void setRealPartElements(Scalar<?>[][] matrix,
                                           Scalar<?>[][] realPart)

  実部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `realPart` - 変更値

### setImagPartElements

    public static void setImagPartElements(Scalar<?>[][] matrix,
                                           Scalar<?>[][] imagPart)

  虚部を設定します。

  パラメータ:
    `matrix` - 対象となる行列
    `imagPart` - 変更値

### toComplexElements

    public static Scalar<?>[][] toComplexElements(Scalar<?>[][] matrix)

  複素成分の2次元配列を返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    複素成分の2次元配列

### anyZero

    public static <E extends Scalar<E>> boolean anyZero(E[][] matrix,
                                                        double tolerance)

  少なくとも1個は絶対値が許容誤差以下である成分が行列に含まれるか判定します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 判定する対象の行列
    `tolerance` - 許容誤差
  戻り値:
    少なくとも1個は絶対値が許容誤差以下である成分があればtrue、そうでなければfalse

### anyZero

    public static <E extends Scalar<E>> boolean anyZero(E[] vector,
                                                        double tolerance)

  少なくとも1個は絶対値が許容誤差以下である成分がベクトルに含まれるか判定します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `vector` - 判定する対象のベクトル
    `tolerance` - 許容誤差
  戻り値:
    少なくとも1個は絶対値が許容誤差以下である成分があればtrue、そうでなければfalse

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