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

## org.mklab.nfc.scalar
クラス DoubleNumber

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

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

    public class DoubleNumber

extends AbstractNumericalScalar<DoubleNumber>
implements MatxObject

倍精度型(double)の実数を表わすクラスです。

バージョン:
  $Revision: 1.46 $, 2007/12/14
作成者:
  koga
関連項目:
  直列化された形式

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

メソッドの概要
`DoubleNumber` | `abs()` 絶対値を返します。
`DoubleNumber` | `abs2()` 絶対値の2乗を返します。
`DoubleNumber` | `acos()` 逆余弦関数の値を返します。
`DoubleNumber` | `acosh()` 逆双曲線余弦関数の値を返します。
`DoubleNumber` | `add(double value)` 値を加えます。
`DoubleNumber` | `add(DoubleNumber value)` 倍精度実数の和を返します。
`DoubleNumber` | `add(int value)` 値を加えます。
`Scalar<?>` | `add(Scalar<?> value)` 値を加えた成分を生成します。
`DoubleNumber` | `addSelf(DoubleNumber value)` 自身に倍精度実数を加えます。
`Scalar<?>` | `addSelf(Scalar<?> value)` 自身に値を加えます。
`DoubleNumber` | `arg()` 偏角を返します。
`DoubleNumber` | `asin()` 逆正弦関数の値を返します。
`DoubleNumber` | `asinh()` 逆双曲線関数の値を返します。
`DoubleNumber` | `atan()` 逆正接の値を返します。
`NumericalScalar<?>` | `atan2(NumericalScalar<?> value)` 逆正接(2)の値を返します。
`DoubleNumber` | `atanh()` 逆双曲線正接関数の値を返します。
`DoubleNumber` | `ceil()` 大きい整数に丸めます。
`DoubleNumber` | `clone()` see java.lang.Object#clone()
`boolean` | `compare(String operator, double opponent)` `opponent`を`operator`で指定された演算子で比較します。
`boolean` | `compare(String operator, GridElement<?> opponent)` `opponent`を`operator`で指定された演算子で比較します。
`boolean` | `compare(String operator, int opponent)` `opponent`を`operator`で指定された演算子で比較します。
`DoubleNumber` | `conjugate()` 共役数を返します。
`DoubleNumber` | `cos()` 余弦関数の値を返します。
`DoubleNumber` | `cosh()` 双曲線関数の値を返します。
`DoubleNumber` | `create(double value)` 与えられたdouble型に対応する値を返します。
`DoubleNumber` | `create(int value)` 与えられたint型に対応する値を返します。
`DoubleNumber[]` | `createArray(int size)` グリッドの一次元配列を生成します。
`DoubleNumber[][]` | `createArray(int rowSize, int columnSize)` グリッドの2次元配列を生成します。
`DoubleNumber` | `createE()` ネイピアの数(自然対数の底)を返します。
`DoubleMatrix` | `createGrid(int rowSize, int columnSize, Scalar<? extends Scalar<?>>[][] elements)` 行列を生成します。
`DoubleMatrix` | `createGrid(Scalar<? extends Scalar<?>>[] elements)` ベクトルを生成します。
`DoubleComplexNumber` | `createImagUnit()` 虚部単位を返します。
`DoubleNumber` | `createPI()` 円周率PIを返します。
`RandomGenerator<DoubleNumber>` | `createUniformRandomGenerator()` 一様分布の乱数生成器を返します。
`DoubleNumber` | `createUnit()` 単位成分を生成します。
`DoubleNumber` | `createZero()` 零(デフォルトの初期値)を生成します。
`DoubleNumber` | `divide(double value)` 値で割ります。
`DoubleNumber` | `divide(DoubleNumber value)` 倍精度実数との商を返します。
`DoubleNumber` | `divide(int value)` 値で割ります。
`Scalar<?>` | `divide(Scalar<?> value)` 値で割ります。
`double` | `doubleValue()` double型の値を返します。
`boolean` | `equals(DoubleNumber opponent, double tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(DoubleNumber opponent, NumericalScalar<?> tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(NumericalScalar<?> opponent, NumericalScalar<?> tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(Object o)`
`boolean` | `equals(Scalar<?> opponent, double tolerance)` 許容範囲内で等しいか判定します。
`DoubleNumber` | `exp()` 指数関数の値を返します。
`DoubleNumber` | `fix()` ゼロ方向の整数に丸めます。
`DoubleNumber` | `floor()` 小さい整数に丸めます。
`Operator` | `getAddOperator()` 足し算のオペレータを返します。
`Operator` | `getAtan2Operator()` 逆正接(2)のオペレータを返します。
`Operator` | `getDivideOperator()` 割り算のオペレータを返します。
`DoubleNumber` | `getImaginaryPart()` 虚部を返します。
`DoubleNumber` | `getInfinity()` 無限大を返します。
`Operator` | `getLeftDivideOperator()` 左からの割り算のオペレータを返します。
`DoubleNumber` | `getMachineEpsilon()` 機種精度(Machine Epsilon)を返します。
`Operator` | `getMultiplyOperator()` 掛け算のオペレータを返します。
`DoubleNumber` | `getNaN()` NaN(Not a Number)を返します。
`Operator` | `getPowerOperator()` 累乗のオペレータを返します。
`DoubleNumber` | `getRealPart()` 実部を返します。
`Operator` | `getSubtractOperator()` 引き算のオペレータを返します。
`int` | `hashCode()`
`DoubleNumber` | `inverse()` 逆数を求めます。
`boolean` | `isComplex()` 複素数であるか判定します。
`static boolean` | `isDisplayAsIntegerFormat()` 整数を整数形式で表示するか判定します。
`static boolean` | `isDisplayAsZero()` ゼロを「０」と表示するか判定します。
`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` | `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)` 零であるか判定します。
`DoubleNumber` | `leftDivide(double value)` 値を割ります。
`DoubleNumber` | `leftDivide(DoubleNumber value)` 倍精度実数の左からの商を返します。
`DoubleNumber` | `leftDivide(int value)` 値を割ります。
`Scalar<?>` | `leftDivide(Scalar<?> value)` 値を割ります。
`DoubleNumber` | `log()` 自然対数の値を返します。
`DoubleNumber` | `log10()` 常用対数の値を返します。
`DoubleNumber` | `multiply(double value)` 値を掛けます。
`DoubleNumber` | `multiply(DoubleNumber value)` 倍精度実数の積を返します。
`DoubleNumber` | `multiply(int value)` 値を掛けます。
`Scalar<?>` | `multiply(Scalar<?> value)` 値を掛けます。
`DoubleNumber` | `power(double scalar)` 実数`scalar`乗(`this` `scalar`)を返します。
`DoubleNumber` | `power(DoubleNumber scalar)` 実数`scalar`乗(`this` `scalar`)を返します。
`DoubleNumber` | `power(int scalar)` 累乗を返します。
`NumericalScalar<?>` | `power(NumericalScalar<?> value)` `scalar`乗(`this` `scalar`)を返します。
`DoubleNumber` | `round()` 最も近い整数に丸めます。
`DoubleNumber` | `roundToZero(double tolerance)` 絶対値が小さい成分を0に丸めます。
`DoubleNumber` | `roundToZero(NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`static void` | `setDisplayAsIntegerFormat(boolean displayAsIntegerFormat)` 整数を整数形式で表示するかを設定します。
`static void` | `setDisplayAsZero(boolean displayAsZero)` ゼロを「０」と表示するかを設定します。
`void` | `setImaginaryPart(double imagPart)` 虚部を設定します。
`void` | `setImaginaryPart(int imagPart)` 虚部を設定します。
`void` | `setImaginaryPart(Scalar<?> imagPart)` 虚部を設定します。
`void` | `setRealPart(double realPart)` 実部を設定します。
`void` | `setRealPart(int realPart)` 実部を設定します。
`void` | `setRealPart(Scalar<?> realPart)` 実部を設定します。
`DoubleNumber` | `signum()` 符合(-1,0,1)を返します。
`DoubleNumber` | `sin()` 正弦関数の値を返します。
`DoubleNumber` | `sinh()` 双曲線正弦関数の値を返します。
`DoubleNumber` | `sqrt()` 平方根を返します。
`DoubleNumber` | `subtract(double value)` 値を引く。
`DoubleNumber` | `subtract(DoubleNumber value)` 倍精度実数との差を返します。
`DoubleNumber` | `subtract(int value)` 値を引く。
`Scalar<?>` | `subtract(Scalar<?> value)` 値を引きます。
`DoubleNumber` | `tan()` 正接関数の値を返します。
`DoubleNumber` | `tanh()` 双曲線正接関数の値を返します。
`DoubleComplexNumber` | `toComplex()` 複素成分に変換します。
`String` | `toMmString()` MM形式の文字列を生成します。
`String` | `toMmString(String format)` MM形式の文字列を生成します。
`String` | `toString()` 文字列に変換します。
`static String` | `toString(double value, String valueFormat)` 文字列に変換します。
`String` | `toString(String valueFormat)` 文字列に変換します。
`DoubleNumber` | `transformFrom(double value)` 実数から成分を生成します。
`DoubleNumber` | `transformFrom(int value)` 整数から成分を生成します。
`GridElement<?>` | `transformTo(GridElement<?> value)` この型から引数で与えられた型へ変換します。
`DoubleNumber` | `unaryMinus()` 符号を反転した値を返します。
`DoubleNumber` | `valueOf(String numberString)` 文字列に対応する数を返します。
`void` | `writeMmFormat(String fileName, String dataName)` MMファイル形式で行列データをファイルに出力します。
`void` | `writeMmFormat(Writer output, String dataName, boolean withNewLine)` MMフォーマット行列データをライターに出力します。
`void` | `writeMxFormat(OutputStream output, String dataName)` データをMX形式で出力ストリームへ出力します。
`void` | `writeMxFormat(String fileName, String dataName)` データをMX形式でファイルへ出力します。

クラス 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, isTransformableFrom, setDefaultFormat, setFormat, transformFrom, transformToSameClass`

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

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

インタフェース org.mklab.nfc.matrix.GridElement から継承されたメソッド
`isTransformableFrom, transformFrom`

コンストラクタの詳細

### DoubleNumber

    public DoubleNumber(double value)

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

  パラメータ:
    `value` - データ

メソッドの詳細

### doubleValue

    public double doubleValue()

  double型の値を返します。

  戻り値:
    double型の値

### setDisplayAsZero

    public static void setDisplayAsZero(boolean displayAsZero)

  ゼロを「０」と表示するかを設定します。

  パラメータ:
    `displayAsZero` - ゼロを「０」と表示するならばtrue

### isDisplayAsZero

    public static boolean isDisplayAsZero()

  ゼロを「０」と表示するか判定します。

  戻り値:
    ゼロを「０」と表示するならばtrue

### setDisplayAsIntegerFormat

    public static void setDisplayAsIntegerFormat(boolean displayAsIntegerFormat)

  整数を整数形式で表示するかを設定します。

  パラメータ:
    `displayAsIntegerFormat` - 整数を整数形式で表示するならばtrue、そうでなければfalse

### isDisplayAsIntegerFormat

    public static boolean isDisplayAsIntegerFormat()

  整数を整数形式で表示するか判定します。

  戻り値:
    整数を整数形式で表示するならばtrue、そうでなければfalse

### abs

    public DoubleNumber abs()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `abs`
  戻り値:
    絶対値
  関連項目:
    `NumericalScalar.abs()`

### signum

    public DoubleNumber signum()

  符合(-1,0,1)を返します。

  戻り値:
    符合(-1,0,1)

### abs2

    public DoubleNumber abs2()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `abs2`
  戻り値:
    絶対値の2乗
  関連項目:
    `NumericalScalar.abs2()`

### acos

    public DoubleNumber acos()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `acos`
  戻り値:
    逆余弦関数の値
  関連項目:
    `NumericalScalar.acos()`

### acosh

    public DoubleNumber acosh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `acosh`
  戻り値:
    逆双曲線余弦関数の値
  関連項目:
    `NumericalScalar.acosh()`

### arg

    public DoubleNumber arg()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `arg`
  戻り値:
    偏角
  関連項目:
    `NumericalScalar.arg()`

### asin

    public DoubleNumber asin()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `asin`
  戻り値:
    逆正弦関数の値
  関連項目:
    `NumericalScalar.asin()`

### asinh

    public DoubleNumber asinh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `asinh`
  戻り値:
    逆双曲線関数の値
  関連項目:
    `NumericalScalar.asinh()`

### atan

    public DoubleNumber atan()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `atan`
  戻り値:
    逆正接関数の値
  関連項目:
    `NumericalScalar.atan()`

### atan2

    public NumericalScalar<?> atan2(NumericalScalar<?> value)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `atan2`
  パラメータ:
    `value` - 分母側の数
  戻り値:
    逆正接(2)の値
  関連項目:
    `NumericalScalar.atan2(org.mklab.nfc.scalar.NumericalScalar)`

### atanh

    public DoubleNumber atanh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `atanh`
  戻り値:
    逆双曲線正接関数の値
  関連項目:
    `NumericalScalar.atanh()`

### cos

    public DoubleNumber cos()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `cos`
  戻り値:
    余弦関数の値
  関連項目:
    `NumericalScalar.cos()`

### cosh

    public DoubleNumber cosh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `cosh`
  戻り値:
    双曲線関数の値
  関連項目:
    `NumericalScalar.cosh()`

### exp

    public DoubleNumber exp()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `exp`
  戻り値:
    指数関数の値
  関連項目:
    `NumericalScalar.exp()`

### log

    public DoubleNumber log()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `log`
  戻り値:
    自然対数の値
  関連項目:
    `NumericalScalar.log()`

### log10

    public DoubleNumber log10()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `log10`
  戻り値:
    常用対数の値
  関連項目:
    `NumericalScalar.log10()`

### power

    public DoubleNumber power(double scalar)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `power`
  パラメータ:
    `scalar` - 実数
  戻り値:
    scalar乗
  関連項目:
    `NumericalScalar.power(double)`

### power

    public DoubleNumber power(DoubleNumber scalar)

  実数`scalar`乗(`this` `scalar`)を返します。

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

### power

    public NumericalScalar<?> power(NumericalScalar<?> value)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `power`
  パラメータ:
    `value` - スカラー
  戻り値:
    scalar乗
  関連項目:
    `NumericalScalar.power(org.mklab.nfc.scalar.NumericalScalar)`

### sin

    public DoubleNumber sin()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `sin`
  戻り値:
    正弦関数の値
  関連項目:
    `NumericalScalar.sin()`

### sinh

    public DoubleNumber sinh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `sinh`
  戻り値:
    双曲線正弦関数の値
  関連項目:
    `NumericalScalar.sinh()`

### sqrt

    public DoubleNumber sqrt()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `sqrt`
  戻り値:
    平方根
  関連項目:
    `NumericalScalar.sqrt()`

### tan

    public DoubleNumber tan()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `tan`
  戻り値:
    正接関数の値
  関連項目:
    `NumericalScalar.tan()`

### tanh

    public DoubleNumber tanh()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `tanh`
  戻り値:
    双曲線正接関数の値
  関連項目:
    `NumericalScalar.tanh()`

### add

    public DoubleNumber add(DoubleNumber value)

  倍精度実数の和を返します。

  パラメータ:
    `value` - 加える倍精度実数
  戻り値:
    倍精度実数の和

### add

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `add`
  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(org.mklab.nfc.scalar.Scalar)`

### add

    public DoubleNumber add(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `add`
  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(double)`

### add

    public DoubleNumber add(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `add`
  パラメータ:
    `value` - 加える値
  戻り値:
    足し算の結果
  関連項目:
    `Scalar.add(int)`

### addSelf

    public DoubleNumber addSelf(DoubleNumber value)

  自身に倍精度実数を加えます。

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

### addSelf

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `addSelf`
  パラメータ:
    `value` - 加える値
  戻り値:
    自身
  関連項目:
    `Scalar.addSelf(org.mklab.nfc.scalar.Scalar)`

### compare

    public boolean compare(String operator,
                           int opponent)

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

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

### compare

    public boolean compare(String operator,
                           double opponent)

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

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

### isGreaterThan

    public boolean isGreaterThan(NumericalScalar<?> opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(org.mklab.nfc.scalar.NumericalScalar)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(NumericalScalar<?> opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(org.mklab.nfc.scalar.NumericalScalar)`

### isLessThan

    public boolean isLessThan(NumericalScalar<?> opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(org.mklab.nfc.scalar.NumericalScalar)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(NumericalScalar<?> opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(org.mklab.nfc.scalar.NumericalScalar)`

### isGreaterThan

    public boolean isGreaterThan(int opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(int)`

### isGreaterThan

    public boolean isGreaterThan(double opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より大きいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThan(double)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(int opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(int)`

### isGreaterThanOrEquals

    public boolean isGreaterThanOrEquals(double opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isGreaterThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以上ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isGreaterThanOrEquals(double)`

### isLessThan

    public boolean isLessThan(int opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(int)`

### isLessThan

    public boolean isLessThan(double opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThan`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`より小さいならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThan(double)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(int opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(int)`

### isLessThanOrEquals

    public boolean isLessThanOrEquals(double opponent)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `isLessThanOrEquals`
  パラメータ:
    `opponent` - 比較対象
  戻り値:
    `opponent`以下ならばtrue、そうでなければfalse
  関連項目:
    `NumericalScalar.isLessThanOrEquals(double)`

### conjugate

    public DoubleNumber conjugate()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `conjugate`
  戻り値:
    共役数
  関連項目:
    `Scalar.conjugate()`

### createGrid

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

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

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

### createGrid

    public DoubleMatrix createGrid(Scalar<? extends Scalar<?>>[] elements)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `createGrid`
  パラメータ:
    `elements` - ベクトルの成分をもつ配列
  戻り値:
    生成したベクトル
  関連項目:
    `Scalar.createGrid(org.mklab.nfc.scalar.Scalar[])`

### createUnit

    public DoubleNumber createUnit()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `createUnit`
  戻り値:
    単位成分
  関連項目:
    `Scalar.createUnit()`

### divide

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `divide`
  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(org.mklab.nfc.scalar.Scalar)`

### divide

    public DoubleNumber divide(DoubleNumber value)

  倍精度実数との商を返します。

  パラメータ:
    `value` - 割る
  戻り値:
    倍精度実数との商

### divide

    public DoubleNumber divide(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `divide`
  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(double)`

### divide

    public DoubleNumber divide(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `divide`
  パラメータ:
    `value` - 割る値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.divide(int)`

### equals

    public boolean equals(Scalar<?> opponent,
                          double tolerance)

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

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

### equals

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

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

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

### equals

    public boolean equals(DoubleNumber opponent,
                          double tolerance)

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

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

### equals

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

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

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

### inverse

    public DoubleNumber inverse()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `inverse`
  戻り値:
    逆数
  関連項目:
    `Scalar.inverse()`

### isFinite

    public boolean isFinite()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isFinite`
  戻り値:
    有限であればtrue、そうでなければfalse
  関連項目:
    `Scalar.isFinite()`

### isInfinite

    public boolean isInfinite()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isInfinite`
  戻り値:
    無限大ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isInfinite()`

### isNaN

    public boolean isNaN()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isNaN`
  戻り値:
    NaNであればtrue、そうでなければfalse
  関連項目:
    `Scalar.isNaN()`

### isUnit

    public boolean isUnit()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isUnit`
  戻り値:
    １(単位元)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isUnit()`

### isUnit

    public boolean isUnit(double tolerance)

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

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

### isUnit

    public boolean isUnit(NumericalScalar<?> tolerance)

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

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

### isZero

    public boolean isZero(double tolerance)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零(大きさがtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isZero(double)`

### isZero

    public boolean isZero(NumericalScalar<?> tolerance)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    零(絶対値がtolerance以下)ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isZero(org.mklab.nfc.scalar.NumericalScalar)`

### leftDivide

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `leftDivide`
  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(org.mklab.nfc.scalar.Scalar)`

### leftDivide

    public DoubleNumber leftDivide(DoubleNumber value)

  倍精度実数の左からの商を返します。

  パラメータ:
    `value` - 割られる数
  戻り値:
    倍精度実数の左からの商

### leftDivide

    public DoubleNumber leftDivide(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `leftDivide`
  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(double)`

### leftDivide

    public DoubleNumber leftDivide(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `leftDivide`
  パラメータ:
    `value` - 割られる値
  戻り値:
    割り算の結果
  関連項目:
    `Scalar.leftDivide(int)`

### multiply

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `multiply`
  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(org.mklab.nfc.scalar.Scalar)`

### multiply

    public DoubleNumber multiply(DoubleNumber value)

  倍精度実数の積を返します。

  パラメータ:
    `value` - 乗じる数
  戻り値:
    倍精度実数の積

### multiply

    public DoubleNumber multiply(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `multiply`
  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(double)`

### multiply

    public DoubleNumber multiply(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `multiply`
  パラメータ:
    `value` - 掛ける値
  戻り値:
    掛け算の結果
  関連項目:
    `Scalar.multiply(int)`

### power

    public DoubleNumber power(int scalar)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `power`
  パラメータ:
    `scalar` - 指数
  戻り値:
    累乗
  関連項目:
    `Scalar.power(int)`

### subtract

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

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `subtract`
  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(org.mklab.nfc.scalar.Scalar)`

### subtract

    public DoubleNumber subtract(DoubleNumber value)

  倍精度実数との差を返します。

  パラメータ:
    `value` - 引く数
  戻り値:
    倍精度実数との差

### subtract

    public DoubleNumber subtract(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `subtract`
  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(double)`

### subtract

    public DoubleNumber subtract(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `subtract`
  パラメータ:
    `value` - 引く値
  戻り値:
    引き算の結果
  関連項目:
    `Scalar.subtract(int)`

### isTransformableTo

    public boolean isTransformableTo(GridElement<?> value)

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

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

### transformTo

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

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

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

### transformFrom

    public DoubleNumber transformFrom(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `transformFrom`
  パラメータ:
    `value` - 整数
  戻り値:
    整数から生成された成分
  関連項目:
    `Scalar.transformFrom(int)`

### transformFrom

    public DoubleNumber transformFrom(double value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `transformFrom`
  パラメータ:
    `value` - 実数
  戻り値:
    実数から生成された成分
  関連項目:
    `Scalar.transformFrom(double)`

### unaryMinus

    public DoubleNumber unaryMinus()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `unaryMinus`
  戻り値:
    符号を反転した値
  関連項目:
    `Scalar.unaryMinus()`

### compare

    public boolean compare(String operator,
                           GridElement<?> opponent)

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

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

### createArray

    public DoubleNumber[] createArray(int size)

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

  定義:
    インタフェース `GridElement<DoubleNumber>` 内の `createArray`
  パラメータ:
    `size` - 成分の数
  戻り値:
    グリッドの一次元配列
  関連項目:
    `GridElement.createArray(int)`

### createArray

    public DoubleNumber[][] createArray(int rowSize,
                                        int columnSize)

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

  定義:
    インタフェース `GridElement<DoubleNumber>` 内の `createArray`
  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 列の数
  戻り値:
    グリッドの2次元配列
  関連項目:
    `GridElement.createArray(int, int)`

### create

    public DoubleNumber create(int value)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `create`
  パラメータ:
    `value` - int型の値
  戻り値:
    与えられたint型に対応する値
  関連項目:
    `Scalar.create(int)`

### create

    public DoubleNumber create(double value)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `create`
  パラメータ:
    `value` - double型の値
  戻り値:
    与えられたdouble型に対応する値
  関連項目:
    `NumericalScalar.create(double)`

### createZero

    public DoubleNumber createZero()

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

  定義:
    インタフェース `GridElement<DoubleNumber>` 内の `createZero`
  戻り値:
    零(デフォルトの初期値)
  関連項目:
    `GridElement.createZero()`

### isZero

    public boolean isZero()

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

  定義:
    インタフェース `GridElement<DoubleNumber>` 内の `isZero`
  戻り値:
    零(デフォルトの初期値)ならばtrue、そうでなければfalse
  関連項目:
    `GridElement.isZero()`

### ceil

    public DoubleNumber ceil()

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `ceil`
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.ceil()`

### fix

    public DoubleNumber fix()

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `fix`
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.fix()`

### floor

    public DoubleNumber floor()

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `floor`
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.floor()`

### round

    public DoubleNumber round()

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `round`
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.round()`

### roundToZero

    public DoubleNumber roundToZero(double tolerance)

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `roundToZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.roundToZero(double)`

### roundToZero

    public DoubleNumber roundToZero(NumericalScalar<?> tolerance)

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

  定義:
    インタフェース `RoundableToInteger<DoubleNumber>` 内の `roundToZero`
  パラメータ:
    `tolerance` - 許容誤差
  戻り値:
    丸めた結果
  関連項目:
    `RoundableToInteger.roundToZero(org.mklab.nfc.scalar.NumericalScalar)`

### clone

    public DoubleNumber clone()

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

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

### toMmString

    public String toMmString()

  インタフェース `MatxObject` の記述:
  MM形式の文字列を生成します。

  定義:
    インタフェース `MatxObject` 内の `toMmString`
  戻り値:
    MM形式の文字列
  関連項目:
    `MatxObject.toMmString()`

### toMmString

    public String toMmString(String format)

  インタフェース `MatxObject` の記述:
  MM形式の文字列を生成します。

  定義:
    インタフェース `MatxObject` 内の `toMmString`
  パラメータ:
    `format` - 出力フォーマット
  戻り値:
    MM形式の文字列
  関連項目:
    `MatxObject.toMmString(java.lang.String)`

### writeMmFormat

    public void writeMmFormat(String fileName,
                              String dataName)
                       throws IOException

  インタフェース `MatxObject` の記述:
  MMファイル形式で行列データをファイルに出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMmFormat`
  パラメータ:
    `fileName` - ファイル名
    `dataName` - 名前
  例外:
    `IOException` - ファイルに出力できない場合
  関連項目:
    `MatxObject.writeMmFormat(java.lang.String, java.lang.String)`

### writeMmFormat

    public void writeMmFormat(Writer output,
                              String dataName,
                              boolean withNewLine)
                       throws IOException

  インタフェース `MatxObject` の記述:
  MMフォーマット行列データをライターに出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMmFormat`
  パラメータ:
    `output` - ライター
    `dataName` - 名前
    `withNewLine` - セミコロンと改行コードを出力するならばtrue、そうでなければfalse
  例外:
    `IOException` - ライターに出力できない場合
  関連項目:
    `MatxObject.writeMmFormat(java.io.Writer, java.lang.String, boolean)`

### writeMxFormat

    public void writeMxFormat(String fileName,
                              String dataName)
                       throws IOException

  インタフェース `MatxObject` の記述:
  データをMX形式でファイルへ出力します。

  定義:
    インタフェース `MatxObject` 内の `writeMxFormat`
  パラメータ:
    `fileName` - ファイル名
    `dataName` - データの名前
  例外:
    `IOException` - ファイルに出力できない場合
  関連項目:
    `MatxObject.writeMxFormat(java.lang.String, java.lang.String)`

### writeMxFormat

    public void writeMxFormat(OutputStream output,
                              String dataName)
                       throws IOException

  インタフェース `MatxObject` の記述:
  データをMX形式で出力ストリームへ出力します。 outputがcloseされるまで、いくつでも出力可能です。

  定義:
    インタフェース `MatxObject` 内の `writeMxFormat`
  パラメータ:
    `output` - 出力ストリーム
    `dataName` - データの名前
  例外:
    `IOException` - 出力ストリームに出力できない場合
  関連項目:
    `MatxObject.writeMxFormat(java.io.OutputStream, java.lang.String)`

### getAddOperator

    public Operator getAddOperator()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getAddOperator`
  戻り値:
    足し算のオペレータ
  関連項目:
    `Scalar.getAddOperator()`

### getDivideOperator

    public Operator getDivideOperator()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getDivideOperator`
  戻り値:
    割り算のオペレータ
  関連項目:
    `Scalar.getDivideOperator()`

### getLeftDivideOperator

    public Operator getLeftDivideOperator()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getLeftDivideOperator`
  戻り値:
    左からの割り算のオペレータ
  関連項目:
    `Scalar.getLeftDivideOperator()`

### getMultiplyOperator

    public Operator getMultiplyOperator()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getMultiplyOperator`
  戻り値:
    掛け算のオペレータ
  関連項目:
    `Scalar.getMultiplyOperator()`

### getSubtractOperator

    public Operator getSubtractOperator()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getSubtractOperator`
  戻り値:
    引き算のオペレータ
  関連項目:
    `Scalar.getSubtractOperator()`

### getPowerOperator

    public Operator getPowerOperator()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `getPowerOperator`
  戻り値:
    累乗のオペレータ
  関連項目:
    `NumericalScalar.getPowerOperator()`

### getAtan2Operator

    public Operator getAtan2Operator()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `getAtan2Operator`
  戻り値:
    逆正接(2)のオペレータ
  関連項目:
    `NumericalScalar.getAtan2Operator()`

### toString

    public static String toString(double value,
                                  String valueFormat)

  文字列に変換します。

  パラメータ:
    `value` - 値
    `valueFormat` - 値のフォーマット
  戻り値:
    変換結果の文字列

### toString

    public String toString(String valueFormat)

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

  定義:
    インタフェース `GridElement<DoubleNumber>` 内の `toString`
  パラメータ:
    `valueFormat` - 値のフォーマット
  戻り値:
    変換結果の文字列
  関連項目:
    `GridElement.toString(java.lang.String)`

### toString

    public String toString()

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

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

### isComplex

    public boolean isComplex()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isComplex`
  戻り値:
    複素数ならばtrue、そうでなければfalse
  関連項目:
    `Scalar.isComplex()`

### isReal

    public boolean isReal()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `isReal`
  戻り値:
    実数ならばtrue、そうでなければ false
  関連項目:
    `Scalar.isReal()`

### getImaginaryPart

    public DoubleNumber getImaginaryPart()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getImaginaryPart`
  戻り値:
    虚部
  関連項目:
    `Scalar.getImaginaryPart()`

### getRealPart

    public DoubleNumber getRealPart()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `getRealPart`
  戻り値:
    実部
  関連項目:
    `Scalar.getRealPart()`

### setRealPart

    public void setRealPart(int realPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(int)`

### setRealPart

    public void setRealPart(double realPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(double)`

### setRealPart

    public void setRealPart(Scalar<?> realPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setRealPart`
  パラメータ:
    `realPart` - 実部
  関連項目:
    `Scalar.setRealPart(org.mklab.nfc.scalar.Scalar)`

### setImaginaryPart

    public void setImaginaryPart(int imagPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setImaginaryPart`
  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(int)`

### setImaginaryPart

    public void setImaginaryPart(double imagPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setImaginaryPart`
  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(double)`

### setImaginaryPart

    public void setImaginaryPart(Scalar<?> imagPart)

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `setImaginaryPart`
  パラメータ:
    `imagPart` - 虚部
  関連項目:
    `Scalar.setImaginaryPart(org.mklab.nfc.scalar.Scalar)`

### toComplex

    public DoubleComplexNumber toComplex()

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

  定義:
    インタフェース `Scalar<DoubleNumber>` 内の `toComplex`
  戻り値:
    複素成分
  関連項目:
    `Scalar.toComplex()`

### createImagUnit

    public DoubleComplexNumber createImagUnit()

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

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

### createPI

    public DoubleNumber createPI()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `createPI`
  戻り値:
    円周率PI
  関連項目:
    `NumericalScalar.createPI()`

### createE

    public DoubleNumber createE()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `createE`
  戻り値:
    ネイピアの数(自然対数の底)
  関連項目:
    `NumericalScalar.createE()`

### valueOf

    public DoubleNumber valueOf(String numberString)

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `valueOf`
  パラメータ:
    `numberString` - 数を表す文字列
  戻り値:
    文字列に対応する数
  関連項目:
    `NumericalScalar.valueOf(java.lang.String)`

### equals

    public boolean equals(Object o)

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

### hashCode

    public int hashCode()

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

### getMachineEpsilon

    public DoubleNumber getMachineEpsilon()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `getMachineEpsilon`
  戻り値:
    機種精度(Machine Epsilon)
  関連項目:
    `NumericalScalar.getMachineEpsilon()`

### getInfinity

    public DoubleNumber getInfinity()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `getInfinity`
  戻り値:
    無限大
  関連項目:
    `NumericalScalar.getInfinity()`

### getNaN

    public DoubleNumber getNaN()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `getNaN`
  戻り値:
    NaN(Not a Number)
  関連項目:
    `NumericalScalar.getNaN()`

### createUniformRandomGenerator

    public RandomGenerator<DoubleNumber> createUniformRandomGenerator()

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

  定義:
    インタフェース `NumericalScalar<DoubleNumber>` 内の `createUniformRandomGenerator`
  戻り値:
    一様分布の乱数生成器
  関連項目:
    `NumericalScalar.createUniformRandomGenerator()`

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