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

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

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

    public class NumericalMatrixUtil

extends Object

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

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

コンストラクタの概要
`NumericalMatrixUtil()`

メソッドの概要
`static NumericalScalar<?>[][]` | `absElementWise(NumericalScalar<?>[][] matrix)` 全ての成分の絶対値を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `argumentElementWise(NumericalScalar<?>[][] matrix)` 自身の各成分の偏角を成分に持つ行列を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `atan2ElementWise(E[][] a1, double[][] a2)` 行列の成分毎に逆正接(2)を計算し、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `atan2ElementWise(NumericalScalar<?>[][] a1, NumericalScalar<?>[][] a2)` 行列の成分毎に逆正接(2)を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> ComplexScalar<E>[][]`
` | `createComplexArray(E[][] rePart, E[][] imPart)` 複素行列の成分を返します。
`static
`<E extends NumericalScalar<E>> ComplexScalar<E>[]`
` | `createComplexArray(E[] rePart, E[] imPart)` 複素ベクトルの成分を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `createNormalRandom(E[][] matrix, int rowSize, int columnSize)` 平均0、分散1の正規分布の乱数を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `createNormalRandom(E[][] matrix, int rowSize, int columnSize, long seed)` 平均0、分散1の正規分布の乱数を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `createUniformRandom(E[][] matrix, int rowSize, int columnSize)` 0〜1の範囲の一様分布の乱数を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `createUniformRandom(E[][] matrix, int rowSize, int columnSize, long seed)` 0〜1の範囲の一様分布の乱数を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `elementWiseFunction(E[][] matrix, org.mklab.nfc.matrix.NumericalScalarFunction<E> function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `elementWiseFunction(NumericalScalar<?>[][] matrix1, NumericalScalar<?>[][] matrix2, org.mklab.nfc.matrix.NumericalScalarFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `elementWiseFunction(NumericalScalar<?>[][] matrix1, NumericalScalar<?> value, org.mklab.nfc.matrix.NumericalScalarFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static boolean` | `equals(NumericalScalar<?>[][] a1, NumericalScalar<?>[][] a2, NumericalScalar<?> tolerance)` 2個の配列の成分が全て等しか判定します。
`static
`<E extends NumericalScalar<E>> E`
` | `frobNorm(E[][] matrixRe, E[][] matrixIm)` 複素行列のフロベニウスノルムを返します。
`static NumericalScalar<?>` | `frobNorm(NumericalScalar<?>[][] matrix)` 行列のフロベニウスノムルを返します。
`static NumericalScalar<?>[][]` | `frobNormColumnWise(NumericalScalar<?>[][] matrix)` 列毎のフロベニウスノムルを成分とする行ベクトル返します。
`static NumericalScalar<?>[][]` | `frobNormRowWise(NumericalScalar<?>[][] matrix)` 行毎のフロベニウスノムルを成分とする列ベクトル返します。
`static int[]` | `indexOfMaximum(NumericalScalar<?>[][] matrix)` 最大成分の行番号(1から始まります)と列番号(1から始まります)を求めます。
`static int[]` | `indexOfMinimum(NumericalScalar<?>[][] matrix)` 最小成分の行番号(1から始まります)と列番号(1から始まります)を返します。
`static NumericalScalar<?>` | `infNorm(NumericalScalar<?>[][] matrix)` 行列の無限大ノルムを返します。
`static
`<E extends NumericalScalar<E>> boolean`
` | `isUnit(E[][] matrix, NumericalScalar<?> tolerance)` 単位行列であるか判定します。
`static
`<E extends NumericalScalar<E>> boolean`
` | `isZero(E[][] matrix, NumericalScalar<?> tolerance)` 零行列か判定します。
`static
`<E extends NumericalScalar<E>> E`
` | `max(E[] matrix)` ベクトルの最大成分を返します。
`static
`<E extends NumericalScalar<E>> E`
` | `max(E[][] matrix)` 行列の最大成分を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `maxColumnWise(E[][] matrix)` 列毎に最大値を計算し、計算結果を成分とする列ベクトルを生成します。
`static NumericalScalar<?>[][]` | `maxElementWise(NumericalScalar<?>[][] a1, NumericalScalar<?>[][] a2)` 成分毎に大きさを比較し、大きい方を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `maximum(E[][] matrix)` 最大成分とその行番号(1から始まります)と列番号(1から始まります)を求めます。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `maximumColumnWise(E[][] matrix)` 列毎の最大成分とその指数を返します。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `maximumRowWise(E[][] matrix)` 行毎の最大成分とその指数を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `maxRowWise(E[][] matrix)` 行毎に最大値を計算し、計算結果を成分とする列ベクトルを生成します。
`static
`<E extends NumericalScalar<E>> E`
` | `median(E[][] matrix)` 全ての成分の中間値(メジアン)を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `medianColumnWise(E[][] matrix)` 列毎のメジアンを成分とする行ベクトルを返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `medianRowWise(E[][] matrix)` 行毎のメジアンを成分とする列ベクトルを返します。
`static
`<E extends NumericalScalar<E>> E`
` | `min(E[] matrix)` ベクトルの最小成分を返します。
`static
`<E extends NumericalScalar<E>> E`
` | `min(E[][] matrix)` 行列の最小成分を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `minColumnWise(E[][] matrix)` 列毎に最小値を計算し、計算結果を成分とする列ベクトルを生成します。
`static NumericalScalar<?>[][]` | `minElementWise(NumericalScalar<?>[][] a1, NumericalScalar<?>[][] a2)` 成分毎に大きさを比較し、小さい方を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `minimum(E[][] matrix)` 最小成分と行番号(1から始まります)と列番号(1から始まります)を返します。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `minimumColumnWise(E[][] matrix)` 列毎に最小成分とその指数を返します。
`static
`<E extends NumericalScalar<E>> Object[]`
` | `minimumRowWise(E[][] matrix)` 行毎の最小成分とその指数を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `minRowWise(E[][] matrix)` 行毎に最小値を計算し、計算結果を成分とする行ベクトルを生成します。
`static
`<E extends NumericalScalar<E>> E[][][]`
` | `multiply(E[][] aRe, E[][] aIm, E[][] bRe, E[][] bIm)` 複素行列と複素行列の積を返します。
`static
`<E extends NumericalScalar<E>> E[][][]`
` | `multiply(E[][] matrixRe, E[][] matrixIm, E valueRe, E valueIm)` 行列に複素数を掛けた行列を生成します。
`static
`<E extends NumericalScalar<E>> void`
` | `multiplySelf(E[][] matrixRe, E[][] matrixIm, E scalar)` 行列に実数を乗じます。
`static
`<E extends NumericalScalar<E>> void`
` | `multiplySelf(E[][] matrixRe, E[][] matrixIm, E valueRe, E valueIm)` 行列に複素数を乗じます。
`static
`<E extends NumericalScalar<E>> NumericalScalar<?>`
` | `norm(E[][] matrix, NormType type)` 行列のノルムを返します。
`static NumericalScalar<?>[][]` | `powerElementWise(double[][] matrix, NumericalScalar<?> scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `powerElementWise(E[][] matrix, double scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `powerElementWise(E[][] a1, double[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `powerElementWise(E scalar, double[][] matrix)` スカラーの累乗を実行列の成分毎に求めます。
`static NumericalScalar<?>[][]` | `powerElementWise(int[][] matrix, NumericalScalar<?> scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `powerElementWise(NumericalScalar<?>[][] matrix, NumericalScalar<?> scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `powerElementWise(NumericalScalar<?>[][] a1, NumericalScalar<?>[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static NumericalScalar<?>[][]` | `powerElementWise(NumericalScalar<?> scalar, NumericalScalar<?>[][] matrix)` スカラーの累乗を複素行列の成分毎に求めます。
`static
`<E extends NumericalScalar<E>> void`
` | `quickSort(E[] vector, int[] index, int start, int end)` ベクトルの成分を昇順にソートした結果を返します。
`static
`<E extends ComplexScalar<?>> void`
` | `quickSortByImagPart(E[] vector, int[] index, int start, int end)` ベクトルの成分を虚部の昇順にソートした結果を返します。
`static
`<E extends ComplexScalar<?>> void`
` | `quickSortByRealPart(E[] vector, int[] index, int start, int end)` ベクトルの成分を実部の昇順にソートした結果を返します。
`static
`<E extends Scalar<E>> E[][]`
` | `roundToZeroElementWise(E[][] matrix, NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `signumElementWise(E[][] matrix)` 自身の各成分の(x/abs(x)を成分に持つ行列を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `sortColumnWise(E[][] matrix)` 列毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。
`static
`<E extends NumericalScalar<E>> org.mklab.nfc.matrix.IndexedElements<E>`
` | `sortColumnWiseWithIndex(E[][] matrix)` 列毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `sortRowWise(E[][] matrix)` 行毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。
`static
`<E extends NumericalScalar<E>> org.mklab.nfc.matrix.IndexedElements<E>`
` | `sortRowWiseWithIndex(E[][] matrix)` 行毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。
`static
`<E extends NumericalScalar<E>> E`
` | `std(E[][] matrix)` 行列の全ての成分の標準偏差を求めます。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `stdColumnWise(E[][] matrix)` 列毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。
`static
`<E extends NumericalScalar<E>> E[][]`
` | `stdRowWise(E[][] matrix)` 行毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。

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

コンストラクタの詳細

### NumericalMatrixUtil

    public NumericalMatrixUtil()

メソッドの詳細

### medianColumnWise

    public static <E extends NumericalScalar<E>> E[][] medianColumnWise(E[][] matrix)

  列毎のメジアンを成分とする行ベクトルを返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    中間値(メジアン)

### medianRowWise

    public static <E extends NumericalScalar<E>> E[][] medianRowWise(E[][] matrix)

  行毎のメジアンを成分とする列ベクトルを返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    中間値(メジアン)

### median

    public static <E extends NumericalScalar<E>> E median(E[][] matrix)

  全ての成分の中間値(メジアン)を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    全ての成分の中間値(メジアン)

### sortRowWiseWithIndex

    public static final <E extends NumericalScalar<E>> org.mklab.nfc.matrix.IndexedElements<E> sortRowWiseWithIndex(E[][] matrix)

  行毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行毎に昇順に並び替えた行列と元の位置を示す指数

### sortRowWise

    public static final <E extends NumericalScalar<E>> E[][] sortRowWise(E[][] matrix)

  行毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行毎に昇順に並び替えた行列と元の位置を示す指数

### sortColumnWiseWithIndex

    public static final <E extends NumericalScalar<E>> org.mklab.nfc.matrix.IndexedElements<E> sortColumnWiseWithIndex(E[][] matrix)

  列毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列毎に昇順に並び替えた行列と元の位置を示す指数

### sortColumnWise

    public static final <E extends NumericalScalar<E>> E[][] sortColumnWise(E[][] matrix)

  列毎に昇順に並び替えた(絶対値でソートした)行列と元の位置を示す指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列毎に昇順に並び替えた行列と元の位置を示す指数

### stdRowWise

    public static final <E extends NumericalScalar<E>> E[][] stdRowWise(E[][] matrix)

  行毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。

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

### stdColumnWise

    public static final <E extends NumericalScalar<E>> E[][] stdColumnWise(E[][] matrix)

  列毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。

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

### std

    public static final <E extends NumericalScalar<E>> E std(E[][] matrix)

  行列の全ての成分の標準偏差を求めます。

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

### absElementWise

    public static NumericalScalar<?>[][] absElementWise(NumericalScalar<?>[][] matrix)

  全ての成分の絶対値を成分とする行列を生成します。

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

### argumentElementWise

    public static NumericalScalar<?>[][] argumentElementWise(NumericalScalar<?>[][] matrix)

  自身の各成分の偏角を成分に持つ行列を返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    偏角行列

### frobNorm

    public static final NumericalScalar<?> frobNorm(NumericalScalar<?>[][] matrix)

  行列のフロベニウスノムルを返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行列のフロベニウスノムル

### frobNormRowWise

    public static final NumericalScalar<?>[][] frobNormRowWise(NumericalScalar<?>[][] matrix)

  行毎のフロベニウスノムルを成分とする列ベクトル返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行毎のフロベニウスノムルを成分とする列ベクトル

### frobNormColumnWise

    public static final NumericalScalar<?>[][] frobNormColumnWise(NumericalScalar<?>[][] matrix)

  列毎のフロベニウスノムルを成分とする行ベクトル返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列毎のフロベニウスノムルを成分とする行ベクトル

### frobNorm

    public static final <E extends NumericalScalar<E>> E frobNorm(E[][] matrixRe,
                                                                  E[][] matrixIm)

  複素行列のフロベニウスノルムを返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrixRe` - 実部行列
    `matrixIm` - 虚部行列
  戻り値:
    フロベニウスノルム

### infNorm

    public static final NumericalScalar<?> infNorm(NumericalScalar<?>[][] matrix)

  行列の無限大ノルムを返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行列の無限大ノルム

### max

    public static final <E extends NumericalScalar<E>> E max(E[][] matrix)

  行列の最大成分を返します。

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

### max

    public static final <E extends NumericalScalar<E>> E max(E[] matrix)

  ベクトルの最大成分を返します。

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

### min

    public static final <E extends NumericalScalar<E>> E min(E[][] matrix)

  行列の最小成分を返します。

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

### min

    public static final <E extends NumericalScalar<E>> E min(E[] matrix)

  ベクトルの最小成分を返します。

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

### maxElementWise

    public static final NumericalScalar<?>[][] maxElementWise(NumericalScalar<?>[][] a1,
                                                              NumericalScalar<?>[][] a2)

  成分毎に大きさを比較し、大きい方を成分とする行列を生成します。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列
  戻り値:
    生成された行列

### minElementWise

    public static final NumericalScalar<?>[][] minElementWise(NumericalScalar<?>[][] a1,
                                                              NumericalScalar<?>[][] a2)

  成分毎に大きさを比較し、小さい方を成分とする行列を生成します。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列
  戻り値:
    生成された行列

### powerElementWise

    public static final <E extends NumericalScalar<E>> E[][] powerElementWise(E[][] matrix,
                                                                              double scalar)

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

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

### powerElementWise

    public static final NumericalScalar<?>[][] powerElementWise(NumericalScalar<?>[][] matrix,
                                                                NumericalScalar<?> scalar)

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

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

### powerElementWise

    public static final NumericalScalar<?>[][] powerElementWise(int[][] matrix,
                                                                NumericalScalar<?> scalar)

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

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

### powerElementWise

    public static final NumericalScalar<?>[][] powerElementWise(double[][] matrix,
                                                                NumericalScalar<?> scalar)

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

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

### powerElementWise

    public static final <E extends NumericalScalar<E>> E[][] powerElementWise(E[][] a1,
                                                                              double[][] a2)

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

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

### powerElementWise

    public static final NumericalScalar<?>[][] powerElementWise(NumericalScalar<?>[][] a1,
                                                                NumericalScalar<?>[][] a2)

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

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

### maxRowWise

    public static final <E extends NumericalScalar<E>> E[][] maxRowWise(E[][] matrix)

  行毎に最大値を計算し、計算結果を成分とする列ベクトルを生成します。

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

### maxColumnWise

    public static final <E extends NumericalScalar<E>> E[][] maxColumnWise(E[][] matrix)

  列毎に最大値を計算し、計算結果を成分とする列ベクトルを生成します。

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

### minRowWise

    public static final <E extends NumericalScalar<E>> E[][] minRowWise(E[][] matrix)

  行毎に最小値を計算し、計算結果を成分とする行ベクトルを生成します。

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

### minColumnWise

    public static final <E extends NumericalScalar<E>> E[][] minColumnWise(E[][] matrix)

  列毎に最小値を計算し、計算結果を成分とする列ベクトルを生成します。

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

### maximum

    public static final <E extends NumericalScalar<E>> Object[] maximum(E[][] matrix)

  最大成分とその行番号(1から始まります)と列番号(1から始まります)を求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    最大成分とその行番号(1から始まります)と列番号(1から始まります)

### indexOfMaximum

    public static final int[] indexOfMaximum(NumericalScalar<?>[][] matrix)

  最大成分の行番号(1から始まります)と列番号(1から始まります)を求めます。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    最大成分の行番号(1から始まります)と列番号(1から始まります)

### maximumRowWise

    public static final <E extends NumericalScalar<E>> Object[] maximumRowWise(E[][] matrix)

  行毎の最大成分とその指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行毎の最大成分とその指数

### maximumColumnWise

    public static final <E extends NumericalScalar<E>> Object[] maximumColumnWise(E[][] matrix)

  列毎の最大成分とその指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列毎の最大成分とその指数

### minimum

    public static final <E extends NumericalScalar<E>> Object[] minimum(E[][] matrix)

  最小成分と行番号(1から始まります)と列番号(1から始まります)を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    最小成分とその行番号(1から始まります)と列番号(1から始まります)

### indexOfMinimum

    public static final int[] indexOfMinimum(NumericalScalar<?>[][] matrix)

  最小成分の行番号(1から始まります)と列番号(1から始まります)を返します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    最小成分の行番号(1から始まります)と列番号(1から始まります)

### minimumRowWise

    public static final <E extends NumericalScalar<E>> Object[] minimumRowWise(E[][] matrix)

  行毎の最小成分とその指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    行毎の最小成分とその指数

### minimumColumnWise

    public static final <E extends NumericalScalar<E>> Object[] minimumColumnWise(E[][] matrix)

  列毎に最小成分とその指数を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列毎の最小成分とその指数

### signumElementWise

    public static <E extends NumericalScalar<E>> E[][] signumElementWise(E[][] matrix)

  自身の各成分の(x/abs(x)を成分に持つ行列を返します。

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

### powerElementWise

    public static final <E extends NumericalScalar<E>> E[][] powerElementWise(E scalar,
                                                                              double[][] matrix)

  スカラーの累乗を実行列の成分毎に求めます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `scalar` - 累乗の対象となるスカラー
    `matrix` - 実行列(累乗の指数を成分とする)
  戻り値:
    スカラーの累乗を成分とする行列

### powerElementWise

    public static final NumericalScalar<?>[][] powerElementWise(NumericalScalar<?> scalar,
                                                                NumericalScalar<?>[][] matrix)

  スカラーの累乗を複素行列の成分毎に求めます。

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

### quickSort

    public static final <E extends NumericalScalar<E>> void quickSort(E[] vector,
                                                                      int[] index,
                                                                      int start,
                                                                      int end)

  ベクトルの成分を昇順にソートした結果を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `vector` - 対象となるベクトル
    `index` - 並び替えた成分の番号を記憶する配列
    `start` - ソートの対象となる成分の開始番号
    `end` - ソートの対象となる成分の終了番号

### quickSortByImagPart

    public static final <E extends ComplexScalar<?>> void quickSortByImagPart(E[] vector,
                                                                              int[] index,
                                                                              int start,
                                                                              int end)

  ベクトルの成分を虚部の昇順にソートした結果を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `vector` - 対象となるベクトル
    `index` - 並び替えた成分の番号を記憶する配列
    `start` - ソートの対象となる成分の開始番号
    `end` - ソートの対象となる成分の終了番号

### quickSortByRealPart

    public static final <E extends ComplexScalar<?>> void quickSortByRealPart(E[] vector,
                                                                              int[] index,
                                                                              int start,
                                                                              int end)

  ベクトルの成分を実部の昇順にソートした結果を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `vector` - 対象となるベクトル
    `index` - 並び替えた成分の番号を記憶する配列
    `start` - ソートの対象となる成分の開始番号
    `end` - ソートの対象となる成分の終了番号

### atan2ElementWise

    public static final <E extends NumericalScalar<E>> E[][] atan2ElementWise(E[][] a1,
                                                                              double[][] a2)

  行列の成分毎に逆正接(2)を計算し、計算結果を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `a1` - 分子側の値を成分とする行列
    `a2` - 分母側の値を成分とする行列
  戻り値:
    生成された行列

### atan2ElementWise

    public static final NumericalScalar<?>[][] atan2ElementWise(NumericalScalar<?>[][] a1,
                                                                NumericalScalar<?>[][] a2)

  行列の成分毎に逆正接(2)を計算し、計算結果を成分とする行列を生成します。

  パラメータ:
    `a1` - 分子側の値を成分とする行列
    `a2` - 分母側の値を成分とする行列
  戻り値:
    生成された行列

### elementWiseFunction

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

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

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

### elementWiseFunction

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

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

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

### elementWiseFunction

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

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

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

### norm

    public static final <E extends NumericalScalar<E>> NumericalScalar<?> norm(E[][] matrix,
                                                                               NormType type)

  行列のノルムを返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `type` - ノルムの種類(NormType.ONE:1ノルム、NormType.TWO:2ノルム(最大特異値))
  戻り値:
    行列のノルム

### createComplexArray

    public static final <E extends NumericalScalar<E>> ComplexScalar<E>[][] createComplexArray(E[][] rePart,
                                                                                               E[][] imPart)

  複素行列の成分を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `rePart` - 実部
    `imPart` - 虚部
  戻り値:
    複素行列の成分

### createComplexArray

    public static final <E extends NumericalScalar<E>> ComplexScalar<E>[] createComplexArray(E[] rePart,
                                                                                             E[] imPart)

  複素ベクトルの成分を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `rePart` - 実部
    `imPart` - 虚部
  戻り値:
    複素ベクトルの成分

### equals

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

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

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

### roundToZeroElementWise

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

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

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

### isZero

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

  零行列か判定します。

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

### isUnit

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

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

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

### createUniformRandom

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

  0〜1の範囲の一様分布の乱数を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    一様分布の乱数を成分とする行列

### createUniformRandom

    public static final <E extends NumericalScalar<E>> E[][] createUniformRandom(E[][] matrix,
                                                                                 int rowSize,
                                                                                 int columnSize,
                                                                                 long seed)

  0〜1の範囲の一様分布の乱数を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 乱数の種
  戻り値:
    一様分布の乱数を成分とする行列

### createNormalRandom

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

  平均0、分散1の正規分布の乱数を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    平均0、分散1の正規分布の乱数を成分とする行列

### createNormalRandom

    public static final <E extends NumericalScalar<E>> E[][] createNormalRandom(E[][] matrix,
                                                                                int rowSize,
                                                                                int columnSize,
                                                                                long seed)

  平均0、分散1の正規分布の乱数を成分とする行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrix` - 対象となる行列
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 乱数の種
  戻り値:
    平均0、分散1の正規分布の乱数を成分とする行列

### multiplySelf

    public static final <E extends NumericalScalar<E>> void multiplySelf(E[][] matrixRe,
                                                                         E[][] matrixIm,
                                                                         E valueRe,
                                                                         E valueIm)

  行列に複素数を乗じます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrixRe` - 対象となる行列の実部
    `matrixIm` - 対象となる行列の虚部
    `valueRe` - 複素数の実部
    `valueIm` - 複素数の虚部

### multiply

    public static final <E extends NumericalScalar<E>> E[][][] multiply(E[][] matrixRe,
                                                                        E[][] matrixIm,
                                                                        E valueRe,
                                                                        E valueIm)

  行列に複素数を掛けた行列を生成します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrixRe` - 対象となる行列の実部
    `matrixIm` - 対象となる行列の虚部
    `valueRe` - 複素数の虚部
    `valueIm` - 複素数の実部
  戻り値:
    生成された行列

### multiply

    public static final <E extends NumericalScalar<E>> E[][][] multiply(E[][] aRe,
                                                                        E[][] aIm,
                                                                        E[][] bRe,
                                                                        E[][] bIm)

  複素行列と複素行列の積を返します。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `aRe` - 第一行列の実部
    `aIm` - 第一行列の虚部
    `bRe` - 第二行列の実部
    `bIm` - 第二行列の虚部
  戻り値:
    複素行列と複素行列の積

### multiplySelf

    public static final <E extends NumericalScalar<E>> void multiplySelf(E[][] matrixRe,
                                                                         E[][] matrixIm,
                                                                         E scalar)

  行列に実数を乗じます。

  型パラメータ:
    `E` - 成分の型
  パラメータ:
    `matrixRe` - 対象となる行列の実部
    `matrixIm` - 対象となる行列の虚部
    `scalar` - 実数

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