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

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

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

    public final class DoubleComplexMatrixUtil

extends Object

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

バージョン:
  $Revision: 1.6 $, 2004/06/23
作成者:
  Koga Laboratory

メソッドの概要
`static void` | `addSelf(double[][] a1Re, double[][] a1Im, double[][] a2Re, double[][] a2Im)` 第一行列に第二行列を加えます。
`static DoubleComplexNumber[][]` | `clone(DoubleComplexNumber[][] matrix)` 行列の複製を生成します。
`static DoubleComplexNumber[][]` | `createArray(double[][] matrix)` 実行列を複素行列(元の行列を実部とする)に変換します。
`static DoubleComplexNumber[][]` | `createArray(double[][] realPart, double[][] imagPart)` 実部配列と虚部配列から複素行列を生成します。
`static DoubleComplexNumber[][]` | `createArray(int[][] matrix)` 整数行列を複素行列(元の行列を実部とする)に変換します。
`static double` | `frobNorm(double[][] aRe, double[][] aIm)` 複素行列のフロベニウスノルムを返します。
`static double[][]` | `getImagPartElements(DoubleComplexNumber[][] matrix)` 虚部をdoubleの2次元配列で返します。
`static double[][]` | `getRealPartElements(DoubleComplexNumber[][] matrix)` 実部をdoubleの2次元配列で返します。
`static double[][][]` | `inverse(double[][] aRe, double[][] aIm)` 複素行列の逆行列を返します。
`static double[][][]` | `inverse(double[][] aRe, double[][] aIm, double tolerance)` 複素行列の逆行列を返します。
`static double[][]` | `mix(double[][] realPart, double[][] imagPart)` 実部行列と虚部行列から実部と虚部の成分が交互に並ぶ行列を生成します。
`static double[]` | `mix(double[] realPart, double[] imagPart)` 実部ベクトルと虚部ベクトルから実部と虚部の成分が交互に並ぶベクトルを生成します。
`static double[][][]` | `multiply(double[][] aRe, double[][] aIm, double[][] bRe, double[][] bIm)` 複素行列と複素行列の積を返します。
`static void` | `multiply(double[][] ansRe, double[][] ansIm, double[][] aRe, double[][] aIm, double[][] bRe, double[][] bIm)` 複素行列と複素行列の積を返します。
`static void` | `multiply(double[][] ansRe, double[][] ansIm, double[][] aRe, double[][] aIm, double dRe, double dIm)` 行列に複素数を掛けた結果を引数として与えられた行列に代入します。
`static double[][][]` | `multiply(double[][] aRe, double[][] aIm, double dRe, double dIm)` 行列に複素数を掛けた行列を生成します。
`static void` | `multiplySelf(double[][] aRe, double[][] aIm, double scalar)` 行列に実数を乗じます。
`static void` | `multiplySelf(double[][] aRe, double[][] aIm, double dRe, double dIm)` 行列に複素数を乗じます。
`static void` | `multiplySelf(double[] aRe, double[] aIm, double scalar)` ベクトルに実数を乗じます。
`static double` | `norm(DoubleComplexNumber[][] matrix, NormType type)` 行列のノルムを返します。
`static DoubleComplexNumber[][]` | `ones(int rowSize, int columnSize)` 全ての成分が1である行列を生成します。
`static DoubleComplexNumber[][]` | `powerElementWise(double[][] matrix, DoubleComplexNumber scalar)` 実行列の成分毎の累乗(指数は複素数)を返します。
`static DoubleComplexNumber[][]` | `powerElementWise(double[][] a1, DoubleComplexNumber[][] a2)` 実行列の累乗を成分毎に返します。
`static DoubleComplexNumber[][]` | `powerElementWise(double scalar, DoubleComplexNumber[][] matrix)` 実数の成分毎の累乗を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `powerElementWise(int[][] matrix, DoubleComplexNumber scalar)` 全ての成分の累乗を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `powerElementWise(int[][] a1, DoubleComplexNumber[][] a2)` 行列の成分毎に累乗を計算し、計算結果を成分とする行列を生成します。
`static void` | `print(DoubleComplexNumber[][] matrix, Writer output, String format, GridElementAlignment alignment, int maxColumnSize)` ライターに出力します。
`static DoubleComplexNumber[][]` | `randomNormal(int rowSize, int columnSize)` 正規分布の乱数を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `randomNormal(int rowSize, int columnSize, long seed)` 正規分布の乱数を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `randomUniform(int rowSize, int columnSize)` 一様分布の乱数を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `randomUniform(int rowSize, int columnSize, long seed)` 一様分布の乱数を成分とする行列を生成します。
`static DoubleComplexNumber[][]` | `readMatFormat(int rowSize, int columnSize, StreamTokenizer st)` ストリームトークンナイザから行列(MATフォーマット)を読み込みます。
`static DoubleComplexNumber[][]` | `readMxFormat(InputStream input, MxDataHead head)` 入力ストリームから行列データ(MXフォーマット)を読み込みます。
`static double[]` | `scalarProduct(double[][] aRe, double[][] aIm, double[][] bRe, double[][] bIm)` 複素ベクトルのスカラー積(内積)を返します。
`static void` | `setImagPartElements(DoubleComplexNumber[][] matrix, double[][] imagPart)` 虚部を設定します。
`static void` | `setRealPartElements(DoubleComplexNumber[][] matrix, double[][] realPart)` 実部を設定します。
`static void` | `subtract(double[][] ansRe, double[][] ansIm, double[][] aRe, double[][] aIm, double[][] bRe, double[][] bIm)` 複素行列の差を返します。
`static String` | `toMmString(DoubleComplexNumber[][] matrix, String elementFormat)` 行列をMMフォーマットの文字列に変換します。
`static DoubleComplexNumber[][]` | `unit(int rowSize, int columnSize)` 単位行列を生成します。
`static void` | `unMix(double[][] mixed, double[][] realPart, double[][] imagPart)` 実部と虚部が交互に並ぶ行列から実部行列を虚部行列を生成します。
`static void` | `unMix(double[] mixed, double[] realPart, double[] imagPart)` 実部と虚部が交互に並ぶベクトルから実部ベクトルを虚部ベクトルを生成します。
`static void` | `writeMatFormat(DoubleComplexNumber[][] matrix, OutputStream output)` 複素行列のデータを(MATフォーマット)で出力ストリームに出力します。
`static void` | `writeMatFormat(DoubleComplexNumber[][] matrix, String fileName)` 複素行列をMATフォーマットでファイルに保存します。
`static void` | `writeMxFormat(DoubleComplexNumber[][] matrix, OutputStream output, String name)` 行列を出力ストリームに(MXフォーマット)で出力します。

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

メソッドの詳細

### createArray

    public static DoubleComplexNumber[][] createArray(double[][] realPart,
                                                      double[][] imagPart)

  実部配列と虚部配列から複素行列を生成します。

  パラメータ:
    `realPart` - 実部配列
    `imagPart` - 複素配列
  戻り値:
    複素配列

### createArray

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

  整数行列を複素行列(元の行列を実部とする)に変換します。

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

### createArray

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

  実行列を複素行列(元の行列を実部とする)に変換します。

  パラメータ:
    `matrix` - 実行列
  戻り値:
    複素行列

### addSelf

    public static final void addSelf(double[][] a1Re,
                                     double[][] a1Im,
                                     double[][] a2Re,
                                     double[][] a2Im)

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

  パラメータ:
    `a1Re` - 第一行列の実部
    `a1Im` - 第一行列の虚部
    `a2Re` - 第二行列の実部
    `a2Im` - 第二行列の虚部

### multiplySelf

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

  行列に実数を乗じます。

  パラメータ:
    `aRe` - 対象となる行列の実部
    `aIm` - 対象となる行列の虚部
    `scalar` - 実数

### multiplySelf

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

  ベクトルに実数を乗じます。

  パラメータ:
    `aRe` - 対象となるベクトルの実部
    `aIm` - 対象となるベクトルの虚部
    `scalar` - 実数

### multiplySelf

    public static final void multiplySelf(double[][] aRe,
                                          double[][] aIm,
                                          double dRe,
                                          double dIm)

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

  パラメータ:
    `aRe` - 対象となる行列の実部
    `aIm` - 対象となる行列の虚部
    `dRe` - 複素数の実部
    `dIm` - 複素数の虚部

### multiply

    public static final double[][][] multiply(double[][] aRe,
                                              double[][] aIm,
                                              double dRe,
                                              double dIm)

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

  パラメータ:
    `aRe` - 対象となる行列の実部
    `aIm` - 対象となる行列の虚部
    `dRe` - 複素数の虚部
    `dIm` - 複素数の実部
  戻り値:
    生成された行列

### multiply

    public static final void multiply(double[][] ansRe,
                                      double[][] ansIm,
                                      double[][] aRe,
                                      double[][] aIm,
                                      double dRe,
                                      double dIm)

  行列に複素数を掛けた結果を引数として与えられた行列に代入します。

  パラメータ:
    `ansRe` - 結果を代入する行列の実部
    `ansIm` - 結果を代入する行列の虚部
    `aRe` - 対象となる行列の実部
    `aIm` - 対象となる行列の虚部
    `dRe` - 複素数の実部
    `dIm` - 複素数の虚部

### scalarProduct

    public static double[] scalarProduct(double[][] aRe,
                                         double[][] aIm,
                                         double[][] bRe,
                                         double[][] bIm)

  複素ベクトルのスカラー積(内積)を返します。

  パラメータ:
    `aRe` - 第一ベクトルの実部
    `aIm` - 第一ベクトルの虚部
    `bRe` - 第二ベクトルの実部
    `bIm` - 第二ベクトルの虚部
  戻り値:
    スカラー積(内積)

### mix

    public static double[][] mix(double[][] realPart,
                                 double[][] imagPart)

  実部行列と虚部行列から実部と虚部の成分が交互に並ぶ行列を生成します。

  パラメータ:
    `realPart` - 実部行列
    `imagPart` - 虚部行列
  戻り値:
    実部と虚部の成分が交互に並ぶ行列

### unMix

    public static void unMix(double[][] mixed,
                             double[][] realPart,
                             double[][] imagPart)

  実部と虚部が交互に並ぶ行列から実部行列を虚部行列を生成します。

  パラメータ:
    `mixed` - 実部と虚部の成分が交互に並ぶ行列
    `realPart` - 実部行列
    `imagPart` - 虚部行列

### mix

    public static double[] mix(double[] realPart,
                               double[] imagPart)

  実部ベクトルと虚部ベクトルから実部と虚部の成分が交互に並ぶベクトルを生成します。

  パラメータ:
    `realPart` - 実部ベクトル
    `imagPart` - 虚部ベクトル
  戻り値:
    実部と虚部の成分が交互に並ぶベクトル

### unMix

    public static void unMix(double[] mixed,
                             double[] realPart,
                             double[] imagPart)

  実部と虚部が交互に並ぶベクトルから実部ベクトルを虚部ベクトルを生成します。

  パラメータ:
    `mixed` - 実部と虚部が交互に並ぶベクトル
    `realPart` - 実部ベクトル
    `imagPart` - 虚部ベクトル

### frobNorm

    public static final double frobNorm(double[][] aRe,
                                        double[][] aIm)

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

  パラメータ:
    `aRe` - 実部行列
    `aIm` - 虚部行列
  戻り値:
    フロベニウスノルム

### inverse

    public static final double[][][] inverse(double[][] aRe,
                                             double[][] aIm)

  複素行列の逆行列を返します。

  パラメータ:
    `aRe` - 実部行列
    `aIm` - 虚部行列
  戻り値:
    逆行列の実部行列と虚部行列の配列

### inverse

    public static final double[][][] inverse(double[][] aRe,
                                             double[][] aIm,
                                             double tolerance)

  複素行列の逆行列を返します。

  パラメータ:
    `aRe` - 実部行列
    `aIm` - 虚部行列
    `tolerance` - 許容誤差
  戻り値:
    逆行列の実部行列と虚部行列の配列

### multiply

    public static final double[][][] multiply(double[][] aRe,
                                              double[][] aIm,
                                              double[][] bRe,
                                              double[][] bIm)

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

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

### multiply

    public static final void multiply(double[][] ansRe,
                                      double[][] ansIm,
                                      double[][] aRe,
                                      double[][] aIm,
                                      double[][] bRe,
                                      double[][] bIm)

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

  パラメータ:
    `ansRe` - 計算結果の実部
    `ansIm` - 計算結果の虚部
    `aRe` - 第一行列の実部
    `aIm` - 第一行列の虚部
    `bRe` - 第二行列の実部
    `bIm` - 第二行列の虚部

### subtract

    public static final void subtract(double[][] ansRe,
                                      double[][] ansIm,
                                      double[][] aRe,
                                      double[][] aIm,
                                      double[][] bRe,
                                      double[][] bIm)

  複素行列の差を返します。

  パラメータ:
    `ansRe` - 複素行列の差の実部
    `ansIm` - 複素行列の差の虚部
    `aRe` - 引かれる行列の実部
    `aIm` - 引かれる行列の虚部
    `bRe` - 引く行列の実部
    `bIm` - 引く行列の虚部

### writeMatFormat

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

  複素行列のデータを(MATフォーマット)で出力ストリームに出力します。

  パラメータ:
    `matrix` - 複素行列
    `output` - 出力ストリーム
  例外:
    `IOException` - 出力エラーが発生した場合

### writeMatFormat

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

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

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

### powerElementWise

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

  実行列の累乗を成分毎に返します。

  パラメータ:
    `a1` - 実行列
    `a2` - 累乗の指数を成分とする複素行列
  戻り値:
    実行列の累乗(成分毎)を成分とする行列

### powerElementWise

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

  実行列の成分毎の累乗(指数は複素数)を返します。

  パラメータ:
    `matrix` - 実行列
    `scalar` - 複素数(指数)
  戻り値:
    実行列の成分毎の累乗(指数は複素数)を成分とする行列

### clone

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

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

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

### readMatFormat

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

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

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

### writeMxFormat

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

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

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

### readMxFormat

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

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

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

### toMmString

    public static final String toMmString(DoubleComplexNumber[][] matrix,
                                          String elementFormat)

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

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

### norm

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

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

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

### getRealPartElements

    public static final double[][] getRealPartElements(DoubleComplexNumber[][] matrix)

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

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

### getImagPartElements

    public static final double[][] getImagPartElements(DoubleComplexNumber[][] matrix)

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

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

### unit

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

  単位行列を生成します。

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

### ones

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

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

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

### powerElementWise

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

  実数の成分毎の累乗を成分とする行列を生成します。

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

### powerElementWise

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

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

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

### powerElementWise

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

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

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

### print

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

  ライターに出力します。

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

### setRealPartElements

    public static void setRealPartElements(DoubleComplexNumber[][] matrix,
                                           double[][] realPart)

  実部を設定します。

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

### setImagPartElements

    public static void setImagPartElements(DoubleComplexNumber[][] matrix,
                                           double[][] imagPart)

  虚部を設定します。

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

### randomUniform

    public static DoubleComplexNumber[][] randomUniform(int rowSize,
                                                        int columnSize)

  一様分布の乱数を成分とする行列を生成します。

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

### randomUniform

    public static DoubleComplexNumber[][] randomUniform(int rowSize,
                                                        int columnSize,
                                                        long seed)

  一様分布の乱数を成分とする行列を生成します。

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

### randomNormal

    public static final DoubleComplexNumber[][] randomNormal(int rowSize,
                                                             int columnSize)

  正規分布の乱数を成分とする行列を生成します。

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

### randomNormal

    public static final DoubleComplexNumber[][] randomNormal(int rowSize,
                                                             int columnSize,
                                                             long seed)

  正規分布の乱数を成分とする行列を生成します。

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

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