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

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

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

    public final class DoubleMatrixUtil

extends Object

倍精度(double)型の実行列のユーティリティクラスです。

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

メソッドの概要
`static double[][]` | `absElementWise(double[][] matrix)` 全ての成分の絶対値を成分とする行列を生成します。
`static double[][]` | `add(double[][] a1, double[][] a2)` 行列の和行列を生成します。
`static double[][]` | `addElementWise(double[][] matrix, double scalar)` 行列の全ての成分に実数を加えた行列を生成します。
`static double[]` | `addElementWise(double[] vector, double scalar)` ベクトル全ての成分に実数を加えたベクトルを生成します。
`static void` | `addSelf(double[][] a1, double[][] a2)` 第1行列に第2行列を加えます。
`static boolean` | `anyZero(double[] vector)` 少なくとも1個は零の成分がベクトルに含まれるか判定します。
`static boolean` | `anyZero(double[][] matrix)` 少なくとも1個は零の成分が行列に含まれるか判定します。
`static boolean` | `anyZero(double[][] matrix, double tolerance)` 少なくとも1個は絶対値が許容誤差以下である成分が行列に含まれるか判定します。
`static boolean` | `anyZero(double[] vector, double tolerance)` 少なくとも1個は絶対値が許容誤差以下である成分がベクトルに含まれるか判定します。
`static double[][]` | `appendDown(double[][] a1, double[][] a2)` 2個の行列を縦に接続した行列を生成します。
`static double[][]` | `appendRight(double[][] a1, double[][] a2)` 2個の行列を横に接続した行列を生成します。
`static double[][]` | `appendRight(double[] a1, double[][] a2)` ベクトルの右側に行列を接続した行列を生成します。
`static double[]` | `clone(double[] vector)` ベクトルの複製を生成します。
`static double[][]` | `clone(double[][] matrix)` 行列の複製を生成します。
`static boolean[][]` | `compareElements(double[][] matrix, String operator, double opponent)` 各成分とvalueをoperatorで指定された演算子で比較し、 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(double[][] a1, String operator, double[][] a2)` 2個の行列を成分毎にoperatorで指定された演算子で比較し、 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(double[][] a1, String operator, int[][] a2)` 2個の行列を成分毎にoperatorで指定された演算子で比較し、 計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(double[][] matrix, String operator, Scalar<?> opponent)` 各成分とvalueをoperatorで指定された演算子で比較し、 計算結果を成分とする行列を生成します。
`static void` | `copy(double[][] source, double[][] destination)` 行列の成分をコピーします。
`static void` | `copy(double[] source, double[] destination)` 行列の成分をコピーします。
`static void` | `copy(int[][] source, double[][] destination)` 行列の成分をコピーします。
`static void` | `copy(int[] source, double[] destination)` 行列の成分をコピーします。
`static double[][]` | `covariance(double[][] a1, double[][] a2)` 共分散行列を生成します。
`static double[][]` | `createArray(int[][] matrix)` 整数行列を実数行列に変換します。
`static double[][]` | `createNormalRandom(int rowSize, int columnSize)` 平均0、分散1の正規分布の乱数を成分とする行列を生成します。
`static double[][]` | `createNormalRandom(int rowSize, int columnSize, long seed)` 平均0、分散1の正規分布の乱数を成分とする行列を生成します。
`static double[][]` | `createOnes(int rowSize, int columnSize)` 全ての成分が1である行列を生成します。
`static double[][]` | `createUniformRandom(int rowSize, int columnSize)` 0〜1の範囲の一様分布の乱数を成分とする行列を生成します。
`static double[][]` | `createUniformRandom(int rowSize, int columnSize, long seed)` 0〜1の範囲の一様分布の乱数を成分とする行列を生成します。
`static double[][]` | `createUnit(int rowSize, int columnSize)` 単位行列を生成します。
`static double[][]` | `cumulativeProduct(double[][] matrix)` 全ての成分の累積積を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `cumulativeProductColumnWise(double[][] matrix)` 列毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `cumulativeProductRowWise(double[][] matrix)` 行毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `cumulativeSum(double[][] matrix)` 全ての成分の累積和を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `cumulativeSumColumnWise(double[][] matrix)` 列毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `cumulativeSumRowWise(double[][] matrix)` 行毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static double[]` | `decrement(double[] vector)` 全ての成分を1だけ減少させたベクトルを生成します。
`static double[][]` | `decrement(double[][] matrix)` 全ての成分を1だけ減少させた行列を生成します。
`static double[][]` | `diagonalToVector(double[][] matrix)` 対角成分からなる縦ベクトルを生成します。
`static double[][]` | `divide(double[][] matrix, double scalar)` 成分を実数で割った値を成分とする行列を生成します。
`static double[][]` | `divide(double[][] matrix, int scalar)` 成分を整数で割った値を成分とする行列を生成します。
`static double[]` | `divide(double[] vector, double scalar)` 成分を実数で割った値を成分とする行列を生成します。
`static double[][]` | `divideElementWise(double[][] a1, double[][] a2)` 成分毎の割り算の結果を成分とする行列を生成します。
`static boolean[][]` | `elementWiseFunction(double[][] matrix, org.mklab.nfc.matrix.BooleanFunction function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static boolean[][]` | `elementWiseFunction(double[][] a1, double[][] a2, org.mklab.nfc.matrix.BooleanFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static double[][]` | `elementWiseFunction(double[][] a1, double[][] a2, org.mklab.nfc.matrix.DoubleRealFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static boolean[][]` | `elementWiseFunction(double[][] matrix, double d2, org.mklab.nfc.matrix.BooleanFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static double[][]` | `elementWiseFunction(double[][] matrix, double d2, org.mklab.nfc.matrix.DoubleRealFunctionWithTwoArguments function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static double[][]` | `elementWiseFunction(double[][] matrix, org.mklab.nfc.matrix.DoubleRealFunction function)` 成分毎に関数の計算をし、計算結果を成分とする行列を生成します。
`static boolean` | `equals(double[][] a1, double[][] a2)` 2個の配列の成分が全て等しか判定します。
`static boolean` | `equals(double[][] a1, double[][] a2, double tolerance)` 2個の配列の成分の差の絶対値が許容誤差以下であるか判定します。
`static boolean` | `equals(double[] a1, double[] a2)` 2個の配列の成分が全て等しか判定します。
`static boolean` | `equals(double[] a1, double[] a2, double tolerance)` 2個の配列の成分の差の絶対値が許容誤差以下であるか判定します。
`static void` | `exchangeColumn(double[][] matrix, int column1, int column2)` column1列とcolumn2列を入れ替えます。
`static void` | `exchangeRow(double[][] matrix, int row1, int row2)` row1行とrow2行を入れ替えます。
`static double` | `frobNorm(double[][] matrix)` 行列のフロベニウスノムルを返します。
`static double[][]` | `frobNormColumnWise(double[][] matrix)` 列毎のフロベニウスノムルを成分とする行ベクトルを返します。
`static double[][]` | `frobNormRowWise(double[][] matrix)` 行毎のフロベニウスノムルを成分とする列ベクトルを返します。
`static double[][]` | `getSubMatrix(double[][] matrix, int[] rowIndex, int column)` 部分行列を生成します。
`static double[][]` | `getSubMatrix(double[][] matrix, int[] rowIndex, int[] columnIndex)` 部分行列を生成します。
`static double[][]` | `getSubMatrix(double[][] matrix, int[] rowIndex, int columnMin, int columnMax)` 部分行列を生成します。
`static double[][]` | `getSubMatrix(double[][] matrix, int row, int[] columnIndex)` 部分行列を生成します。
`static double[][]` | `getSubMatrix(double[][] matrix, int rowMin, int rowMax, int[] columnIndex)` 部分行列を生成します。
`static double[][]` | `getSubMatrix(double[][] matrix, int rowMin, int rowMax, int columnMin, int columnMax)` 部分行列を生成します。
`static double[]` | `getSubVector(double[] vector, int[] index)` 部分ベクトルを生成します。
`static double[]` | `getSubVector(double[] vector, int rowMin, int rowMax)` 部分ベクトルを生成します。
`static double[]` | `increment(double[] vector)` 全ての成分を1だけ増加させたベクトルを生成します。
`static double[][]` | `increment(double[][] matrix)` 全ての成分を1だけ増加させた行列を生成します。
`static int[]` | `indexOfMaximum(double[][] matrix)` 最大成分の指数を求めます。
`static int[]` | `indexOfMinimum(double[][] matrix)` 最小成分の指数を返します。
`static double` | `infNorm(double[][] matrix)` 行列の無限大ノルムを返します。
`static double[][]` | `inverseElementWise(double[][] matrix)` 行列の全ての成分の逆数を成分とする行列を生成します。
`static boolean` | `isSameSize(double[] a1, double[] a2)` 2個のベクトルの大きさが等しいか判定します。
`static boolean` | `isUnit(double[][] matrix, double tolerance)` 単位行列であるか判定します。
`static boolean` | `isUnit(double[][] matrix, NumericalScalar<?> tolerance)` 単位行列であるか判定します。
`static boolean` | `isZero(double[][] matrix, double tolerance)` 零行列であるか判定します。
`static boolean` | `isZero(double[][] matrix, NumericalScalar<?> tolerance)` 零行列であるか判定します。
`static double[][]` | `leftDivideElementWise(double[][] a1, double[][] a2)` 成分毎の割り算(左が分母、右が分子)の結果を成分とする行列を生成します。
`static double[][]` | `makeColumnVector(double[][] matrix)` 各列ベクトルを縦に結合し、長い列ベクトルを生成します。
`static double` | `max(double[] vector)` ベクトルの最大成分を返します。
`static double` | `max(double[][] matrix)` 行列の最大成分を返します。
`static double[][]` | `maxColumnWise(double[][] matrix)` 列毎に最大値を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `maxElementWise(double[][] a1, double[][] a2)` 成分毎に大きさを比較し、大きい方を成分とする行列を生成します。
`static Object[]` | `maximum(double[][] matrix)` 最大成分とその指数を返します。
`static Object[]` | `maximumColumnWise(double[][] matrix)` 列毎の最大成分とその指数を返します。
`static Object[]` | `maximumRowWise(double[][] matrix)` 行毎の最大成分とその指数を返します。
`static double[][]` | `maxRowWise(double[][] matrix)` 行毎に最大値を計算し、計算結果を成分とする列ベクトルを生成します。
`static double` | `mean(double[][] matrix)` 全ての成分の平均値を返します。
`static double[][]` | `meanColumnWise(double[][] matrix)` 列毎に全ての成分の平均値を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `meanRowWise(double[][] matrix)` 行毎に全ての成分の平均値を計算し、計算結果を成分とする列ベクトルを生成します。
`static double` | `median(double[][] matrix)` 全ての成分のメジアンを返します。
`static double[][]` | `medianColumnWise(double[][] matrix)` 列毎のメジアンを成分とする行ベクトルを生成します。
`static double[][]` | `medianRowWise(double[][] matrix)` 行毎のメジアンを成分とする列ベクトルを生成します。
`static double` | `min(double[] vector)` ベクトルの最小成分を返します。
`static double` | `min(double[][] matrix)` 行列の最小成分を返します。
`static double[][]` | `minColumnWise(double[][] matrix)` 列毎に最小値を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `minElementWise(double[][] a1, double[][] a2)` 成分毎に大きさを比較し、小さい方を成分とする行列を生成します。
`static Object[]` | `minimum(double[][] matrix)` 最小成分と指数を返します。
`static Object[]` | `minimumColumnWise(double[][] matrix)` 列毎に最小成分とその指数を返します。
`static Object[]` | `minimumRowWise(double[][] matrix)` 行毎の最小成分とその指数を返します。
`static double[][]` | `minRowWise(double[][] matrix)` 行毎に最小値を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `multiply(double[][] matrix, double scalar)` 行列に実数を掛けた行列を生成します。
`static double[][]` | `multiply(double[][] a1, double[][] a2)` 2個の行列の積行列を生成します。
`static double[][]` | `multiply(double[][] matrix, int scalar)` 行列に整数を掛けた行列を生成します。
`static double[][]` | `multiplyElementWise(double[][] a1, double[][] a2)` 成分毎の乗算結果を成分とする行列を生成します。
`static void` | `multiplySelf(double[][] matrix, double scalar)` 行列自身に実数を掛けます。
`static double` | `norm(double[][] matrix, NormType type)` 行列のノルムを返します。
`static double[][]` | `permutateSelf(double[][] matrix, int[] pivot, int count, boolean rowExchange)` 行や列を交換します。
`static double[][]` | `powerElementWise(double[][] matrix, double scalar)` 行列の全ての成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `powerElementWise(double[][] a1, double[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `powerElementWise(double[][] matrix, int scalar)` 全ての成分の累乗を成分とする行列を生成します。
`static double[][]` | `powerElementWise(double[][] a1, int[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `powerElementWise(double scalar, double[][] matrix)` 実数の累乗を行列の全ての成分毎に計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `powerElementWise(double scalar, int[][] matrix)` 実数の累乗を行列の全ての成分毎に計算し、計算結果を成分とする行列を生成します。
`static double[][]` | `powerElementWise(int[][] matrix, double d)` 全ての成分の累乗を成分とする行列を生成します。
`static double[][]` | `powerElementWise(int[][] a1, double[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static void` | `print(double[][] matrix, Writer output, String format, GridElementAlignment alignment, int maxColumnSize)` ライターに出力します。
`static double` | `product(double[][] matrix)` 全ての成分の積を返します。
`static double[][]` | `productColumnWise(double[][] matrix)` 列毎に全ての成分の積を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `productRowWise(double[][] matrix)` 行毎に全ての成分の積を計算し、計算結果を成分とする列ベクトルを生成します。
`static void` | `quickSort(double[] vector, int[] index, int start, int end)` ベクトルの成分を昇順にソートした結果を返します。
`static double[][]` | `readMatFormat(int rowSize, int columnSize, StreamTokenizer st)` ストリームトークンナイザから読み込んだ行列(MATフォーマット)を返します。
`static double[][]` | `readMxFormat(InputStream input, MxDataHead head)` 入力ストリームから読み込んだ(MXフォーマット)行列を返します。
`static double[][]` | `removeColumnVectors(double[][] matrix, int[] columnIndex)` 指定された列を削除した行列を生成します。
`static double[][]` | `removeColumnVectors(double[][] matrix, int columnMin, int columnMax)` 指定された列を削除した行列を生成します。
`static double[][]` | `removeRowVectors(double[][] matrix, int[] rowIndex)` 指定された行を削除した行列を生成します。
`static double[][]` | `removeRowVectors(double[][] matrix, int rowMin, int rowMax)` 指定された行を削除した行列を生成します。
`static double[][]` | `reshape(double[][] matrix, int newRowSize, int newColumnSize)` 行列の成分を変えずに、行列の大きさ(行の数と列の数)を変形します。
`static double[][]` | `reshape(double[] vector, int newRowSize, int newColumnSize)` ベクトルの成分を変えずに、行列に変形します。
`static double[][]` | `resize(double[][] matrix, int newRowSize, int newColumnSize)` `newRowSize`*`newColumnSize`にサイズ変更します。
`static double[]` | `series(double from, double to, double by)` `from`から`to`までの`by`飛びの実数を成分とする行ベクトルを返します。
`static void` | `setSubMatrix(double[][] destination, int[] rowIndex, int[] columnIndex, double[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubMatrix(double[][] destination, int[] rowIndex, int columnMin, int columnMax, double[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubMatrix(double[][] destination, int rowTo, int columnTo, double[][] source, int rowMin, int rowMax, int columnMin, int columnMax)` 配列`to`の`rowTo`行`columnTo`列を始点として、 配列`from`の`rowMin`行`columnMin`列から `rowMax`行`columnMax`列までの値をコピーします。
`static void` | `setSubMatrix(double[][] destination, int rowMin, int rowMax, int[] columnIndex, double[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubMatrix(double[][] destination, int rowMin, int rowMax, int columnMin, int columnMax, double[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubVector(double[] destination, int to, double[] source, int min, int max)` 配列`destination`の`rowTo`行を始点として、 配列`source`の `rowMin`行から`rowMax`行までの値をコピーします。
`static void` | `setSubVector(double[] destination, int min, int max, double[] source)` 与えられた位置にベクトルを代入します。
`static void` | `setZero(double[] matrix)` ベクトルの全ての成分に零を代入します。
`static void` | `setZero(double[][] matrix)` 行列の全ての成分に零を代入します。
`static org.mklab.nfc.matrix.IndexedDoubleElements` | `sortColumnWise(double[][] matrix)` 列毎とに昇順に並び替えた行列と元の位置を示す指数を返します。
`static org.mklab.nfc.matrix.IndexedDoubleElements` | `sortRowWise(double[][] matrix)` 行毎に昇順に並び替えた行列と元の位置を示す指数を返します。
`static double` | `std(double[][] matrix)` 全ての成分の標準偏差を返します。
`static double[][]` | `stdColumnWise(double[][] matrix)` 列毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。
`static double[][]` | `stdRowWise(double[][] matrix)` 行毎に標準偏差を計算し、計算結果を成分とする列ベクトルを生成します。
`static double[][]` | `subtract(double[][] a1, double[][] a2)` 行列の差行列を生成します。
`static double[][]` | `subtractElementWise(double[][] matrix, double scalar)` 行列の全ての成分から実数を引いた行列を生成します。
`static double` | `sum(double[][] matrix)` 全ての成分の和を返します。
`static double[][]` | `sumColumnWise(double[][] matrix)` 列毎に全ての成分の和を計算し、計算結果を成分とする行ベクトルを生成します。
`static double[][]` | `sumRowWise(double[][] matrix)` 行毎に全ての成分の和を計算し、計算結果を成分とする列ベクトルを生成します。
`static int[]` | `toIntMatrix(double[] vector)` 全ての実数成分を最も近い整数に丸めるた行列を生成します。
`static String` | `toMmString(double[][] matrix, String format)` 行列をMMフォーマットの文字列に変換します。
`static double` | `trace(double[][] matrix)` 全対角成分の和(トレース)を返します。
`static double[][]` | `transpose(double[][] matrix)` 転置行列を生成します。
`static void` | `transpose(double[][] matrix, double[][] result)` 転置行列の成分を設定します。
`static double[][]` | `unaryMinus(double[][] matrix)` 成分の符号を反転した行列を生成します。
`static double` | `variance(double[][] matrix)` 分散を返します。
`static double[][]` | `vectorToDiagonal(double[] vector)` ベクトルの成分を対角成分とする対角行列を生成します。
`static void` | `writeMatFormat(double[][] matrix, OutputStream output)` 出力ストリームに行列をMATフォーマットで出力します。
`static void` | `writeMatFormat(double[][] matrix, String fileName)` 指定したファイルに行列をMATフォーマットで保存します。
`static void` | `writeMxFormat(double[][] matrix, OutputStream output, String name)` 行列を出力ストリームにMXフォーマットで出力します。

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

メソッドの詳細

### equals

    public static boolean equals(double[] a1,
                                 double[] a2)

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

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

### equals

    public static boolean equals(double[] a1,
                                 double[] a2,
                                 double tolerance)

  2個の配列の成分の差の絶対値が許容誤差以下であるか判定します。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列
    `tolerance` - 許容誤差
  戻り値:
    配列の成分の差が許容誤差以下ならばtrue、そうでなければfalse

### equals

    public static boolean equals(double[][] a1,
                                 double[][] a2)

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

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

### equals

    public static boolean equals(double[][] a1,
                                 double[][] a2,
                                 double tolerance)

  2個の配列の成分の差の絶対値が許容誤差以下であるか判定します。

  パラメータ:
    `a1` - 第一行列
    `a2` - 第二行列
    `tolerance` - 許容誤差
  戻り値:
    配列の成分の差が許容誤差以下ならばtrue、そうでなければfalse

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int rowMin,
                                                int rowMax,
                                                int columnMin,
                                                int columnMax)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowMin` - 始まり行(0から始まります)
    `rowMax` - 終わり行(0から始まります)
    `columnMin` - 始まり列(0から始まります)
    `columnMax` - 終わり列(0から始まります)
  戻り値:
    部分行列

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int[] rowIndex,
                                                int column)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowIndex` - 該当する行の番号
    `column` - 列番号
  戻り値:
    部分行列

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int[] rowIndex,
                                                int columnMin,
                                                int columnMax)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowIndex` - 該当する行の番号
    `columnMin` - 始まりの列
    `columnMax` - 終わりの列
  戻り値:
    部分行列

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int row,
                                                int[] columnIndex)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `row` - 行の番号
    `columnIndex` - 該当する列の番号
  戻り値:
    部分行列

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int rowMin,
                                                int rowMax,
                                                int[] columnIndex)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowMin` - 始まりの行
    `rowMax` - 終わりの行
    `columnIndex` - 該当する列の番号
  戻り値:
    部分行列

### getSubMatrix

    public static final double[][] getSubMatrix(double[][] matrix,
                                                int[] rowIndex,
                                                int[] columnIndex)

  部分行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowIndex` - 該当する行の番号
    `columnIndex` - 該当する列の番号
  戻り値:
    部分行列

### getSubVector

    public static final double[] getSubVector(double[] vector,
                                              int[] index)

  部分ベクトルを生成します。

  パラメータ:
    `vector` - 元のベクトル
    `index` - 該当する行の番号
  戻り値:
    部分ベクトル

### getSubVector

    public static final double[] getSubVector(double[] vector,
                                              int rowMin,
                                              int rowMax)

  部分ベクトルを生成します。

  パラメータ:
    `vector` - 元のベクトル
    `rowMin` - 開始位置
    `rowMax` - 終了位置
  戻り値:
    部分ベクトル

### appendDown

    public static double[][] appendDown(double[][] a1,
                                        double[][] a2)

  2個の行列を縦に接続した行列を生成します。

  パラメータ:
    `a1` - 上側の行列
    `a2` - 下側の行列
  戻り値:
    接続された行列

### appendRight

    public static final double[][] appendRight(double[][] a1,
                                               double[][] a2)

  2個の行列を横に接続した行列を生成します。

  パラメータ:
    `a1` - 左側の行列
    `a2` - 右側の行列
  戻り値:
    接続された行列

### appendRight

    public static final double[][] appendRight(double[] a1,
                                               double[][] a2)

  ベクトルの右側に行列を接続した行列を生成します。

  パラメータ:
    `a1` - 左側のベクトル
    `a2` - 右側の行列
  戻り値:
    接続された行列

### absElementWise

    public static double[][] absElementWise(double[][] matrix)

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

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

### powerElementWise

    public static double[][] powerElementWise(double[][] matrix,
                                              int scalar)

  全ての成分の累乗を成分とする行列を生成します。

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

### anyZero

    public static boolean anyZero(double[][] matrix)

  少なくとも1個は零の成分が行列に含まれるか判定します。

  パラメータ:
    `matrix` - 判定する対象の行列
  戻り値:
    少なくとも1個は零の成分があればtrue、そうでなければfalse

### anyZero

    public static boolean anyZero(double[][] matrix,
                                  double tolerance)

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

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

### anyZero

    public static boolean anyZero(double[] vector)

  少なくとも1個は零の成分がベクトルに含まれるか判定します。

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

### anyZero

    public static boolean anyZero(double[] vector,
                                  double tolerance)

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

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

### clone

    public static final double[][] clone(double[][] matrix)

  行列の複製を生成します。

  パラメータ:
    `matrix` - 複製の元となる行列
  戻り値:
    複製された行列

### clone

    public static final double[] clone(double[] vector)

  ベクトルの複製を生成します。

  パラメータ:
    `vector` - 複製の元となるベクトル
  戻り値:
    複製されたベクトル

### copy

    public static final void copy(double[][] source,
                                  double[][] destination)

  行列の成分をコピーします。

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

### copy

    public static final void copy(int[][] source,
                                  double[][] destination)

  行列の成分をコピーします。

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

### copy

    public static final void copy(double[] source,
                                  double[] destination)

  行列の成分をコピーします。

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

### copy

    public static final void copy(int[] source,
                                  double[] destination)

  行列の成分をコピーします。

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

### isZero

    public static final boolean isZero(double[][] matrix,
                                       double tolerance)

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

  パラメータ:
    `matrix` - 判定する行列
    `tolerance` - 許容誤差
  戻り値:
    零行列ならばtrue、そうでなければfalse

### isZero

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

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

  パラメータ:
    `matrix` - 判定する行列
    `tolerance` - 許容誤差
  戻り値:
    零行列ならばtrue、そうでなければfalse

### isUnit

    public static final boolean isUnit(double[][] matrix,
                                       double tolerance)

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

  パラメータ:
    `matrix` - 判定する行列
    `tolerance` - 許容誤差
  戻り値:
    単位行列ならばtrue、そうでなければfalse

### isUnit

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

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

  パラメータ:
    `matrix` - 判定する行列
    `tolerance` - 許容誤差
  戻り値:
    単位行列ならばtrue、そうでなければfalse

### setZero

    public static final void setZero(double[][] matrix)

  行列の全ての成分に零を代入します。

  パラメータ:
    `matrix` - 零を代入する行列

### setZero

    public static final void setZero(double[] matrix)

  ベクトルの全ての成分に零を代入します。

  パラメータ:
    `matrix` - 零を代入するベクトル

### transpose

    public static final double[][] transpose(double[][] matrix)

  転置行列を生成します。

  パラメータ:
    `matrix` - 元の行列
  戻り値:
    転置行列

### transpose

    public static final void transpose(double[][] matrix,
                                       double[][] result)

  転置行列の成分を設定します。

  パラメータ:
    `matrix` - 元の行列
    `result` - 転置行列の成分を代入する行列

### inverseElementWise

    public static double[][] inverseElementWise(double[][] matrix)

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

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

### addSelf

    public static final void addSelf(double[][] a1,
                                     double[][] a2)

  第1行列に第2行列を加えます。

  パラメータ:
    `a1` - 第1行列
    `a2` - 第2行列

### multiply

    public static final double[][] multiply(double[][] a1,
                                            double[][] a2)

  2個の行列の積行列を生成します。

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

### createUnit

    public static final double[][] createUnit(int rowSize,
                                              int columnSize)

  単位行列を生成します。

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

### createOnes

    public static final double[][] createOnes(int rowSize,
                                              int columnSize)

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

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    全ての成分が1である行列

### createUniformRandom

    public static final double[][] createUniformRandom(int rowSize,
                                                       int columnSize)

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

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    0〜1の範囲の一様分布の乱数を成分とする行列

### createUniformRandom

    public static final double[][] createUniformRandom(int rowSize,
                                                       int columnSize,
                                                       long seed)

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

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `seed` - 乱数の種
  戻り値:
    0〜1の範囲の一様分布の乱数を成分とする行列

### createNormalRandom

    public static final double[][] createNormalRandom(int rowSize,
                                                      int columnSize)

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

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

### createNormalRandom

    public static final double[][] createNormalRandom(int rowSize,
                                                      int columnSize,
                                                      long seed)

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

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

### series

    public static final double[] series(double from,
                                        double to,
                                        double by)

  `from`から`to`までの`by`飛びの実数を成分とする行ベクトルを返します。

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

### setSubMatrix

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

  配列`to`の`rowTo`行`columnTo`列を始点として、 配列`from`の`rowMin`行`columnMin`列から `rowMax`行`columnMax`列までの値をコピーします。

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

### setSubMatrix

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

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

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

### setSubMatrix

    public static final void setSubMatrix(double[][] destination,
                                          int[] rowIndex,
                                          int columnMin,
                                          int columnMax,
                                          double[][] source)

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

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

### setSubMatrix

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

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

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

### setSubMatrix

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

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

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

### setSubVector

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

  与えられた位置にベクトルを代入します。

  パラメータ:
    `destination` - 値を設定するベクトル
    `min` - 成分の始まり
    `max` - 成分の終り
    `source` - 代入するベクトル

### setSubVector

    public static final void setSubVector(double[] destination,
                                          int to,
                                          double[] source,
                                          int min,
                                          int max)

  配列`destination`の`rowTo`行を始点として、 配列`source`の `rowMin`行から`rowMax`行までの値をコピーします。

  パラメータ:
    `destination` - コピー先
    `to` - 変更開始行
    `source` - コピー元
    `min` - コピー開始行
    `max` - コピー開始列

### exchangeColumn

    public static final void exchangeColumn(double[][] matrix,
                                            int column1,
                                            int column2)

  column1列とcolumn2列を入れ替えます。

  パラメータ:
    `matrix` - 対象の行列
    `column1` - 指定列１
    `column2` - 指定列２

### exchangeRow

    public static final void exchangeRow(double[][] matrix,
                                         int row1,
                                         int row2)

  row1行とrow2行を入れ替えます。

  パラメータ:
    `matrix` - 対象の行列
    `row1` - 指定行１
    `row2` - 指定行２

### permutateSelf

    public static final double[][] permutateSelf(double[][] matrix,
                                                 int[] pivot,
                                                 int count,
                                                 boolean rowExchange)

  行や列を交換します。

  パラメータ:
    `matrix` - 対象となる行列
    `pivot` - 交換する行番号や列番号の配列
    `count` - 交換する数
    `rowExchange` - 行を交換する場合true
  戻り値:
    行や列を交換した行列

### multiplySelf

    public static final void multiplySelf(double[][] matrix,
                                          double scalar)

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

  パラメータ:
    `matrix` - 対象となる行列
    `scalar` - 乗じる実数

### multiply

    public static final double[][] multiply(double[][] matrix,
                                            int scalar)

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

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

### multiply

    public static final double[][] multiply(double[][] matrix,
                                            double scalar)

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

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

### unaryMinus

    public static final double[][] unaryMinus(double[][] matrix)

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

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

### increment

    public static final double[][] increment(double[][] matrix)

  全ての成分を1だけ増加させた行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    成分を１だけ増加させた行列

### increment

    public static final double[] increment(double[] vector)

  全ての成分を1だけ増加させたベクトルを生成します。

  パラメータ:
    `vector` - 対象となるベクトル
  戻り値:
    成分を１だけ増加させたベクトル

### decrement

    public static final double[][] decrement(double[][] matrix)

  全ての成分を1だけ減少させた行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    成分を１だけ減少させた行列

### decrement

    public static final double[] decrement(double[] vector)

  全ての成分を1だけ減少させたベクトルを生成します。

  パラメータ:
    `vector` - 対象となるベクトル
  戻り値:
    成分を１だけ減少させたベクトル

### toIntMatrix

    public static int[] toIntMatrix(double[] vector)

  全ての実数成分を最も近い整数に丸めるた行列を生成します。

  パラメータ:
    `vector` - 対象となる行列
  戻り値:
    全ての実数成分を最も近い整数に丸めた行列

### vectorToDiagonal

    public static final double[][] vectorToDiagonal(double[] vector)

  ベクトルの成分を対角成分とする対角行列を生成します。

  パラメータ:
    `vector` - 対象となるベクトル
  戻り値:
    対角行列

### removeRowVectors

    public static double[][] removeRowVectors(double[][] matrix,
                                              int rowMin,
                                              int rowMax)

  指定された行を削除した行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `rowMin` - 開始行
    `rowMax` - 終了行
  戻り値:
    行を削除された行列

### removeRowVectors

    public static double[][] removeRowVectors(double[][] matrix,
                                              int[] rowIndex)

  指定された行を削除した行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `rowIndex` - 削除する行の番号
  戻り値:
    行を削除された行列

### removeColumnVectors

    public static double[][] removeColumnVectors(double[][] matrix,
                                                 int columnMin,
                                                 int columnMax)

  指定された列を削除した行列を生成します。

  パラメータ:
    `matrix` - 対象となる行列
    `columnMin` - 開始列
    `columnMax` - 終了列
  戻り値:
    列を削除された行列

### removeColumnVectors

    public static double[][] removeColumnVectors(double[][] matrix,
                                                 int[] columnIndex)

  指定された列を削除した行列を生成します。

  パラメータ:
    `matrix` - 元の行列
    `columnIndex` - 削除する列の番号
  戻り値:
    列を削除された行列

### reshape

    public static final double[][] reshape(double[][] matrix,
                                           int newRowSize,
                                           int newColumnSize)

  行列の成分を変えずに、行列の大きさ(行の数と列の数)を変形します。

  パラメータ:
    `matrix` - 対象となる行列
    `newRowSize` - 変更後の行の数
    `newColumnSize` - 変更後の列の数
  戻り値:
    変形した行列

### reshape

    public static final double[][] reshape(double[] vector,
                                           int newRowSize,
                                           int newColumnSize)

  ベクトルの成分を変えずに、行列に変形します。

  パラメータ:
    `vector` - 対象となるベクトル
    `newRowSize` - 行の数
    `newColumnSize` - 列の数
  戻り値:
    変形された行列

### multiplyElementWise

    public static final double[][] multiplyElementWise(double[][] a1,
                                                       double[][] a2)

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

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

### maxElementWise

    public static final double[][] maxElementWise(double[][] a1,
                                                  double[][] a2)

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

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

### minElementWise

    public static final double[][] minElementWise(double[][] a1,
                                                  double[][] a2)

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

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

### divide

    public static double[][] divide(double[][] matrix,
                                    int scalar)

  成分を整数で割った値を成分とする行列を生成します。

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

### divide

    public static double[][] divide(double[][] matrix,
                                    double scalar)

  成分を実数で割った値を成分とする行列を生成します。

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

### divide

    public static double[] divide(double[] vector,
                                  double scalar)

  成分を実数で割った値を成分とする行列を生成します。

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

### divideElementWise

    public static final double[][] divideElementWise(double[][] a1,
                                                     double[][] a2)

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

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

### leftDivideElementWise

    public static final double[][] leftDivideElementWise(double[][] a1,
                                                         double[][] a2)

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

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

### addElementWise

    public static final double[][] addElementWise(double[][] matrix,
                                                  double scalar)

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

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

### addElementWise

    public static final double[] addElementWise(double[] vector,
                                                double scalar)

  ベクトル全ての成分に実数を加えたベクトルを生成します。

  パラメータ:
    `vector` - 対象となるベクトル
    `scalar` - 加える実数
  戻り値:
    生成されたベクトル

### subtractElementWise

    public static final double[][] subtractElementWise(double[][] matrix,
                                                       double scalar)

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

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

### powerElementWise

    public static final double[][] powerElementWise(double scalar,
                                                    double[][] matrix)

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

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

### powerElementWise

    public static final double[][] powerElementWise(double[][] matrix,
                                                    double scalar)

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

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

### powerElementWise

    public static final double[][] powerElementWise(double[][] a1,
                                                    double[][] a2)

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

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

### powerElementWise

    public static final double[][] powerElementWise(double[][] a1,
                                                    int[][] a2)

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

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

### isSameSize

    public static final boolean isSameSize(double[] a1,
                                           double[] a2)

  2個のベクトルの大きさが等しいか判定します。

  パラメータ:
    `a1` - 第一ベクトル
    `a2` - 第二ベクトル
  戻り値:
    2個のベクトルの大きさが等しければtrue

### add

    public static final double[][] add(double[][] a1,
                                       double[][] a2)

  行列の和行列を生成します。

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

### subtract

    public static final double[][] subtract(double[][] a1,
                                            double[][] a2)

  行列の差行列を生成します。

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

### max

    public static final double max(double[][] matrix)

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

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

### max

    public static double max(double[] vector)

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

  パラメータ:
    `vector` - 対象となるベクトル
  戻り値:
    最大成分

### min

    public static double min(double[][] matrix)

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

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

### min

    public static double min(double[] vector)

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

  パラメータ:
    `vector` - 対象となるベクトル
  戻り値:
    最小成分

### sum

    public static double sum(double[][] matrix)

  全ての成分の和を返します。

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

### product

    public static final double product(double[][] matrix)

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

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

### mean

    public static final double mean(double[][] matrix)

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

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

### std

    public static final double std(double[][] matrix)

  全ての成分の標準偏差を返します。

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

### frobNorm

    public static final double frobNorm(double[][] matrix)

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

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

### frobNormRowWise

    public static final double[][] frobNormRowWise(double[][] matrix)

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

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

### frobNormColumnWise

    public static final double[][] frobNormColumnWise(double[][] matrix)

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

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

### norm

    public static final double norm(double[][] matrix,
                                    NormType type)

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

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

### infNorm

    public static final double infNorm(double[][] matrix)

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

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

### trace

    public static final double trace(double[][] matrix)

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

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

### diagonalToVector

    public static final double[][] diagonalToVector(double[][] matrix)

  対角成分からなる縦ベクトルを生成します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    対角成分からなる縦ベクトル

### quickSort

    public static final void quickSort(double[] vector,
                                       int[] index,
                                       int start,
                                       int end)

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

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

### sortRowWise

    public static final org.mklab.nfc.matrix.IndexedDoubleElements sortRowWise(double[][] matrix)

  行毎に昇順に並び替えた行列と元の位置を示す指数を返します。

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

### sortColumnWise

    public static final org.mklab.nfc.matrix.IndexedDoubleElements sortColumnWise(double[][] matrix)

  列毎とに昇順に並び替えた行列と元の位置を示す指数を返します。

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

### readMatFormat

    public static final double[][] readMatFormat(int rowSize,
                                                 int columnSize,
                                                 StreamTokenizer st)
                                          throws IOException

  ストリームトークンナイザから読み込んだ行列(MATフォーマット)を返します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `st` - データを読み込むストリームトークンナイザ
  戻り値:
    読み込んだ行列
  例外:
    `IOException` - ストリームトークンナイザから読み込めない場合

### writeMatFormat

    public static void writeMatFormat(double[][] matrix,
                                      String fileName)
                               throws IOException

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

  パラメータ:
    `fileName` - 作成するmatファイル名
    `matrix` - 対象となる行列
  例外:
    `IOException` - 入出力エラーが発生した場合

### writeMatFormat

    public static void writeMatFormat(double[][] matrix,
                                      OutputStream output)
                               throws IOException

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

  パラメータ:
    `matrix` - 対象となる行列
    `output` - 出力ストリーム
  例外:
    `IOException` - ストリームに出力できない場合

### writeMxFormat

    public static final void writeMxFormat(double[][] matrix,
                                           OutputStream output,
                                           String name)
                                    throws IOException

  行列を出力ストリームにMXフォーマットで出力します。

  パラメータ:
    `matrix` - 対象となる行列
    `output` - 出力ストリーム
    `name` - 行列の名前
  例外:
    `IOException` - ストリームに出力できない場合

### readMxFormat

    public static final double[][] readMxFormat(InputStream input,
                                                MxDataHead head)
                                         throws IOException

  入力ストリームから読み込んだ(MXフォーマット)行列を返します。

  パラメータ:
    `input` - 入力ストリーム
    `head` - MXフォーマットのヘッダ情報
  戻り値:
    読み込んだ行列
  例外:
    `IOException` - 入力ストリームから読み込めない場合

### toMmString

    public static final String toMmString(double[][] matrix,
                                          String format)

  行列をMMフォーマットの文字列に変換します。

  パラメータ:
    `matrix` - 対象となる行列
    `format` - 成分の出力フォーマット
  戻り値:
    MMフォーマットの文字列

### productRowWise

    public static final double[][] productRowWise(double[][] matrix)

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

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

### productColumnWise

    public static final double[][] productColumnWise(double[][] matrix)

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

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

### sumRowWise

    public static final double[][] sumRowWise(double[][] matrix)

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

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

### sumColumnWise

    public static final double[][] sumColumnWise(double[][] matrix)

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

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

### meanColumnWise

    public static final double[][] meanColumnWise(double[][] matrix)

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

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

### meanRowWise

    public static final double[][] meanRowWise(double[][] matrix)

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

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

### cumulativeProductColumnWise

    public static final double[][] cumulativeProductColumnWise(double[][] matrix)

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

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

### cumulativeProductRowWise

    public static final double[][] cumulativeProductRowWise(double[][] matrix)

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

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

### cumulativeSumColumnWise

    public static final double[][] cumulativeSumColumnWise(double[][] matrix)

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

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

### cumulativeSumRowWise

    public static final double[][] cumulativeSumRowWise(double[][] matrix)

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

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

### minColumnWise

    public static final double[][] minColumnWise(double[][] matrix)

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

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

### minRowWise

    public static final double[][] minRowWise(double[][] matrix)

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

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

### maxColumnWise

    public static final double[][] maxColumnWise(double[][] matrix)

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

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

### maxRowWise

    public static final double[][] maxRowWise(double[][] matrix)

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

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

### stdColumnWise

    public static final double[][] stdColumnWise(double[][] matrix)

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

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

### stdRowWise

    public static final double[][] stdRowWise(double[][] matrix)

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

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

### cumulativeProduct

    public static final double[][] cumulativeProduct(double[][] matrix)

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

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

### cumulativeSum

    public static final double[][] cumulativeSum(double[][] matrix)

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

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

### minimum

    public static final Object[] minimum(double[][] matrix)

  最小成分と指数を返します。

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

### indexOfMinimum

    public static int[] indexOfMinimum(double[][] matrix)

  最小成分の指数を返します。

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

### minimumColumnWise

    public static final Object[] minimumColumnWise(double[][] matrix)

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

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

### minimumRowWise

    public static final Object[] minimumRowWise(double[][] matrix)

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

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

### maximum

    public static final Object[] maximum(double[][] matrix)

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

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

### indexOfMaximum

    public static int[] indexOfMaximum(double[][] matrix)

  最大成分の指数を求めます。

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

### maximumColumnWise

    public static final Object[] maximumColumnWise(double[][] matrix)

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

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

### maximumRowWise

    public static final Object[] maximumRowWise(double[][] matrix)

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

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

### elementWiseFunction

    public static final double[][] elementWiseFunction(double[][] matrix,
                                                       org.mklab.nfc.matrix.DoubleRealFunction function)

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

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

### elementWiseFunction

    public static final double[][] elementWiseFunction(double[][] a1,
                                                       double[][] a2,
                                                       org.mklab.nfc.matrix.DoubleRealFunctionWithTwoArguments function)

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

  パラメータ:
    `a1` - 第一引数を成分とする行列
    `a2` - 第二引数を成分とする行列
    `function` - 実数関数(引数2個)
  戻り値:
    計算結果を成分とする行列

### elementWiseFunction

    public static final double[][] elementWiseFunction(double[][] matrix,
                                                       double d2,
                                                       org.mklab.nfc.matrix.DoubleRealFunctionWithTwoArguments function)

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

  パラメータ:
    `matrix` - 第一引数を成分とする行列
    `d2` - 第二引数
    `function` - 実数関数(引数2個)
  戻り値:
    計算結果を成分とする行列

### elementWiseFunction

    public static final boolean[][] elementWiseFunction(double[][] matrix,
                                                        org.mklab.nfc.matrix.BooleanFunction function)

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

  パラメータ:
    `matrix` - 関数の引数を成分とする行列
    `function` - ブーリアン関数(引数1個)
  戻り値:
    計算結果を成分とする行列(ブーリアン)

### elementWiseFunction

    public static final boolean[][] elementWiseFunction(double[][] a1,
                                                        double[][] a2,
                                                        org.mklab.nfc.matrix.BooleanFunctionWithTwoArguments function)

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

  パラメータ:
    `a1` - 第一引数を成分とする行列
    `a2` - 第二引数を成分とする行列
    `function` - ブーリアン関数(引数2個)
  戻り値:
    計算結果を成分とする行列

### elementWiseFunction

    public static final boolean[][] elementWiseFunction(double[][] matrix,
                                                        double d2,
                                                        org.mklab.nfc.matrix.BooleanFunctionWithTwoArguments function)

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

  パラメータ:
    `matrix` - 第一引数を成分とする行列
    `d2` - 第二引数
    `function` - ブーリアン関数(引数2個)
  戻り値:
    計算結果を成分とする行列

### compareElements

    public static final boolean[][] compareElements(double[][] matrix,
                                                    String operator,
                                                    double opponent)

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

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

### compareElements

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

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

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

### compareElements

    public static final boolean[][] compareElements(double[][] a1,
                                                    String operator,
                                                    double[][] a2)

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

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

### compareElements

    public static final boolean[][] compareElements(double[][] a1,
                                                    String operator,
                                                    int[][] a2)

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

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

### resize

    public static final double[][] resize(double[][] matrix,
                                          int newRowSize,
                                          int newColumnSize)

  `newRowSize`*`newColumnSize`にサイズ変更します。

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

  パラメータ:
    `matrix` - 対象となる行列
    `newRowSize` - 新しい行の数
    `newColumnSize` - 新しいレスう
  戻り値:
    サイズ変更後の行列

### powerElementWise

    public static final double[][] powerElementWise(int[][] matrix,
                                                    double d)

  全ての成分の累乗を成分とする行列を生成します。

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

### powerElementWise

    public static final double[][] powerElementWise(int[][] a1,
                                                    double[][] a2)

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

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

### powerElementWise

    public static double[][] powerElementWise(double scalar,
                                              int[][] matrix)

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

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

### createArray

    public static final double[][] createArray(int[][] matrix)

  整数行列を実数行列に変換します。

  パラメータ:
    `matrix` - 整数行列
  戻り値:
    実数行列

### print

    public static void print(double[][] matrix,
                             Writer output,
                             String format,
                             GridElementAlignment alignment,
                             int maxColumnSize)

  ライターに出力します。

  パラメータ:
    `matrix` - 対象となる行列
    `output` - ライター
    `format` - 成分の出力フォーマット
    `alignment` - 成分の出力配置
    `maxColumnSize` - 最大列の数

### median

    public static double median(double[][] matrix)

  全ての成分のメジアンを返します。

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

### medianColumnWise

    public static double[][] medianColumnWise(double[][] matrix)

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

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

### medianRowWise

    public static double[][] medianRowWise(double[][] matrix)

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

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

### covariance

    public static double[][] covariance(double[][] a1,
                                        double[][] a2)

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

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

### variance

    public static double variance(double[][] matrix)

  分散を返します。

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

### makeColumnVector

    public static double[][] makeColumnVector(double[][] matrix)

  各列ベクトルを縦に結合し、長い列ベクトルを生成します。

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    列ベクトル

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