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

## org.mklab.nfc.scalar
クラス ComplexScalar<T extends NumericalScalar<T>>

    java.lang.Object
      org.mklab.nfc.scalar.AbstractScalar<E>
          org.mklab.nfc.scalar.AbstractNumericalScalar<ComplexScalar<T>>
              org.mklab.nfc.scalar.ComplexScalar<T>

型パラメータ:
  `T` - 実部と虚部の型

すべての実装されたインタフェース:
  Serializable, Cloneable, GridElement<ComplexScalar<T>>, NumericalScalar<ComplexScalar<T>>, RoundableToInteger<ComplexScalar<T>>, Scalar<ComplexScalar<T>>

    public class ComplexScalar<T extends NumericalScalar<T>>

extends AbstractNumericalScalar<ComplexScalar<T>>

複素スカラーを表わすクラスです。

バージョン:
  $Revision: 1.33 $, 2004/06/22
作成者:
  koga
関連項目:
  直列化された形式

コンストラクタの概要
`ComplexScalar(NumericalScalar realPart, NumericalScalar imagPart)` 新しく生成された`ComplexScalar`オブジェクトを初期化します。

メソッドの概要
`T` | `abs()` 絶対値を返します。
`T` | `abs2()` 絶対値の2乗を返します。
`ComplexScalar<T>` | `acos()` 逆余弦関数の値を返します。
`ComplexScalar<T>` | `acosh()` 逆双曲線余弦関数の値を返します。
`ComplexScalar<T>` | `add(ComplexScalar<T> value)` 複素数との和を返します。
`ComplexScalar<T>` | `add(double value)` 値を加えます。
`ComplexScalar<T>` | `add(int value)` 値を加えます。
`Scalar<?>` | `add(Scalar<?> value)` 値を加えた成分を生成します。
`ComplexScalar<T>` | `addSelf(ComplexScalar<T> value)` 自身に複素数を加えます。
`ComplexScalar<T>` | `addSelf(Scalar value)` 自身に値を加えます。
`ComplexScalar<T>` | `addSelft(double value)` 自身に実数を加えます。
`T` | `arg()` 偏角を返します。
`ComplexScalar<T>` | `asin()` 逆正弦関数の値を返します。
`ComplexScalar<T>` | `asinh()` 逆双曲線関数の値を返します。
`ComplexScalar<T>` | `atan()` 逆正接の値を返します。
`ComplexScalar<T>` | `atan2(NumericalScalar value)` 逆正接(2)の値を返します。
`ComplexScalar<T>` | `atanh()` 逆双曲線正接関数の値を返します。
`ComplexScalar<T>` | `ceil()` 大きい整数に丸めます。
`ComplexScalar<T>` | `clone()` see java.lang.Object#clone()
`boolean` | `compare(String operator, ComplexScalar<T> opponent)` `opponent`を`operator`で指定された演算子で比較します。
`boolean` | `compare(String operator, double opponent)` `opponent`を`operator`で指定された演算子で比較します。
`boolean` | `compare(String operator, GridElement opponent)` `opponent`を`operator`で指定された演算子で比較します。
`boolean` | `compare(String operator, int opponent)` `opponent`を`operator`で指定された演算子で比較します。
`ComplexScalar<T>` | `conjugate()` 共役数を返します。
`ComplexScalar<T>` | `cos()` 余弦関数の値を返します。
`ComplexScalar<T>` | `cosh()` 双曲線関数の値を返します。
`ComplexScalar<T>` | `create(double value)` 与えられたdouble型に対応する値を返します。
`ComplexScalar<T>` | `create(int value)` 与えられたint型に対応する値を返します。
`ComplexScalar<T>[]` | `createArray(int size)` グリッドの一次元配列を生成します。
`ComplexScalar<T>[][]` | `createArray(int rowSize, int columnSize)` グリッドの2次元配列を生成します。
`ComplexScalar<T>` | `createE()` ネイピアの数(自然対数の底)を返します。
`NumericalMatrix<ComplexScalar<T>>` | `createGrid(int rowSize, int columnSize, Scalar<? extends Scalar<?>>[][] elements)` 行列を生成します。
`NumericalMatrix<ComplexScalar<T>>` | `createGrid(Scalar<? extends Scalar<?>>[] elements)` ベクトルを生成します。
`ComplexScalar<T>` | `createImagUnit()` 虚部単位を返します。
`ComplexScalar<T>` | `createPI()` 円周率PIを返します。
`RandomGenerator<ComplexScalar<T>>` | `createUniformRandomGenerator()` 一様分布の乱数生成器を返します。
`ComplexScalar<T>` | `createUnit()` 単位成分を生成します。
`ComplexScalar<T>` | `createZero()` 零(デフォルトの初期値)を生成します。
`ComplexScalar<T>` | `divide(ComplexScalar<T> value)` 複素数との商(`this`*`value` -1 )を返します。
`ComplexScalar<T>` | `divide(double value)` 値で割ります。
`ComplexScalar<T>` | `divide(int value)` 値で割ります。
`Scalar<?>` | `divide(Scalar<?> value)` 値で割ります。
`boolean` | `equals(ComplexScalar<T> opponent, double tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(ComplexScalar<T> opponent, NumericalScalar<?> tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(double opponent)` 実数と等しいか判定します。
`boolean` | `equals(NumericalScalar opponent, NumericalScalar tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(Object opponent)`
`boolean` | `equals(Scalar opponent, double tolerance)` 許容範囲内で等しいか判定します。
`ComplexScalar<T>` | `exp()` 指数関数の値を返します。
`ComplexScalar<T>` | `fix()` ゼロ方向の整数に丸めます。
`ComplexScalar<T>` | `floor()` 小さい整数に丸めます。
`Operator` | `getAddOperator()` 足し算のオペレータを返します。
`Operator` | `getAtan2Operator()` 逆正接(2)のオペレータを返します。
`Operator` | `getDivideOperator()` 割り算のオペレータを返します。
`T` | `getImaginaryPart()` 虚部を返します。
`ComplexScalar<T>` | `getInfinity()` 無限大を返します。
`Operator` | `getLeftDivideOperator()` 左からの割り算のオペレータを返します。
`NumericalScalar<?>` | `getMachineEpsilon()` 機種精度(Machine Epsilon)を返します。
`Operator` | `getMultiplyOperator()` 掛け算のオペレータを返します。
`ComplexScalar<T>` | `getNaN()` NaN(Not a Number)を返します。
`Operator` | `getPowerOperator()` 累乗のオペレータを返します。
`T` | `getRealPart()` 実部を返します。
`Operator` | `getSubtractOperator()` 引き算のオペレータを返します。
`int` | `hashCode()` Override hashCode.
`ComplexScalar<T>` | `inverse()` 逆数を求めます。
`boolean` | `isComplex()` 複素数であるか判定します。
`boolean` | `isFinite()` 有限であるか判定します。
`boolean` | `isGreaterThan(double opponent)` `opponent`より大きいか判定します。
`boolean` | `isGreaterThan(int opponent)` `opponent`より大きいか判定します。
`boolean` | `isGreaterThan(NumericalScalar<?> opponent)` `opponent`より大きいか判定します。
`boolean` | `isGreaterThanOrEquals(double opponent)` `opponent`以上であるか判定します。
`boolean` | `isGreaterThanOrEquals(int opponent)` `opponent`以上であるか判定します。
`boolean` | `isGreaterThanOrEquals(NumericalScalar<?> opponent)` `opponent`以上であるか判定します。
`boolean` | `isInfinite()` 無限大であるか判定します。
`boolean` | `isLessThan(double opponent)` `opponent`より小さいか判定します。
`boolean` | `isLessThan(int opponent)` `opponent`より小さいか判定します。
`boolean` | `isLessThan(NumericalScalar<?> opponent)` `opponent`より小さいか判定します。
`boolean` | `isLessThanOrEquals(double opponent)` `opponent`以下であるか判定します。
`boolean` | `isLessThanOrEquals(int opponent)` `opponent`以下であるか判定します。
`boolean` | `isLessThanOrEquals(NumericalScalar<?> opponent)` `opponent`以下であるか判定します。
`boolean` | `isNaN()` NaNであるか判定します。
`boolean` | `isReal()` 実数であるか判定します。
`boolean` | `isTransformableFrom(GridElement<?> value)` 引数で与えられた型からこの型へ変換可能か判定します。
`boolean` | `isTransformableTo(GridElement<?> value)` この型から引数で与えられた型へ変換可能か判定します。
`boolean` | `isUnit()` １(単位元)であるか判定します。
`boolean` | `isUnit(double tolerance)` 1(単位元)であるか判定します。
`boolean` | `isUnit(NumericalScalar<?> tolerance)` 1(単位元)であるか判定します。
`boolean` | `isZero()` 零(デフォルトの初期値)であるか判定します。
`boolean` | `isZero(double tolerance)` 零であるか判定します。
`boolean` | `isZero(NumericalScalar<?> tolerance)` 零であるか判定します。
`ComplexScalar<T>` | `leftDivide(ComplexScalar<T> value)` 自身の逆数と複素数cの積(`this` -1 *`value`)を返します。
`ComplexScalar<T>` | `leftDivide(double value)` 値を割ります。
`ComplexScalar<T>` | `leftDivide(int value)` 値を割ります。
`Scalar<?>` | `leftDivide(Scalar<?> value)` 値を割ります。
`ComplexScalar<T>` | `log()` 自然対数の値を返します。
`ComplexScalar<T>` | `log10()` 常用対数の値を返します。
`ComplexScalar<T>` | `multiply(ComplexScalar<T> value)` 複素数との積を返します。
`ComplexScalar<T>` | `multiply(double value)` 値を掛けます。
`ComplexScalar<T>` | `multiply(int value)` 値を掛けます。
`Scalar<?>` | `multiply(Scalar<?> value)` 値を掛けます。
`ComplexScalar<T>` | `multiplySelf(ComplexScalar<T> value)` 自身に複素数を乗じます。
`ComplexScalar<T>` | `multiplySelf(double value)` 自身に実数を乗じます。
`ComplexScalar<T>` | `power(ComplexScalar<T> scalar)` 複素`scalar`乗(`this` `scalar`)を返します。
`ComplexScalar<T>` | `power(double scalar)` 実数`scalar`乗(`this` `scalar`)を返します。
`ComplexScalar<T>` | `power(int scalar)` 累乗を返します。
`ComplexScalar<T>` | `power(NumericalScalar value)` `scalar`乗(`this` `scalar`)を返します。
`void` | `print()` 標準出力に出力します。
`void` | `print(String name)` 標準出力に出力します。
`ComplexScalar<T>` | `round()` 最も近い整数に丸めます。
`ComplexScalar<T>` | `roundToZero(double tolerance)` 絶対値が小さい成分を0に丸めます。
`ComplexScalar<T>` | `roundToZero(NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`void` | `setImaginaryPart(double imagPart)` 虚部を設定します。
`void` | `setImaginaryPart(int imagPart)` 虚部を設定します。
`void` | `setImaginaryPart(Scalar<?> imagPart)` 虚部を設定します。
`void` | `setImagPart(T imagPart)` 虚部を設定します。
`void` | `setRealPart(double realPart)` 実部を設定します。
`void` | `setRealPart(int realPart)` 実部を設定します。
`void` | `setRealPart(Scalar<?> realPart)` 実部を設定します。
`void` | `setRealPart(T realPart)` 実部を設定します。
`ComplexScalar<T>` | `sin()` 正弦関数の値を返します。
`ComplexScalar<T>` | `sinh()` 双曲線正弦関数の値を返します。
`ComplexScalar<T>` | `sqrt()` 平方根を返します。
`ComplexScalar<T>` | `subtract(ComplexScalar<T> value)` 複素数との差を返します。
`ComplexScalar<T>` | `subtract(double value)` 値を引く。
`ComplexScalar<T>` | `subtract(int value)` 値を引く。
`Scalar<?>` | `subtract(Scalar<?> value)` 値を引きます。
`ComplexScalar<T>` | `tan()` 正接関数の値を返します。
`ComplexScalar<T>` | `tanh()` 双曲線正接関数の値を返します。
`ComplexScalar<T>` | `toComplex()` 複素成分に変換します。
`String` | `toString()` 文字列に変換します。
`String` | `toString(String valueFormat)` 文字列に変換します。
`ComplexScalar<T>` | `transformFrom(double value)` 実数から成分を生成します。
`ComplexScalar<T>` | `transformFrom(GridElement<?> value)` 引数で与えられた型からこの型へ変換します。
`ComplexScalar<T>` | `transformFrom(int value)` 整数から成分を生成します。
`GridElement<?>` | `transformTo(GridElement<?> value)` この型から引数で与えられた型へ変換します。
`ComplexScalar<T>` | `unaryMinus()` 符号を反転した値を返します。
`ComplexScalar<T>` | `valueOf(String numberString)` 文字列に対応する数を返します。

クラス org.mklab.nfc.scalar.AbstractNumericalScalar から継承されたメソッド
`max, max, max, min, min, min, modulus, remainder`

クラス org.mklab.nfc.scalar.AbstractScalar から継承されたメソッド
`createGrid, createGrid, createGrid, createGrid, createZeroGrid, createZeroGrid, getDefaultFormat, getFormat, setDefaultFormat, setFormat, transformToSameClass`

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

インタフェース org.mklab.nfc.scalar.Scalar から継承されたメソッド
`createGrid, createGrid, createGrid, createGrid, createZeroGrid, createZeroGrid, getFormat, setFormat`

コンストラクタの詳細

### ComplexScalar

    public ComplexScalar(NumericalScalar realPart,
                         NumericalScalar imagPart)

  新しく生成された`ComplexScalar`オブジェクトを初期化します。

  パラメータ:
    `realPart` - 実部
    `imagPart` - 虚部

メソッドの詳細

### equals

    public boolean equals(Object opponent)

  オーバーライド:
    クラス `Object` 内の `equals`
  関連項目:
    `Object.equals(java.lang.Object)`

### equals

    public boolean equals(Scalar opponent,
                          double tolerance)

  インタフェース `Scalar` の記述:
  許容範囲内で等しいか判定します。

  定義:
    インタフェース `Scalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `equals`
  オーバーライド:
    クラス `AbstractScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `equals`
  パラメータ:
    `opponent` - 比較する値
    `tolerance` - 許容誤差
  戻り値:
    等しければ(差の絶対値がtolerance以下)true、そうでなければfalse
  関連項目:
    `Scalar.equals(org.mklab.nfc.scalar.Scalar, double)`

### equals

    public boolean equals(NumericalScalar opponent,
                          NumericalScalar tolerance)

  インタフェース `NumericalScalar` の記述:
  許容範囲内で等しいか判定します。

  定義:
    インタフェース `NumericalScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `equals`
  オーバーライド:
    クラス `AbstractNumericalScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `equals`
  パラメータ:
    `opponent` - 比較する値
    `tolerance` - 許容誤差
  戻り値:
    等しい(差の絶対値がtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.equals(org.mklab.nfc.scalar.NumericalScalar, org.mklab.nfc.scalar.NumericalScalar)`

### equals

    public boolean equals(ComplexScalar<T> opponent,
                          double tolerance)

  許容範囲内で等しいか判定します。

  パラメータ:
    `opponent` - 比較する複素数成分
    `tolerance` - 許容誤差
  戻り値:
    許容範囲内で等しければtrue、そうでなければfalse

### equals

    public boolean equals(ComplexScalar<T> opponent,
                          NumericalScalar<?> tolerance)

  許容範囲内で等しいか判定します。

  パラメータ:
    `opponent` - 比較する複素数成分
    `tolerance` - 許容誤差
  戻り値:
    許容範囲内で等しければtrue、そうでなければfalse

### equals

    public boolean equals(double opponent)

  実数と等しいか判定します。

  パラメータ:
    `opponent` - 比較する実数
  戻り値:
    等しければtrue、そうでなければfalse

### clone

    public ComplexScalar<T> clone()

  クラス `AbstractNumericalScalar` の記述:
  see java.lang.Object#clone()

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `clone`
  オーバーライド:
    クラス `AbstractNumericalScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `clone`
  戻り値:
    生成した複製
  関連項目:
    `AbstractScalar.clone()`

### toString

    public String toString()

  インタフェース `GridElement` の記述:
  文字列に変換します。

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `toString`
  オーバーライド:
    クラス `Object` 内の `toString`
  戻り値:
    変換結果の文字列
  関連項目:
    `Object.toString()`

### toString

    public String toString(String valueFormat)

  インタフェース `GridElement` の記述:
  文字列に変換します。

  パラメータ:
    `valueFormat` - 値のフォーマット
  戻り値:
    変換結果の文字列
  関連項目:
    `GridElement.toString(java.lang.String)`

### setRealPart

    public void setRealPart(int realPart)

  インタフェース `Scalar` の記述:
  実部を設定します。

  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(int)`

### setRealPart

    public void setRealPart(double realPart)

  インタフェース `Scalar` の記述:
  実部を設定します。

  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(double)`

### setRealPart

    public void setRealPart(T realPart)

  実部を設定します。

  パラメータ:
    `realPart` - 実部

### setRealPart

    public void setRealPart(Scalar<?> realPart)

  インタフェース `Scalar` の記述:
  実部を設定します。

  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(org.mklab.nfc.scalar.Scalar)`

### getRealPart

    public T getRealPart()

  インタフェース `Scalar` の記述:
  実部を返します。

  戻り値:
    実部
  関連項目:
    `Scalar.getRealPart()`

### setImaginaryPart

    public void setImaginaryPart(int imagPart)

  インタフェース `Scalar` の記述:
  虚部を設定します。

  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(int)`

### setImaginaryPart

    public void setImaginaryPart(double imagPart)

  インタフェース `Scalar` の記述:
  虚部を設定します。

  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(double)`

### setImagPart

    public void setImagPart(T imagPart)

  虚部を設定します。

  パラメータ:
    `imagPart` - 虚部

### setImaginaryPart

    public void setImaginaryPart(Scalar<?> imagPart)

  インタフェース `Scalar` の記述:
  虚部を設定します。

  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(org.mklab.nfc.scalar.Scalar)`

### getImaginaryPart

    public T getImaginaryPart()

  インタフェース `Scalar` の記述:
  虚部を返します。

  戻り値:
    虚部
  関連項目:
    `Scalar.getImaginaryPart()`

### add

    public Scalar<?> add(Scalar<?> value)

  インタフェース `Scalar` の記述:
  値を加えた成分を生成します。

  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(org.mklab.nfc.scalar.Scalar)`

### add

    public ComplexScalar<T> add(ComplexScalar<T> value)

  複素数との和を返します。

  パラメータ:
    `value` - 加える複素数
  戻り値:
    複素数との和

### addSelf

    public ComplexScalar<T> addSelf(ComplexScalar<T> value)

  自身に複素数を加えます。

  パラメータ:
    `value` - 加える複素数
  戻り値:
    自身

### addSelf

    public ComplexScalar<T> addSelf(Scalar value)

  インタフェース `Scalar` の記述:
  自身に値を加えます。

  パラメータ:
    `value` - 加える値
  戻り値:
    自身
  関連項目:
    `Scalar.addSelf(org.mklab.nfc.scalar.Scalar)`

### add

    public ComplexScalar<T> add(double value)

  インタフェース `Scalar` の記述:
  値を加えます。

  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(double)`

### add

    public ComplexScalar<T> add(int value)

  インタフェース `Scalar` の記述:
  値を加えます。

  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(int)`

### addSelft

    public ComplexScalar<T> addSelft(double value)

  自身に実数を加えます。

  パラメータ:
    `value` - 加える実数
  戻り値:
    自身

### subtract

    public Scalar<?> subtract(Scalar<?> value)

  インタフェース `Scalar` の記述:
  値を引きます。

  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(org.mklab.nfc.scalar.Scalar)`

### subtract

    public ComplexScalar<T> subtract(ComplexScalar<T> value)

  複素数との差を返します。

  パラメータ:
    `value` - 引く複素数
  戻り値:
    複素数との差

### subtract

    public ComplexScalar<T> subtract(double value)

  インタフェース `Scalar` の記述:
  値を引く。

  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(double)`

### subtract

    public ComplexScalar<T> subtract(int value)

  インタフェース `Scalar` の記述:
  値を引く。

  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(int)`

### multiply

    public Scalar<?> multiply(Scalar<?> value)

  インタフェース `Scalar` の記述:
  値を掛けます。

  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(org.mklab.nfc.scalar.Scalar)`

### multiply

    public ComplexScalar<T> multiply(ComplexScalar<T> value)

  複素数との積を返します。

  パラメータ:
    `value` - 乗じる複素数
  戻り値:
    複素数との積

### multiplySelf

    public ComplexScalar<T> multiplySelf(ComplexScalar<T> value)

  自身に複素数を乗じます。

  パラメータ:
    `value` - 乗じる複素数
  戻り値:
    自身

### multiply

    public ComplexScalar<T> multiply(double value)

  インタフェース `Scalar` の記述:
  値を掛けます。

  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(double)`

### multiply

    public ComplexScalar<T> multiply(int value)

  インタフェース `Scalar` の記述:
  値を掛けます。

  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(int)`

### multiplySelf

    public ComplexScalar<T> multiplySelf(double value)

  自身に実数を乗じます。

  パラメータ:
    `value` - 乗じる実数
  戻り値:
    自身

### conjugate

    public ComplexScalar<T> conjugate()

  インタフェース `Scalar` の記述:
  共役数を返します。

  戻り値:
    共役数
  関連項目:
    `Scalar.conjugate()`

### inverse

    public ComplexScalar<T> inverse()

  インタフェース `Scalar` の記述:
  逆数を求めます。

  戻り値:
    逆数
  関連項目:
    `Scalar.inverse()`

### divide

    public Scalar<?> divide(Scalar<?> value)

  インタフェース `Scalar` の記述:
  値で割ります。

  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(org.mklab.nfc.scalar.Scalar)`

### divide

    public ComplexScalar<T> divide(ComplexScalar<T> value)

  複素数との商(`this`*`value` -1 )を返します。

  パラメータ:
    `value` - 割る複素数
  戻り値:
    複素数との商(this*c -1 )

### divide

    public ComplexScalar<T> divide(double value)

  インタフェース `Scalar` の記述:
  値で割ります。

  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(double)`

### divide

    public ComplexScalar<T> divide(int value)

  インタフェース `Scalar` の記述:
  値で割ります。

  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(int)`

### leftDivide

    public Scalar<?> leftDivide(Scalar<?> value)

  インタフェース `Scalar` の記述:
  値を割ります。

  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(org.mklab.nfc.scalar.Scalar)`

### leftDivide

    public ComplexScalar<T> leftDivide(ComplexScalar<T> value)

  自身の逆数と複素数cの積(`this` -1 *`value`)を返します。

  パラメータ:
    `value` - 複素数
  戻り値:
    自身の逆数とcの積

### leftDivide

    public ComplexScalar<T> leftDivide(double value)

  インタフェース `Scalar` の記述:
  値を割ります。

  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(double)`

### leftDivide

    public ComplexScalar<T> leftDivide(int value)

  インタフェース `Scalar` の記述:
  値を割ります。

  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(int)`

### power

    public ComplexScalar<T> power(int scalar)

  インタフェース `Scalar` の記述:
  累乗を返します。

  パラメータ:
    `scalar` - 指数
  戻り値:
    累乗
  関連項目:
    `Scalar.power(int)`

### unaryMinus

    public ComplexScalar<T> unaryMinus()

  インタフェース `Scalar` の記述:
  符号を反転した値を返します。

  戻り値:
    符号を反転した値
  関連項目:
    `Scalar.unaryMinus()`

### fix

    public ComplexScalar<T> fix()

  インタフェース `RoundableToInteger` の記述:
  ゼロ方向の整数に丸めます。

  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.fix()`

### round

    public ComplexScalar<T> round()

  インタフェース `RoundableToInteger` の記述:
  最も近い整数に丸めます。

  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.round()`

### roundToZero

    public ComplexScalar<T> roundToZero(double tolerance)

  インタフェース `RoundableToInteger` の記述:
  絶対値が小さい成分を0に丸めます。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.roundToZero(double)`

### roundToZero

    public ComplexScalar<T> roundToZero(NumericalScalar<?> tolerance)

  インタフェース `RoundableToInteger` の記述:
  絶対値が小さい成分を0に丸めます。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.roundToZero(org.mklab.nfc.scalar.NumericalScalar)`

### ceil

    public ComplexScalar<T> ceil()

  インタフェース `RoundableToInteger` の記述:
  大きい整数に丸めます。

  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.ceil()`

### floor

    public ComplexScalar<T> floor()

  インタフェース `RoundableToInteger` の記述:
  小さい整数に丸めます。

  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.floor()`

### print

    public void print()

  標準出力に出力します。

### print

    public void print(String name)

  標準出力に出力します。

  パラメータ:
    `name` - 名前

### isZero

    public boolean isZero()

  インタフェース `GridElement` の記述:
  零(デフォルトの初期値)であるか判定します。

  戻り値:
    零(デフォルトの初期値)ならばtrue、そうでなければfalse
  関連項目:
    `GridElement.isZero()`

### isZero

    public boolean isZero(double tolerance)

  インタフェース `Scalar` の記述:
  零であるか判定します。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零(大きさがtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isZero(double)`

### isZero

    public boolean isZero(NumericalScalar<?> tolerance)

  インタフェース `Scalar` の記述:
  零であるか判定します。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零(絶対値がtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isZero(org.mklab.nfc.scalar.NumericalScalar)`

### isUnit

    public boolean isUnit()

  インタフェース `Scalar` の記述:
  １(単位元)であるか判定します。

  戻り値:
    １(単位元)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isUnit()`

### isUnit

    public boolean isUnit(double tolerance)

  インタフェース `Scalar` の記述:
  1(単位元)であるか判定します。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    1(単位元)(1との差の絶対値がtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isUnit(double)`

### isUnit

    public boolean isUnit(NumericalScalar<?> tolerance)

  インタフェース `Scalar` の記述:
  1(単位元)であるか判定します。

  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    1(単位元)(1との差の絶対値がtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isUnit(org.mklab.nfc.scalar.NumericalScalar)`

### isNaN

    public boolean isNaN()

  インタフェース `Scalar` の記述:
  NaNであるか判定します。

  戻り値:
    NaNであればtrue、そうでなければfalse
  関連項目:
    `Scalar.isNaN()`

### isFinite

    public boolean isFinite()

  インタフェース `Scalar` の記述:
  有限であるか判定します。

  戻り値:
    有限であればtrue、そうでなければfalse
  関連項目:
    `Scalar.isFinite()`

### isInfinite

    public boolean isInfinite()

  インタフェース `Scalar` の記述:
  無限大であるか判定します。

  戻り値:
    無限大ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isInfinite()`

### compare

    public boolean compare(String operator,
                           ComplexScalar<T> opponent)

  `opponent`を`operator`で指定された演算子で比較します。

  パラメータ:
    `operator` - 比較演算子(". <", ". <=", ".>", ".>=", ".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    比較式が正しければtrue、そうでなければfalse

### compare

    public boolean compare(String operator,
                           double opponent)

  インタフェース `Scalar` の記述:
  `opponent`を`operator`で指定された演算子で比較します。

  パラメータ:
    `operator` - 比較演算子 (".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    比較式が正しければtrue、そうでなければfalse
  関連項目:
    `Scalar.compare(java.lang.String, double)`

### compare

    public boolean compare(String operator,
                           int opponent)

  インタフェース `Scalar` の記述:
  `opponent`を`operator`で指定された演算子で比較します。

  パラメータ:
    `operator` - 比較演算子(".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    比較式が正しければtrue、そうでなければfalse
  関連項目:
    `Scalar.compare(java.lang.String, int)`

### createGrid

    public NumericalMatrix<ComplexScalar<T>> createGrid(int rowSize,
                                                        int columnSize,
                                                        Scalar<? extends Scalar<?>>[][] elements)

  インタフェース `Scalar` の記述:
  行列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
    `elements` - 行列の成分をもつ配列
  戻り値:
    生成した行列
  関連項目:
    `Scalar.createGrid(int, int, org.mklab.nfc.scalar.Scalar[][])`

### createGrid

    public NumericalMatrix<ComplexScalar<T>> createGrid(Scalar<? extends Scalar<?>>[] elements)

  インタフェース `Scalar` の記述:
  ベクトルを生成します。

  パラメータ:
    `elements` - ベクトルの成分をもつ配列
  戻り値:
    生成したベクトル
  関連項目:
    `Scalar.createGrid(org.mklab.nfc.scalar.Scalar[])`

### createUnit

    public ComplexScalar<T> createUnit()

  インタフェース `Scalar` の記述:
  単位成分を生成します。

  戻り値:
    単位成分
  関連項目:
    `Scalar.createUnit()`

### createImagUnit

    public ComplexScalar<T> createImagUnit()

  インタフェース `NumericalScalar` の記述:
  虚部単位を返します。

  定義:
    インタフェース `NumericalScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `createImagUnit`
  オーバーライド:
    クラス `AbstractNumericalScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `createImagUnit`
  戻り値:
    虚部単位
  関連項目:
    `AbstractNumericalScalar.createImagUnit()`

### createPI

    public ComplexScalar<T> createPI()

  インタフェース `NumericalScalar` の記述:
  円周率PIを返します。

  戻り値:
    円周率PI
  関連項目:
    `NumericalScalar.createPI()`

### createE

    public ComplexScalar<T> createE()

  インタフェース `NumericalScalar` の記述:
  ネイピアの数(自然対数の底)を返します。

  戻り値:
    ネイピアの数(自然対数の底)
  関連項目:
    `NumericalScalar.createE()`

### create

    public ComplexScalar<T> create(int value)

  インタフェース `Scalar` の記述:
  与えられたint型に対応する値を返します。

  パラメータ:
    `value` - int型の値
  戻り値:
    与えられたint型に対応する値
  関連項目:
    `Scalar.create(int)`

### create

    public ComplexScalar<T> create(double value)

  インタフェース `NumericalScalar` の記述:
  与えられたdouble型に対応する値を返します。

  パラメータ:
    `value` - double型の値
  戻り値:
    与えられたdouble型に対応する値
  関連項目:
    `NumericalScalar.create(double)`

### valueOf

    public ComplexScalar<T> valueOf(String numberString)

  インタフェース `NumericalScalar` の記述:
  文字列に対応する数を返します。

  パラメータ:
    `numberString` - 数を表す文字列
  戻り値:
    文字列に対応する数
  関連項目:
    `NumericalScalar.valueOf(java.lang.String)`

### createZero

    public ComplexScalar<T> createZero()

  インタフェース `GridElement` の記述:
  零(デフォルトの初期値)を生成します。

  戻り値:
    零(デフォルトの初期値)
  関連項目:
    `GridElement.createZero()`

### compare

    public boolean compare(String operator,
                           GridElement opponent)

  インタフェース `GridElement` の記述:
  `opponent`を`operator`で指定された演算子で比較します。

  パラメータ:
    `operator` - 比較演算子 (".==", ".!=")
    `opponent` - 比較対象
  戻り値:
    比較式が正しければtrue、そうでなければfalse
  関連項目:
    `GridElement.compare(java.lang.String, org.mklab.nfc.matrix.GridElement)`

### createArray

    public ComplexScalar<T>[] createArray(int size)

  インタフェース `GridElement` の記述:
  グリッドの一次元配列を生成します。

  パラメータ:
    `size` - 成分の数
  戻り値:
    グリッドの一次元配列
  関連項目:
    `GridElement.createArray(int)`

### createArray

    public ComplexScalar<T>[][] createArray(int rowSize,
                                            int columnSize)

  インタフェース `GridElement` の記述:
  グリッドの2次元配列を生成します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    グリッドの2次元配列
  関連項目:
    `GridElement.createArray(int, int)`

### transformFrom

    public ComplexScalar<T> transformFrom(int value)

  インタフェース `Scalar` の記述:
  整数から成分を生成します。

  パラメータ:
    `value` - 整数
  戻り値:
    整数から生成された成分
  関連項目:
    `Scalar.transformFrom(int)`

### transformFrom

    public ComplexScalar<T> transformFrom(double value)

  インタフェース `Scalar` の記述:
  実数から成分を生成します。

  パラメータ:
    `value` - 実数
  戻り値:
    実数から生成された成分
  関連項目:
    `Scalar.transformFrom(double)`

### isTransformableFrom

    public boolean isTransformableFrom(GridElement<?> value)

  インタフェース `GridElement` の記述:
  引数で与えられた型からこの型へ変換可能か判定します。

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `isTransformableFrom`
  オーバーライド:
    クラス `AbstractScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `isTransformableFrom`
  パラメータ:
    `value` - 変換元
  戻り値:
    変換可能ならtrue、そうでなければfalse
  関連項目:
    `GridElement.isTransformableFrom(org.mklab.nfc.matrix.GridElement)`

### isTransformableTo

    public boolean isTransformableTo(GridElement<?> value)

  インタフェース `GridElement` の記述:
  この型から引数で与えられた型へ変換可能か判定します。

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `isTransformableTo`
  オーバーライド:
    クラス `AbstractScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `isTransformableTo`
  パラメータ:
    `value` - 変換先
  戻り値:
    変換可能ならtrue、そうでなければfalse
  関連項目:
    `AbstractScalar.isTransformableTo(org.mklab.nfc.matrix.GridElement)`

### transformTo

    public GridElement<?> transformTo(GridElement<?> value)

  インタフェース `GridElement` の記述:
  この型から引数で与えられた型へ変換します。

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `transformTo`
  オーバーライド:
    クラス `AbstractScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `transformTo`
  パラメータ:
    `value` - 変換先
  戻り値:
    変換で生成された値
  関連項目:
    `GridElement.transformTo(org.mklab.nfc.matrix.GridElement)`

### transformFrom

    public ComplexScalar<T> transformFrom(GridElement<?> value)

  インタフェース `GridElement` の記述:
  引数で与えられた型からこの型へ変換します。

  定義:
    インタフェース `GridElement<ComplexScalar<T extends NumericalScalar<T>>>` 内の `transformFrom`
  オーバーライド:
    クラス `AbstractScalar<ComplexScalar<T extends NumericalScalar<T>>>` 内の `transformFrom`
  パラメータ:
    `value` - 変換元
  戻り値:
    変換で生成された値
  関連項目:
    `GridElement.transformFrom(org.mklab.nfc.matrix.GridElement)`

### getAddOperator

    public Operator getAddOperator()

  インタフェース `Scalar` の記述:
  足し算のオペレータを返します。

  戻り値:
    足し算のオペレータ
  関連項目:
    `Scalar.getAddOperator()`

### getDivideOperator

    public Operator getDivideOperator()

  インタフェース `Scalar` の記述:
  割り算のオペレータを返します。

  戻り値:
    割り算のオペレータ
  関連項目:
    `Scalar.getDivideOperator()`

### getLeftDivideOperator

    public Operator getLeftDivideOperator()

  インタフェース `Scalar` の記述:
  左からの割り算のオペレータを返します。

  戻り値:
    左からの割り算のオペレータ
  関連項目:
    `Scalar.getLeftDivideOperator()`

### getMultiplyOperator

    public Operator getMultiplyOperator()

  インタフェース `Scalar` の記述:
  掛け算のオペレータを返します。

  戻り値:
    掛け算のオペレータ
  関連項目:
    `Scalar.getMultiplyOperator()`

### getSubtractOperator

    public Operator getSubtractOperator()

  インタフェース `Scalar` の記述:
  引き算のオペレータを返します。

  戻り値:
    引き算のオペレータ
  関連項目:
    `Scalar.getSubtractOperator()`

### isComplex

    public boolean isComplex()

  インタフェース `Scalar` の記述:
  複素数であるか判定します。

  戻り値:
    複素数ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isComplex()`

### isReal

    public boolean isReal()

  インタフェース `Scalar` の記述:
  実数であるか判定します。

  戻り値:
    実数ならばtrue、そうでなければ false
  関連項目:
    `Scalar.isReal()`

### toComplex

    public ComplexScalar<T> toComplex()

  インタフェース `Scalar` の記述:
  複素成分に変換します。

  戻り値:
    複素成分
  関連項目:
    `Scalar.toComplex()`

### power

    public ComplexScalar<T> power(ComplexScalar<T> scalar)

  複素`scalar`乗(`this` `scalar`)を返します。

  パラメータ:
    `scalar` - 複素数
  戻り値:
    scalar乗

### power

    public ComplexScalar<T> power(double scalar)

  インタフェース `NumericalScalar` の記述:
  実数`scalar`乗(`this` `scalar`)を返します。

  パラメータ:
    `scalar` - 実数
  戻り値:
    scalar乗
  関連項目:
    `NumericalScalar.power(double)`

### power

    public ComplexScalar<T> power(NumericalScalar value)

  インタフェース `NumericalScalar` の記述:
  `scalar`乗(`this` `scalar`)を返します。

  パラメータ:
    `value` - スカラー
  戻り値:
    scalar乗
  関連項目:
    `NumericalScalar.power(org.mklab.nfc.scalar.NumericalScalar)`

### abs

    public T abs()

  インタフェース `NumericalScalar` の記述:
  絶対値を返します。

  戻り値:
    絶対値
  関連項目:
    `NumericalScalar.abs()`

### abs2

    public T abs2()

  インタフェース `NumericalScalar` の記述:
  絶対値の2乗を返します。

  戻り値:
    絶対値の2乗
  関連項目:
    `NumericalScalar.abs2()`

### sqrt

    public ComplexScalar<T> sqrt()

  インタフェース `NumericalScalar` の記述:
  平方根を返します。

  戻り値:
    平方根
  関連項目:
    `NumericalScalar.sqrt()`

### arg

    public T arg()

  インタフェース `NumericalScalar` の記述:
  偏角を返します。

  戻り値:
    偏角
  関連項目:
    `NumericalScalar.arg()`

### log

    public ComplexScalar<T> log()

  インタフェース `NumericalScalar` の記述:
  自然対数の値を返します。

  戻り値:
    自然対数の値
  関連項目:
    `NumericalScalar.log()`

### log10

    public ComplexScalar<T> log10()

  インタフェース `NumericalScalar` の記述:
  常用対数の値を返します。

  戻り値:
    常用対数の値
  関連項目:
    `NumericalScalar.log10()`

### exp

    public ComplexScalar<T> exp()

  インタフェース `NumericalScalar` の記述:
  指数関数の値を返します。

  戻り値:
    指数関数の値
  関連項目:
    `NumericalScalar.exp()`

### sin

    public ComplexScalar<T> sin()

  インタフェース `NumericalScalar` の記述:
  正弦関数の値を返します。

  戻り値:
    正弦関数の値
  関連項目:
    `NumericalScalar.sin()`

### asin

    public ComplexScalar<T> asin()

  インタフェース `NumericalScalar` の記述:
  逆正弦関数の値を返します。 asin(a) = - i log(i*a + sqrt(1 - a*a))

  戻り値:
    逆正弦関数の値
  関連項目:
    `NumericalScalar.asin()`

### sinh

    public ComplexScalar<T> sinh()

  インタフェース `NumericalScalar` の記述:
  双曲線正弦関数の値を返します。 sinh(a) = (exp(a) - exp(-a))/2

  戻り値:
    双曲線正弦関数の値
  関連項目:
    `NumericalScalar.sinh()`

### asinh

    public ComplexScalar<T> asinh()

  インタフェース `NumericalScalar` の記述:
  逆双曲線関数の値を返します。 asinh(a) = log(a + sqrt(a*a + 1))

  戻り値:
    逆双曲線関数の値
  関連項目:
    `NumericalScalar.asinh()`

### cos

    public ComplexScalar<T> cos()

  インタフェース `NumericalScalar` の記述:
  余弦関数の値を返します。 cos(a)

  戻り値:
    余弦関数の値
  関連項目:
    `NumericalScalar.cos()`

### acos

    public ComplexScalar<T> acos()

  インタフェース `NumericalScalar` の記述:
  逆余弦関数の値を返します。 acos(a) = - i log(a + sqrt(a*a - 1.0))

  戻り値:
    逆余弦関数の値
  関連項目:
    `NumericalScalar.acos()`

### acosh

    public ComplexScalar<T> acosh()

  インタフェース `NumericalScalar` の記述:
  逆双曲線余弦関数の値を返します。 acosh(a) = log(a + sqrt(a*a - 1))

  戻り値:
    逆双曲線余弦関数の値
  関連項目:
    `NumericalScalar.acosh()`

### cosh

    public ComplexScalar<T> cosh()

  インタフェース `NumericalScalar` の記述:
  双曲線関数の値を返します。 cosh(a) = (exp(a) + exp(-a))/2

  戻り値:
    双曲線関数の値
  関連項目:
    `NumericalScalar.cosh()`

### tan

    public ComplexScalar<T> tan()

  インタフェース `NumericalScalar` の記述:
  正接関数の値を返します。 tan()

  戻り値:
    正接関数の値
  関連項目:
    `NumericalScalar.tan()`

### atan

    public ComplexScalar<T> atan()

  インタフェース `NumericalScalar` の記述:
  逆正接の値を返します。 atan(a) = 1/2i log((1+i*a)/(1-i*a))

  戻り値:
    逆正接関数の値
  関連項目:
    `NumericalScalar.atan()`

### atan2

    public ComplexScalar<T> atan2(NumericalScalar value)

  インタフェース `NumericalScalar` の記述:
  逆正接(2)の値を返します。

  パラメータ:
    `value` - 分母側の数
  戻り値:
    逆正接(2)の値
  関連項目:
    `NumericalScalar.atan2(org.mklab.nfc.scalar.NumericalScalar)`

### tanh

    public ComplexScalar<T> tanh()

  インタフェース `NumericalScalar` の記述:
  双曲線正接関数の値を返します。 tanh()

  戻り値:
    双曲線正接関数の値
  関連項目:
    `NumericalScalar.tanh()`

### atanh

    public ComplexScalar<T> atanh()

  インタフェース `NumericalScalar` の記述:
  逆双曲線正接関数の値を返します。 atanh(a) = 1/2 log((1+a)/(1-a))

  戻り値:
    逆双曲線正接関数の値
  関連項目:
    `NumericalScalar.atanh()`

### isGreaterThan

    public boolean isGreaterThan(NumericalScalar<?> opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より大きいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(org.mklab.nfc.scalar.NumericalScalar)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(NumericalScalar<?> opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以上であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(org.mklab.nfc.scalar.NumericalScalar)`

### isLessThan

    public boolean isLessThan(NumericalScalar<?> opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より小さいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(org.mklab.nfc.scalar.NumericalScalar)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(NumericalScalar<?> opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以下であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(org.mklab.nfc.scalar.NumericalScalar)`

### isGreaterThan

    public boolean isGreaterThan(int opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より大きいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(int)`

### isGreaterThan

    public boolean isGreaterThan(double opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より大きいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(double)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(int opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以上であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(int)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(double opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以上であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(double)`

### isLessThan

    public boolean isLessThan(int opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より小さいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(int)`

### isLessThan

    public boolean isLessThan(double opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`より小さいか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(double)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(int opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以下であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(int)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(double opponent)

  インタフェース `NumericalScalar` の記述:
  `opponent`以下であるか判定します。

  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(double)`

### getPowerOperator

    public Operator getPowerOperator()

  インタフェース `NumericalScalar` の記述:
  累乗のオペレータを返します。

  戻り値:
    累乗のオペレータ
  関連項目:
    `NumericalScalar.getPowerOperator()`

### getAtan2Operator

    public Operator getAtan2Operator()

  インタフェース `NumericalScalar` の記述:
  逆正接(2)のオペレータを返します。

  戻り値:
    逆正接(2)のオペレータ
  関連項目:
    `NumericalScalar.getAtan2Operator()`

### getMachineEpsilon

    public NumericalScalar<?> getMachineEpsilon()

  インタフェース `NumericalScalar` の記述:
  機種精度(Machine Epsilon)を返します。

  戻り値:
    機種精度(Machine Epsilon)
  関連項目:
    `NumericalScalar.getMachineEpsilon()`

### getInfinity

    public ComplexScalar<T> getInfinity()

  インタフェース `NumericalScalar` の記述:
  無限大を返します。

  戻り値:
    無限大
  関連項目:
    `NumericalScalar.getInfinity()`

### getNaN

    public ComplexScalar<T> getNaN()

  インタフェース `NumericalScalar` の記述:
  NaN(Not a Number)を返します。

  戻り値:
    NaN(Not a Number)
  関連項目:
    `NumericalScalar.getNaN()`

### createUniformRandomGenerator

    public RandomGenerator<ComplexScalar<T>> createUniformRandomGenerator()

  インタフェース `NumericalScalar` の記述:
  一様分布の乱数生成器を返します。

  戻り値:
    一様分布の乱数生成器
  関連項目:
    `NumericalScalar.createUniformRandomGenerator()`

### hashCode

    public int hashCode()

  Override hashCode.

  オーバーライド:
    クラス `Object` 内の `hashCode`
  戻り値:
    the Objects hashcode.

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