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

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

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

    public final class IntMatrixUtil

extends Object

整数行列`IntMatrix`に関するユーティリティクラスです。

バージョン:
  $Revision: 1.63 $
作成者:
  Koga Laboratory

メソッドの概要
`static int[][]` | `add(int[][] a1, int[][] a2)` 行列の和を求めます。
`static int[][]` | `addElementWise(int[][] matrix, int scalar)` 行列の全ての成分に整数を加えた行列を生成します。
`static int[]` | `addElementWise(int[] vector, int scalar)` ベクトルの全ての成分に整数を加えたベクトルを生成します。
`static int[][]` | `appendDown(int[][] a1, int[][] a2)` 2個の行列を縦に接続した行列を生成します。
`static int[][]` | `appendRight(int[][] a1, int[][] a2)` 2個の行列を横に接続した行列を生成します。
`static int[][]` | `clone(int[][] matrix)` 行列の複製を生成します。
`static boolean[][]` | `compareElements(int[][] matrix, String operator, double opponent)` 各成分とvalueをoperatorで指定された演算子で比較し、計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(int[][] matrix, String operator, int opponent)` 各成分とvalueをoperatorで指定された演算子で比較し、計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(int[][] a1, String operator, int[][] a2)` 2個の行列を成分毎にoperatorで指定された演算子で比較し、計算結果を成分とする行列を生成します。
`static boolean[][]` | `compareElements(int[][] matrix, String operator, Scalar<?> opponent)` 各成分とvalueをoperatorで指定された演算子で比較し、計算結果を成分とする行列を生成します。
`static void` | `copy(int[][] source, int[][] destination)` 行列の成分をコピーします。
`static int[][]` | `covariance(int[][] a1, int[][] a2)` 共分散行列を求めます。
`static int[][]` | `createMatrix(double[][] matrix)` 実行列を整数行列に変換(最も近い整数に丸める)します。
`static int[][]` | `createUnit(int rowSize, int columnSize)` 単位行列を生成します。
`static int[][]` | `cumulativeProduct(int[][] matrix)` 全ての成分の累積積を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `cumulativeProductColumnWise(int[][] matrix)` 列毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `cumulativeProductRowWise(int[][] matrix)` 行毎に累積積を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `cumulativeSum(int[][] matrix)` 全ての成分の累積和を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `cumulativeSumColumnWise(int[][] matrix)` 列毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `cumulativeSumRowWise(int[][] matrix)` 行毎に累積和を計算し、計算結果を成分とする行列を生成します。
`static int[]` | `decrement(int[] vector)` ベクトルの全ての成分を１減少させたベクトルを生成します。
`static int[][]` | `decrement(int[][] matrix)` 行列の全ての成分を１減少させた行列を生成します。
`static int[][]` | `diagonal(int[] diagonalElements)` 対角行列を生成する
`static int[][]` | `diagonalToVector(int[][] matrix)` 対角成分からなる列ベクトルを生成します。
`static int[][]` | `divide(int[][] matrix, int scalar)` 全ての成分を整数で割る。
`static boolean` | `equals(int[][] a1, int[][] a2)` 2個の配列の成分が全て等しか判定します。
`static boolean` | `equals(int[][] a1, int[][] a2, double tolerance)` 2個の配列の成分が全て等しか判定します。
`static void` | `exchangeColumn(int[][] matrix, int column1, int column2)` column1列とcolumn2列を入れ替えます。
`static void` | `exchangeRow(int[][] matrix, int row1, int row2)` row1行とrow2行を入れ替えます。
`static int[][]` | `getSubMatrix(int[][] matrix, int[] rowIndex, int column)` 部分行列を生成します。
`static int[][]` | `getSubMatrix(int[][] matrix, int[] rowIndex, int[] columnIndex)` 部分行列を生成します。
`static int[][]` | `getSubMatrix(int[][] matrix, int[] rowIndex, int columnMin, int columnMax)` 部分行列を生成します。
`static int[][]` | `getSubMatrix(int[][] matrix, int row, int[] columnIndex)` 部分行列を生成します。
`static int[][]` | `getSubMatrix(int[][] matrix, int rowMin, int rowMax, int[] columnIndex)` 部分行列を生成します。
`static int[][]` | `getSubMatrix(int[][] matrix, int rowMin, int rowMax, int columnMin, int columnMax)` 部分行列を生成します。
`static int[]` | `getSubVector(int[] vector, int[] index)` 部分ベクトルを生成します。
`static int[]` | `getSubVector(int[] vector, int rowMin, int rowMax)` 部分ベクトルを生成します。
`static int[]` | `increment(int[] vector)` ベクトルの全ての成分を１増加させたベクトルを生成します。
`static int[][]` | `increment(int[][] matrix)` 行列の全ての成分を１増加させた行列を生成します。
`static boolean[][]` | `isFiniteElementWise(int[][] matrix)` 各成分の有限性の真偽を成分にもつ行列を返します。
`static boolean[][]` | `isInfiniteElementWise(int[][] matrix)` 各成分の無限性の真偽を成分にもつ行列を返します。
`static boolean[][]` | `isNanElementWise(int[][] matrix)` 各成分の非数性の真偽を成分にもつ行列を返します。
`static boolean` | `isUnit(int[][] matrix, double tolerance)` 単位行列であるか判定します。
`static boolean` | `isZero(int[][] matrix, double tolerance)` 零行列であるか判定します。
`static int[][]` | `makeColumnVector(int[][] matrix)` 各列ベクトルを縦に結合し、長い列ベクトルを生成します。
`static int[][]` | `maxElementWise(int[][] a1, int[][] a2)` 成分毎に大きさを比較し、大きい方を成分とする行列を生成します。
`static int[][]` | `meanColumnWise(int[][] matrix)` 列毎に全ての成分の平均値を計算し、計算結果を成分とする行ベクトルを生成します。
`static int[][]` | `meanRowWise(int[][] matrix)` 行毎に全ての成分の平均値を計算し、計算結果を成分とする列ベクトルを生成します。
`static int[][]` | `medianColumnWise(int[][] matrix)` 列毎のメジアンを成分とする行ベクトルを返します。
`static int[][]` | `medianRowWise(int[][] matrix)` 行毎のメジアンを成分とする列ベクトルを返します。
`static int[][]` | `minElementWise(int[][] a1, int[][] a2)` 成分毎に大きさを比較し、小さい方を成分とする行列を生成します。
`static int[][]` | `multiply(int[][] matrix, int scalar)` 行列に整数を掛けます。
`static int[][]` | `multiply(int[][] a1, int[][] a2)` 2個の行列の積を求めます。
`static int[][]` | `multiplyElementWise(int[][] a1, int[][] a2)` 成分毎に乗算を行います。
`static int[][]` | `ones(int rowSize, int columnSize)` rowSize*columnSizeの全成分1の行列を生成します。
`static int[][]` | `permutateSelf(int[][] matrix, int[] pivot, int count, boolean rowExchange)` 行や列を交換します。
`static int[][]` | `powerElementWise(int[][] matrix, int scalar)` 全ての成分の累乗を成分とする行列を生成します。
`static int[][]` | `powerElementWise(int[][] a1, int[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static int[][]` | `powerElementWise(int scalar, int[][] matrix)` 1個の整数について、行列の各成分の累乗を求めます。
`static void` | `print(int[][] matrix, Writer output, String format, int maxColumnSize)` 出力ストリームに出力します。
`static int` | `product(int[][] matrix)` 行列の全ての成分の積を求めます。
`static int[][]` | `productColumnWise(int[][] matrix)` 列毎に全ての成分の積を計算し、計算結果を成分とする行ベクトルを生成します。
`static int[][]` | `productRowWise(int[][] matrix)` 行毎に全ての成分の積を計算し、計算結果を成分とする列ベクトルを生成します。
`static void` | `quickSort(int[] vector, int[] index, int start, int end)` ベクトルの成分を昇順にソートします。
`static int[][]` | `readMxFormat(InputStream input, MxDataHead head)` 入力ストリームから行列データ(MXフォーマット)を読み込みます。
`static int[][]` | `remElementWise(int[][] matrix, double scalar)` 成分毎の剰余関数の結果からなる行列を返します。
`static int[][]` | `removeColumnVectors(int[][] matrix, int[] columnIndex)` 指定された列を削除した行列を生成します。
`static int[][]` | `removeColumnVectors(int[][] matrix, int columnMin, int columnMax)` 指定された列を削除した行列を生成します。
`static int[][]` | `removeRowVectors(int[][] matrix, int[] rowIndex)` 指定された行を削除した行列を生成します。
`static int[][]` | `removeRowVectors(int[][] matrix, int rowMin, int rowMax)` 指定された行を削除した行列を生成します。
`static int[][]` | `reshape(int[][] matrix, int newRowSize, int newColumnSize)` 行列の成分を変えずに、行列の大きさ(行の数と列の数)を変形します。
`static int[][]` | `resize(int[][] matrix, int newRowSize, int newColSize)` `newRowSize`*`newColSize`にサイズ変更します。
`static int[]` | `series(int from, int to, int by)` `from`から`to`までの`by`飛びの整数を成分にもつ行ベクトルを返します。
`static void` | `setElements(int[][] destination, int[] index, int[][] source)` `index`で指定した各成分に行列`source`の成分を代入します。
`static void` | `setSubMatrix(int[][] destination, int[] rowIndex, int[] columnIndex, int[][] source)`
`static void` | `setSubMatrix(int[][] destination, int[] rowIndex, int columnMin, int columnMax, int[][] source)`
`static void` | `setSubMatrix(int[][] destination, int rowTo, int columnTo, int[][] source, int rowMin, int rowMax, int columnMin, int columnMax)` 配列`destination`の`rowTo`行`columnTo`列を始点として、 配列`source`の`rowMin`行`columnMin`列から `rowMax`行`columnMax`列までの値をコピーします。
`static void` | `setSubMatrix(int[][] destination, int rowMin, int rowMax, int[] columnIndex, int[][] source)`
`static void` | `setSubMatrix(int[][] destination, int rowMin, int rowMax, int columnMin, int columnMax, int[][] source)` 与えられた位置に行列を代入します。
`static void` | `setSubVector(int[] destination, int min, int max, int[] source)` 与えられた位置にベクトルを代入します。
`static void` | `setZero(int[][] matrix)` 行列の全ての成分に零を代入します。
`static org.mklab.nfc.matrix.IndexedIntElements` | `sortColumnWise(int[][] matrix)` 列毎に昇順に並び替えた行列と元の位置を示す指数を返します。
`static org.mklab.nfc.matrix.IndexedIntElements` | `sortRowWise(int[][] matrix)` 行毎に昇順に並び替えた行列と元の位置を示す指数を返します。
`static int[][]` | `subtract(int[][] a1, int[][] a2)` 行列の差を求めます。
`static int[][]` | `subtractElementWise(int[][] matrix, int scalar)` 行列の全ての成分から整数を引いた行列を生成します。
`static int` | `sum(int[][] matrix)` 行列の全ての成分も和を求めます。
`static int[][]` | `sumColumnWise(int[][] matrix)` 列毎に全ての成分の和を計算し、計算結果を成分とする行ベクトルを生成します。
`static int[][]` | `sumRowWise(int[][] matrix)` 行毎に全ての成分の和を計算し、計算結果を成分とする列ベクトルを生成します。
`static String` | `toMmString(int[][] matrix)` 行列をMMフォーマットの文字列に変換します。
`static int[][]` | `transpose(int[][] matrix)` 転置行列を生成します。
`static int[][]` | `unaryMinus(int[][] matrix)` 行列の符号を反転した行列を生成します。
`static int[][]` | `unit(int rowSize, int columnSize)` rowSize*columnSizeの単位行列を生成します。
`static int` | `variance(int[][] matrix)` 分散を求めます。
`static int[][]` | `vectorToDiagonal(int[] vector)` ベクトルの成分を対角成分とする対角行列を生成します。
`static void` | `writeMatFormat(int[][] matrix, OutputStream output)` 行列を出力ストリームにMATフォーマットで出力します。
`static void` | `writeMatFormat(int[][] matrix, String fileName)` 行列をMATフォーマットでファイルに出力します。
`static void` | `writeMxFormat(int[][] matrix, OutputStream output, String name)` 行列を出力ストリームに出力(MXフォーマット)します。

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

メソッドの詳細

### addElementWise

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

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

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

### addElementWise

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

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

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

### increment

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

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

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

### increment

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

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

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

### decrement

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

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

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

### decrement

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

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

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

### writeMatFormat

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

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

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

### writeMatFormat

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

  行列をMATフォーマットでファイルに出力します。

  パラメータ:
    `matrix` - 対象となる行列
    `fileName` - ファイル
  例外:
    `IOException` - ファイルに出力できない場合

### unaryMinus

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

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

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

### createMatrix

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

  実行列を整数行列に変換(最も近い整数に丸める)します。

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

### createUnit

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

  単位行列を生成します。

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

### isZero

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

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

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

### setZero

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

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

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

### isUnit

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

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

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

### resize

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

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

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

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

### removeColumnVectors

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

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

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

### removeColumnVectors

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

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

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

### removeRowVectors

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

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

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

### removeRowVectors

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

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

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

### toMmString

    public static final String toMmString(int[][] matrix)

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

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

### isFiniteElementWise

    public static final boolean[][] isFiniteElementWise(int[][] matrix)

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

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    有限性のboolean行列

### isInfiniteElementWise

    public static final boolean[][] isInfiniteElementWise(int[][] matrix)

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

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    無限性のboolean行列

### isNanElementWise

    public static final boolean[][] isNanElementWise(int[][] matrix)

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

  パラメータ:
    `matrix` - 対象となる行列
  戻り値:
    非数性のboolean行列

### ones

    public static int[][] ones(int rowSize,
                               int columnSize)

  rowSize*columnSizeの全成分1の行列を生成します。

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

### diagonal

    public static int[][] diagonal(int[] diagonalElements)

  対角行列を生成する

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

### unit

    public static int[][] unit(int rowSize,
                               int columnSize)

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

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

### setSubMatrix

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

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

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

### setSubMatrix

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

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

### setSubMatrix

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

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

### setSubMatrix

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

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

### setSubVector

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

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

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

### setElements

    public static void setElements(int[][] destination,
                                   int[] index,
                                   int[][] source)

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

  パラメータ:
    `destination` - 成分を代入する行列
    `index` - 成分の番号を指定する指数
    `source` - 代入するベクトル

### series

    public static int[] series(int from,
                               int to,
                               int by)

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

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

### add

    public static int[][] add(int[][] a1,
                              int[][] a2)

  行列の和を求めます。

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

### subtract

    public static int[][] subtract(int[][] a1,
                                   int[][] a2)

  行列の差を求めます。

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

### subtractElementWise

    public static int[][] subtractElementWise(int[][] matrix,
                                              int scalar)

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

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

### multiply

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

  行列に整数を掛けます。

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

### multiply

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

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

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

### multiplyElementWise

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

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

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

### powerElementWise

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

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

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

### powerElementWise

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

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

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

### powerElementWise

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

  1個の整数について、行列の各成分の累乗を求めます。

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

### divide

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

  全ての成分を整数で割る。

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

### equals

    public static final boolean equals(int[][] a1,
                                       int[][] a2)

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

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

### equals

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

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

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

### transpose

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

  転置行列を生成します。

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

### getSubMatrix

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

  部分行列を生成します。

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

### getSubVector

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

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

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

### getSubVector

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

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

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

### getSubMatrix

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

  部分行列を生成します。

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

### getSubMatrix

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

  部分行列を生成します。

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

### getSubMatrix

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

  部分行列を生成します。

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

### getSubMatrix

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

  部分行列を生成します。

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

### getSubMatrix

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

  部分行列を生成します。

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

### appendDown

    public static final int[][] appendDown(int[][] a1,
                                           int[][] a2)

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

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

### appendRight

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

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

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

### clone

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

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

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

### exchangeColumn

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

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

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

### exchangeRow

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

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

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

### copy

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

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

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

### diagonalToVector

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

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

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

### vectorToDiagonal

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

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

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

### reshape

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

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

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

### sortRowWise

    public static final org.mklab.nfc.matrix.IndexedIntElements sortRowWise(int[][] matrix)

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

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

### sortColumnWise

    public static final org.mklab.nfc.matrix.IndexedIntElements sortColumnWise(int[][] matrix)

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

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

### sum

    public static final int sum(int[][] matrix)

  行列の全ての成分も和を求めます。

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

### sumColumnWise

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

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

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

### sumRowWise

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

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

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

### cumulativeSum

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

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

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

### cumulativeSumRowWise

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

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

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

### cumulativeSumColumnWise

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

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

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

### cumulativeProduct

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

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

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

### cumulativeProductRowWise

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

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

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

### cumulativeProductColumnWise

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

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

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

### product

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

  行列の全ての成分の積を求めます。

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

### productRowWise

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

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

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

### productColumnWise

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

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

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

### meanRowWise

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

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

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

### meanColumnWise

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

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

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

### compareElements

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

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

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

### compareElements

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

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

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

### compareElements

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

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

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

### compareElements

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

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

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

### writeMxFormat

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

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

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

### readMxFormat

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

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

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

### setSubMatrix

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

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

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

### remElementWise

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

  成分毎の剰余関数の結果からなる行列を返します。

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

### quickSort

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

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

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

### medianColumnWise

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

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

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

### medianRowWise

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

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

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

### covariance

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

  共分散行列を求めます。

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

### variance

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

  分散を求めます。

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

### makeColumnVector

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

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

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

### maxElementWise

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

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

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

### minElementWise

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

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

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

### print

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

  出力ストリームに出力します。

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

### permutateSelf

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

  行や列を交換します。

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

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