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

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

    java.lang.Object
      org.mklab.nfc.scalar.AbstractScalar<E>
          org.mklab.nfc.scalar.AbstractSymbolicScalar<RationalPolynomial>
              org.mklab.nfc.scalar.RationalPolynomial

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

    public class RationalPolynomial

extends AbstractSymbolicScalar<RationalPolynomial>
implements MatxObject

有理多項式を表現するクラスです。

バージョン:
  $Revision: 1.123 $, 2008/02/16
作成者:
  koga
関連項目:
  直列化された形式

コンストラクタの概要
`RationalPolynomial(double numerator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(double numerator, Polynomial denominator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(double numerator, String variableName)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(int numerator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Polynomial numerator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Polynomial numerator, double denominator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Polynomial numerator, Polynomial denominator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Polynomial numerator, Scalar<?> denominator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Scalar<?> numerator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Scalar<?> numerator, Polynomial denominator)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。
`RationalPolynomial(Scalar<?> numerator, String variableName)` 新しく生成された`RationalPolynomial`オブジェクトを初期化します。

メソッドの概要
`RationalPolynomial` | `add(double value)` 値を加えます。
`RationalPolynomial` | `add(int value)` 値を加えます。
`RationalPolynomial` | `add(NumericalScalar<?> value)` 数値を加えた有理多項式を生成します。
`RationalPolynomial` | `add(Polynomial value)` 多項式を加えた有理多項式を生成します。
`RationalPolynomial` | `add(RationalPolynomial value)` 有理多項式を加えた有理多項式を生成します。
`Scalar<?>` | `add(Scalar<?> value)` 値を加えた成分を生成します。
`RationalPolynomial` | `addSelf(RationalPolynomial value)` 自身に有理多項式を加えます。
`RationalPolynomial` | `addSelf(Scalar<?> value)` 自身に値を加えます。
`RationalPolynomial` | `ceil()` 大きい整数に丸めます。
`RationalPolynomial` | `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`で指定された演算子で比較します。
`boolean` | `compare(String operator, RationalPolynomial opponent)` `opponent`を`operator`で指定された演算子で比較します。
`RationalPolynomial` | `conjugate()` 共役数を返します。
`RationalPolynomial` | `create(int value)` 与えられたint型に対応する値を返します。
`RationalPolynomial[]` | `createArray(int size)` グリッドの一次元配列を生成します。
`RationalPolynomial[][]` | `createArray(int rowSize, int columnSize)` グリッドの2次元配列を生成します。
`RationalPolynomialMatrix` | `createGrid(int rowSize, int columnSize, Scalar<? extends Scalar<?>>[][] elements)` 行列を生成します。
`RationalPolynomialMatrix` | `createGrid(Scalar<? extends Scalar<?>>[] elements)` ベクトルを生成します。
`RationalPolynomial` | `createUnit()` 単位成分を生成します。
`RationalPolynomial` | `createZero()` 零(デフォルトの初期値)を生成します。
`static RationalPolynomial[][]` | `createZeroArray(int rowSize, int columnSize, String variableName)` 成分が零である`RationalPolynomial`の2次元配列を返します。
`RationalPolynomial` | `derivative(int order)` 導関数を返します。
`RationalPolynomial` | `divide(double value)` 値で割ります。
`RationalPolynomial` | `divide(int value)` 値で割ります。
`RationalPolynomial` | `divide(NumericalScalar<?> value)` 数値で割った有理多項式を生成します。
`RationalPolynomial` | `divide(Polynomial value)` 多項式で割った有理多項式を生成します。
`RationalPolynomial` | `divide(RationalPolynomial value)` 有理多項式で割った有理多項式を生成します。
`Scalar<?>` | `divide(Scalar<?> value)` 値で割ります。
`boolean` | `equals(Object opponent)`
`boolean` | `equals(RationalPolynomial opponent, double tolerance)` 許容誤差内で有理多項式`opponent`と等しいか判定します。
`boolean` | `equals(RationalPolynomial opponent, NumericalScalar<?> tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(Scalar<?> opponent, double tolerance)` 許容範囲内で等しいか判定します。
`boolean` | `equals(SymbolicScalar<?> opponent, NumericalScalar<?> tolerance)` 許容範囲内で等しいか判定します。
`Scalar<?>` | `evaluate(double value)` 式変数に倍精度実数を代入した評価結果を返します。
`Scalar<?>` | `evaluate(int value)` 式変数に整数を代入した評価結果を返します。
`Matrix` | `evaluate(Matrix value)` 式変数に行列を代入した評価結果を返します。
`NumericalScalar<?>` | `evaluate(NumericalScalar<?> value)` 式変数に倍精度複素数を代入した評価結果を返します。
`RationalPolynomial` | `evaluate(Polynomial value)` 式変数に多項式を代入する評価します。
`RationalPolynomial` | `evaluate(RationalPolynomial value)` 式変数に有理多項式を代入する評価します。
`Scalar<?>` | `evaluate(Scalar<?> value)` 式変数にスカラーを代入した評価結果を返します。
`Matrix` | `evaluateElementWise(Matrix value)` 式変数に行列の各成分を代入した結果からなる行列を求めて返します。
`RationalPolynomial` | `fix()` ゼロ方向の整数に丸めます。
`RationalPolynomial` | `floor()` 小さい整数に丸めます。
`Operator` | `getAddOperator()` 足し算のオペレータを返します。
`Polynomial` | `getDenominator()` 分母多項式を返します。
`int` | `getDenominatorDegree()` 分母多項式の次数を返します。
`int` | `getDisplayWidth()` 出力の幅を返します。
`Operator` | `getDivideOperator()` 割り算のオペレータを返します。
`RationalPolynomial` | `getImaginaryPart()` 虚部を返します。
`Operator` | `getLeftDivideOperator()` 左からの割り算のオペレータを返します。
`Operator` | `getMultiplyOperator()` 掛け算のオペレータを返します。
`Polynomial` | `getNumerator()` 分子多項式を返します。
`int` | `getNumeratorDegree()` 分子多項式の次数を返します。
`Matrix` | `getPoles()` 極(分母多項式=0の解)を求めます。
`String` | `getPrintingString(String name)` 表示文字列を返します。
`String` | `getPrintingString(String name, String valueFormat)` 表示文字列を返します。
`Polynomial` | `getQuotient()` 分母多項式による分子多項式の除算の商多項式を返します。
`RationalPolynomial` | `getRealPart()` 実部を返します。
`Polynomial` | `getRemainder()` 分母多項式による分子多項式の除算の剰余(余り)多項式を返します。
`Operator` | `getSubtractOperator()` 引き算のオペレータを返します。
`String` | `getVariable()` 式変数を表す文字列を返します。
`Matrix` | `getZeros()` 零点(分子多項式=0の解)を求めます。
`int` | `hashCode()` Override hashCode.
`RationalPolynomial` | `inverse()` 逆数を求めます。
`boolean` | `isComplex()` 複素数であるか判定します。
`boolean` | `isFinite()` 有限であるか判定します。
`boolean` | `isInfinite()` 無限大であるか判定します。
`boolean` | `isNaN()` NaNであるか判定します。
`boolean` | `isReal()` 実数であるか判定します。
`boolean` | `isTransformableFrom(GridElement<?> value)` 引数で与えられた型からこの型へ変換可能か判定します。
`boolean` | `isUnit()` １(単位元)であるか判定します。
`boolean` | `isUnit(double tolerance)` 1(単位元)であるか判定します。
`boolean` | `isUnit(NumericalScalar<?> tolerance)` 1(単位元)であるか判定します。
`boolean` | `isZero()` 零(デフォルトの初期値)であるか判定します。
`boolean` | `isZero(double tolerance)` 零であるか判定します。
`boolean` | `isZero(NumericalScalar<?> tolerance)` 零であるか判定します。
`RationalPolynomial` | `leftDivide(double value)` 値を割ります。
`RationalPolynomial` | `leftDivide(int value)` 値を割ります。
`RationalPolynomial` | `leftDivide(NumericalScalar<?> value)` 数値を割った有理多項式を生成します。
`RationalPolynomial` | `leftDivide(Polynomial value)` 多項式を割った有理多項式を生成します。
`RationalPolynomial` | `leftDivide(RationalPolynomial value)` 有理多項式を割った有理多項式を生成します。
`Scalar<?>` | `leftDivide(Scalar<?> value)` 値を割ります。
`RationalPolynomial` | `multiply(double value)` 値を掛けます。
`RationalPolynomial` | `multiply(int value)` 値を掛けます。
`RationalPolynomial` | `multiply(NumericalScalar<?> value)` 数値を乗じた有理多項式を生成します。
`RationalPolynomial` | `multiply(Polynomial value)` 多項式を乗じた有理多項式を生成します。
`RationalPolynomial` | `multiply(RationalPolynomial value)` 有理多項式を乗じた有理多項式を生成します。
`Scalar<?>` | `multiply(Scalar<?> value)` 値を掛けます。
`RationalPolynomial` | `power(int m)` 累乗を返します。
`void` | `print()` 標準出力に出力(表示)します。
`void` | `print(String name)` 標準出力に出力(表示)します。
`void` | `print(String name, OutputStream output)` 出力ストリームに出力します。
`void` | `print(String name, OutputStream output, String valueFormat)` 出力ストリームに出力します。
`static RationalPolynomial` | `readMxFormat(InputStream input)` MX形式のデータを入力ストリームから入力します。
`static RationalPolynomial` | `readMxFormat(MxDataHead head, InputStream input)` MX形式のデータを入力ストリームから入力します。
`static RationalPolynomial` | `readMxFormat(String fileName)` MX形式のデータをファイルから入力します。
`RationalPolynomial` | `round()` 最も近い整数に丸めます。
`RationalPolynomial` | `roundToZero(double tolerance)` 絶対値が小さい成分を0に丸めます。
`RationalPolynomial` | `roundToZero(NumericalScalar<?> tolerance)` 絶対値が小さい成分を0に丸めます。
`void` | `setDisplayWidth(int displayWidth)` 出力の幅を設定します。
`void` | `setImaginaryPart(Scalar<?> imagPart)` 虚部を設定します。
`void` | `setImagPart(RationalPolynomial imagPart)` 複素有理多項式の虚部有理多項式を設定します。
`void` | `setRealPart(RationalPolynomial realPart)` 複素有理多項式の実部有理多項式を設定します。
`void` | `setRealPart(Scalar<?> realPart)` 実部を設定します。
`void` | `setVariable(String variableName)` 式変数を指定した文字列に変更します。
`RationalPolynomial` | `shiftHigher(int count)` 係数を次数の高い方向へシフトした値を返します。
`RationalPolynomial` | `shiftLower(int count)` 係数を次数の低い方向へシフトした値を返します。
`RationalPolynomial` | `subtract(double value)` 値を引く。
`RationalPolynomial` | `subtract(int value)` 値を引く。
`RationalPolynomial` | `subtract(NumericalScalar<?> value)` 数値を引いた有理多項式を生成します。
`RationalPolynomial` | `subtract(Polynomial value)` 多項式を引いた有理多項式を生成します。
`RationalPolynomial` | `subtract(RationalPolynomial value)` 有理多項式を引いた有理多項式を生成します。
`Scalar<?>` | `subtract(Scalar<?> value)` 値を引きます。
`RationalPolynomial` | `toComplex()` 複素成分に変換します。
`String` | `toMmString()` MM形式の文字列を生成します。
`String` | `toMmString(String format)` MM形式の文字列を生成します。
`String` | `toString()` 文字列に変換します。
`String[]` | `toString(boolean saving)` 文字列に変換します。
`String[]` | `toString(boolean saving, String valueFormat)` 文字列に変換します。
`String` | `toString(String valueFormat)` 文字列に変換します。
`RationalPolynomial` | `transformFrom(double value)` 実数から成分を生成します。
`RationalPolynomial` | `transformFrom(GridElement<?> value)` 引数で与えられた型からこの型へ変換します。
`RationalPolynomial` | `transformFrom(int value)` 整数から成分を生成します。
`RationalPolynomial` | `unaryMinus()` 符号を反転した値を返します。
`void` | `writeMmFormat(String fileName, String name)` MMファイル形式で行列データをファイルに出力します。
`void` | `writeMmFormat(Writer output, String name, boolean withNewLine)` MMフォーマット行列データをライターに出力します。
`void` | `writeMxFormat(OutputStream output, String name)` データをMX形式で出力ストリームへ出力します。
`void` | `writeMxFormat(String fileName, String name)` データをMX形式でファイルへ出力します。

クラス org.mklab.nfc.scalar.AbstractSymbolicScalar から継承されたメソッド
`derivative, setImaginaryPart, setImaginaryPart, setRealPart, setRealPart, shiftHigher, shiftLower`

クラス org.mklab.nfc.scalar.AbstractScalar から継承されたメソッド
`createGrid, createGrid, createGrid, createGrid, createZeroGrid, createZeroGrid, getDefaultFormat, getFormat, isTransformableTo, setDefaultFormat, setFormat, transformTo, 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 から継承されたメソッド
`isTransformableTo, transformTo`

コンストラクタの詳細

### RationalPolynomial

    public RationalPolynomial(double numerator,
                              Polynomial denominator)

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

  パラメータ:
    `numerator` - 分子定数(実数)
    `denominator` - 分母多項式

### RationalPolynomial

    public RationalPolynomial(Scalar<?> numerator,
                              Polynomial denominator)

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

  パラメータ:
    `numerator` - 分子定数(スカラー)
    `denominator` - 分母多項式

### RationalPolynomial

    public RationalPolynomial(Polynomial numerator,
                              Polynomial denominator)

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

  パラメータ:
    `numerator` - 分子多項式
    `denominator` - 分母多項式

### RationalPolynomial

    public RationalPolynomial(Polynomial numerator,
                              double denominator)

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

  パラメータ:
    `numerator` - 分子多項式
    `denominator` - 分母定数(実数)

### RationalPolynomial

    public RationalPolynomial(Polynomial numerator,
                              Scalar<?> denominator)

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

  パラメータ:
    `numerator` - 分子多項式
    `denominator` - 分母定数(スカラー)

### RationalPolynomial

    public RationalPolynomial(Polynomial numerator)

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

  パラメータ:
    `numerator` - 分子多項式

### RationalPolynomial

    public RationalPolynomial(int numerator)

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

  パラメータ:
    `numerator` - 分子実数

### RationalPolynomial

    public RationalPolynomial(double numerator)

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

  パラメータ:
    `numerator` - 分子実数

### RationalPolynomial

    public RationalPolynomial(double numerator,
                              String variableName)

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

  パラメータ:
    `numerator` - 分子実数
    `variableName` - 多項式変数

### RationalPolynomial

    public RationalPolynomial(Scalar<?> numerator)

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

  パラメータ:
    `numerator` - 分子スカラー

### RationalPolynomial

    public RationalPolynomial(Scalar<?> numerator,
                              String variableName)

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

  パラメータ:
    `numerator` - 分子複素数
    `variableName` - 多項式変数

メソッドの詳細

### create

    public RationalPolynomial create(int value)

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

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

### clone

    public RationalPolynomial clone()

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

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

### toString

    public String toString()

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

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

### toString

    public String toString(String valueFormat)

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

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

### equals

    public boolean equals(Object opponent)

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

### hashCode

    public int hashCode()

  Override hashCode.

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

### equals

    public boolean equals(RationalPolynomial opponent,
                          double tolerance)

  許容誤差内で有理多項式`opponent`と等しいか判定します。

  パラメータ:
    `opponent` - 比較する有理多項式
    `tolerance` - 許容誤差
  戻り値:
    等しければtrue、そうでなければfalse

### equals

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

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

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

### equals

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

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

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `equals`
  パラメータ:
    `opponent` - 比較する値
    `tolerance` - 許容誤差
  戻り値:
    等しければtrue、そうでなければfalse
  関連項目:
    `SymbolicScalar.equals(org.mklab.nfc.scalar.SymbolicScalar, org.mklab.nfc.scalar.NumericalScalar)`

### equals

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

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

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

### getNumeratorDegree

    public int getNumeratorDegree()

  分子多項式の次数を返します。

  戻り値:
    分子多項式の次数

### getDenominatorDegree

    public int getDenominatorDegree()

  分母多項式の次数を返します。

  戻り値:
    分母多項式の次数

### getNumerator

    public Polynomial getNumerator()

  分子多項式を返します。

  戻り値:
    分子多項式

### getDenominator

    public Polynomial getDenominator()

  分母多項式を返します。

  戻り値:
    分母多項式

### getVariable

    public String getVariable()

  インタフェース `SymbolicScalar` の記述:
  式変数を表す文字列を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `getVariable`
  戻り値:
    式変数を表す文字列
  関連項目:
    `SymbolicScalar.getVariable()`

### setVariable

    public void setVariable(String variableName)

  インタフェース `SymbolicScalar` の記述:
  式変数を指定した文字列に変更します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `setVariable`
  パラメータ:
    `variableName` - 設定する式変数
  関連項目:
    `SymbolicScalar.setVariable(java.lang.String)`

### add

    public RationalPolynomial add(RationalPolynomial value)

  有理多項式を加えた有理多項式を生成します。

  パラメータ:
    `value` - 加える有理多項式
  戻り値:
    足し算の結果

### addSelf

    public RationalPolynomial addSelf(RationalPolynomial value)

  自身に有理多項式を加えます。

  パラメータ:
    `value` - 加える有理多項式
  戻り値:
    自身

### addSelf

    public RationalPolynomial addSelf(Scalar<?> value)

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

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

### add

    public RationalPolynomial add(Polynomial value)

  多項式を加えた有理多項式を生成します。

  パラメータ:
    `value` - 加える多項式
  戻り値:
    足し算の結果

### add

    public RationalPolynomial add(double value)

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

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

### add

    public RationalPolynomial add(int value)

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

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

### subtract

    public RationalPolynomial subtract(RationalPolynomial value)

  有理多項式を引いた有理多項式を生成します。

  パラメータ:
    `value` - 引く有理多項式
  戻り値:
    引き算の結果

### subtract

    public RationalPolynomial subtract(Polynomial value)

  多項式を引いた有理多項式を生成します。

  パラメータ:
    `value` - 引く多項式
  戻り値:
    引き算の結果

### subtract

    public RationalPolynomial subtract(double value)

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

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

### subtract

    public RationalPolynomial subtract(int value)

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

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

### inverse

    public RationalPolynomial inverse()

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

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

### multiply

    public RationalPolynomial multiply(RationalPolynomial value)

  有理多項式を乗じた有理多項式を生成します。

  パラメータ:
    `value` - 乗じる有理多項式
  戻り値:
    掛け算の結果

### multiply

    public RationalPolynomial multiply(double value)

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

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

### multiply

    public RationalPolynomial multiply(int value)

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

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

### multiply

    public RationalPolynomial multiply(Polynomial value)

  多項式を乗じた有理多項式を生成します。

  パラメータ:
    `value` - 乗じる多項式
  戻り値:
    掛け算の結果

### divide

    public RationalPolynomial divide(double value)

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

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

### divide

    public RationalPolynomial divide(int value)

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

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

### divide

    public RationalPolynomial divide(Polynomial value)

  多項式で割った有理多項式を生成します。

  パラメータ:
    `value` - 割る多項式
  戻り値:
    割り算の結果

### divide

    public RationalPolynomial divide(RationalPolynomial value)

  有理多項式で割った有理多項式を生成します。

  パラメータ:
    `value` - 割る有理多項式
  戻り値:
    割り算の結果

### leftDivide

    public RationalPolynomial leftDivide(double value)

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

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

### leftDivide

    public RationalPolynomial leftDivide(int value)

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

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

### leftDivide

    public RationalPolynomial leftDivide(Polynomial value)

  多項式を割った有理多項式を生成します。

  パラメータ:
    `value` - 割られる多項式
  戻り値:
    割り算の結果

### leftDivide

    public RationalPolynomial leftDivide(RationalPolynomial value)

  有理多項式を割った有理多項式を生成します。

  パラメータ:
    `value` - 割られる有理多項式
  戻り値:
    割り算の結果

### power

    public RationalPolynomial power(int m)

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

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

### unaryMinus

    public RationalPolynomial unaryMinus()

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

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

### conjugate

    public RationalPolynomial conjugate()

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

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

### getRealPart

    public RationalPolynomial getRealPart()

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

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

### setRealPart

    public void setRealPart(RationalPolynomial realPart)

  複素有理多項式の実部有理多項式を設定します。

  パラメータ:
    `realPart` - 実部有理多項式

### setImagPart

    public void setImagPart(RationalPolynomial imagPart)

  複素有理多項式の虚部有理多項式を設定します。

  パラメータ:
    `imagPart` - 虚部有理多項式

### getImaginaryPart

    public RationalPolynomial getImaginaryPart()

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

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

### toComplex

    public RationalPolynomial toComplex()

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

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

### roundToZero

    public RationalPolynomial roundToZero(double tolerance)

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

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

### roundToZero

    public RationalPolynomial roundToZero(NumericalScalar<?> tolerance)

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

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

### round

    public RationalPolynomial round()

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

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

### ceil

    public RationalPolynomial ceil()

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

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

### floor

    public RationalPolynomial floor()

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

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

### fix

    public RationalPolynomial fix()

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

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

### evaluate

    public Scalar<?> evaluate(int value)

  インタフェース `SymbolicScalar` の記述:
  式変数に整数を代入した評価結果を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `evaluate`
  パラメータ:
    `value` - 代入する整数
  戻り値:
    式変数に整数を代入した評価結果
  関連項目:
    `SymbolicScalar.evaluate(int)`

### evaluate

    public Scalar<?> evaluate(double value)

  インタフェース `SymbolicScalar` の記述:
  式変数に倍精度実数を代入した評価結果を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `evaluate`
  パラメータ:
    `value` - 代入する倍精度実数
  戻り値:
    式変数に倍精度実数を代入した評価結果
  関連項目:
    `SymbolicScalar.evaluate(double)`

### evaluate

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

  インタフェース `SymbolicScalar` の記述:
  式変数に倍精度複素数を代入した評価結果を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `evaluate`
  パラメータ:
    `value` - 代入する倍精度複素数
  戻り値:
    式変数に倍精度複素数を代入した評価結果
  関連項目:
    `SymbolicScalar.evaluate(org.mklab.nfc.scalar.NumericalScalar)`

### evaluate

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

  インタフェース `SymbolicScalar` の記述:
  式変数にスカラーを代入した評価結果を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `evaluate`
  パラメータ:
    `value` - 代入するスカラー
  戻り値:
    式変数にスカラーを代入した評価結果
  関連項目:
    `SymbolicScalar.evaluate(org.mklab.nfc.scalar.Scalar)`

### evaluate

    public RationalPolynomial evaluate(Polynomial value)

  式変数に多項式を代入する評価します。

  パラメータ:
    `value` - 変数に代入する多項式
  戻り値:
    評価の結果

### evaluate

    public RationalPolynomial evaluate(RationalPolynomial value)

  式変数に有理多項式を代入する評価します。

  パラメータ:
    `value` - 代入する有理多項式
  戻り値:
    評価の結果

### evaluate

    public Matrix evaluate(Matrix value)

  インタフェース `SymbolicScalar` の記述:
  式変数に行列を代入した評価結果を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `evaluate`
  パラメータ:
    `value` - 代入する行列
  戻り値:
    式変数に行列を代入した評価結果
  関連項目:
    `SymbolicScalar.evaluate(org.mklab.nfc.matrix.Matrix)`

### evaluateElementWise

    public Matrix evaluateElementWise(Matrix value)

  式変数に行列の各成分を代入した結果からなる行列を求めて返します。

  パラメータ:
    `value` - 代入する値を成分とする行列
  戻り値:
    評価の結果

### getZeros

    public Matrix getZeros()

  零点(分子多項式=0の解)を求めます。

  戻り値:
    零点(分子多項式=0の解)

### getPoles

    public Matrix getPoles()

  極(分母多項式=0の解)を求めます。

  戻り値:
    極(分母多項式=0の解)

### derivative

    public RationalPolynomial derivative(int order)

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

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `derivative`
  パラメータ:
    `order` - 微分の階数
  戻り値:
    導関数
  関連項目:
    `SymbolicScalar.derivative(int)`

### shiftLower

    public RationalPolynomial shiftLower(int count)

  インタフェース `SymbolicScalar` の記述:
  係数を次数の低い方向へシフトした値を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `shiftLower`
  パラメータ:
    `count` - シフトする数
  戻り値:
    係数をシフトして得られる値
  関連項目:
    `SymbolicScalar.shiftLower(int)`

### shiftHigher

    public RationalPolynomial shiftHigher(int count)

  インタフェース `SymbolicScalar` の記述:
  係数を次数の高い方向へシフトした値を返します。

  定義:
    インタフェース `SymbolicScalar<RationalPolynomial>` 内の `shiftHigher`
  パラメータ:
    `count` - シフトする数
  戻り値:
    係数をシフトして得られる値
  関連項目:
    `SymbolicScalar.shiftHigher(int)`

### isReal

    public boolean isReal()

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

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

### isComplex

    public boolean isComplex()

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

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

### getQuotient

    public Polynomial getQuotient()

  分母多項式による分子多項式の除算の商多項式を返します。

  戻り値:
    分母多項式による分子多項式の除算の商多項式

### getRemainder

    public Polynomial getRemainder()

  分母多項式による分子多項式の除算の剰余(余り)多項式を返します。

  戻り値:
    分母多項式による分子多項式の除算の剰余(余り)多項式

### print

    public void print()

  標準出力に出力(表示)します。

  変数名はansです。

### print

    public void print(String name)

  標準出力に出力(表示)します。

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

### getPrintingString

    public String getPrintingString(String name)

  表示文字列を返します。

  パラメータ:
    `name` - 名前
  戻り値:
    表示文字列

### getPrintingString

    public String getPrintingString(String name,
                                    String valueFormat)

  表示文字列を返します。

  パラメータ:
    `name` - 名前
    `valueFormat` - 出力フォーマット
  戻り値:
    表示文字列

### print

    public void print(String name,
                      OutputStream output)

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

  パラメータ:
    `name` - 名前
    `output` - 出力ストリーム

### print

    public void print(String name,
                      OutputStream output,
                      String valueFormat)

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

  パラメータ:
    `name` - 名前
    `output` - 出力ストリーム
    `valueFormat` - 出力フォーマット

### 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)`

### toString

    public String[] toString(boolean saving)

  文字列に変換します。

  パラメータ:
    `saving` - ファイルに保存するならばtrue、そうでなければfalse
  戻り値:
    生成された文字列

### toString

    public String[] toString(boolean saving,
                             String valueFormat)

  文字列に変換します。

  パラメータ:
    `saving` - ファイルに保存するならばtrue、そうでなければfalse
    `valueFormat` - 係数の出力フォーマット
  戻り値:
    生成された文字列

### writeMxFormat

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

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

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

### writeMxFormat

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

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

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

### readMxFormat

    public static RationalPolynomial readMxFormat(String fileName)
                                           throws IOException

  MX形式のデータをファイルから入力します。

  パラメータ:
    `fileName` - ファイル名
  戻り値:
    読み込んだ有理多項式
  例外:
    `IOException` - ファイルから入力できない場合

### readMxFormat

    public static RationalPolynomial readMxFormat(InputStream input)
                                           throws IOException

  MX形式のデータを入力ストリームから入力します。

  パラメータ:
    `input` - 入力ストリーム
  戻り値:
    入力した有理多項式
  例外:
    `IOException` - 入力ストリームから入力できない場合

### readMxFormat

    public static RationalPolynomial readMxFormat(MxDataHead head,
                                                  InputStream input)
                                           throws IOException

  MX形式のデータを入力ストリームから入力します。 ヘッダ情報は先に指定している。

  パラメータ:
    `input` - 入力ストリーム
    `head` - ヘッダ情報
  戻り値:
    入力した有理多項式
  例外:
    `IOException` - 入力ストリームから入力できない場合

### writeMmFormat

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

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

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

### writeMmFormat

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

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

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

### compare

    public boolean compare(String operator,
                           RationalPolynomial opponent)

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

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

### createZero

    public RationalPolynomial createZero()

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

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

### isZero

    public boolean isZero()

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

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

### compare

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

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

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

### createArray

    public RationalPolynomial[] createArray(int size)

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

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

### createArray

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

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

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

### isFinite

    public boolean isFinite()

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

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

### isInfinite

    public boolean isInfinite()

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

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

### isNaN

    public boolean isNaN()

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

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

### compare

    public boolean compare(String operator,
                           double opponent)

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

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

### compare

    public boolean compare(String operator,
                           int opponent)

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

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

### isZero

    public boolean isZero(double tolerance)

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

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

### isZero

    public boolean isZero(NumericalScalar<?> tolerance)

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

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

### isUnit

    public boolean isUnit()

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

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

### isUnit

    public boolean isUnit(double tolerance)

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

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

### isUnit

    public boolean isUnit(NumericalScalar<?> tolerance)

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

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

### createGrid

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

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

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

### createGrid

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

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

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

### createUnit

    public RationalPolynomial createUnit()

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

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

### add

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

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

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

### add

    public RationalPolynomial add(NumericalScalar<?> value)

  数値を加えた有理多項式を生成します。

  パラメータ:
    `value` - 加えられる数値
  戻り値:
    足し算の結果

### subtract

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

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

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

### subtract

    public RationalPolynomial subtract(NumericalScalar<?> value)

  数値を引いた有理多項式を生成します。

  パラメータ:
    `value` - 引かれる数値
  戻り値:
    引き算の結果

### multiply

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

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

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

### multiply

    public RationalPolynomial multiply(NumericalScalar<?> value)

  数値を乗じた有理多項式を生成します。

  パラメータ:
    `value` - 乗じられる数値
  戻り値:
    掛け算の結果

### divide

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

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

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

### divide

    public RationalPolynomial divide(NumericalScalar<?> value)

  数値で割った有理多項式を生成します。

  パラメータ:
    `value` - 割る数値
  戻り値:
    割り算の結果

### leftDivide

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

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

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

### leftDivide

    public RationalPolynomial leftDivide(NumericalScalar<?> value)

  数値を割った有理多項式を生成します。

  パラメータ:
    `value` - 割られる数値
  戻り値:
    掛け算の結果

### transformFrom

    public RationalPolynomial transformFrom(int value)

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

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

### transformFrom

    public RationalPolynomial transformFrom(double value)

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

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

### transformFrom

    public RationalPolynomial transformFrom(GridElement<?> value)

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

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

### isTransformableFrom

    public boolean isTransformableFrom(GridElement<?> value)

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

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

### getAddOperator

    public Operator getAddOperator()

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

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

### getDivideOperator

    public Operator getDivideOperator()

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

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

### getLeftDivideOperator

    public Operator getLeftDivideOperator()

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

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

### getMultiplyOperator

    public Operator getMultiplyOperator()

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

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

### getSubtractOperator

    public Operator getSubtractOperator()

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

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

### createZeroArray

    public static RationalPolynomial[][] createZeroArray(int rowSize,
                                                         int columnSize,
                                                         String variableName)

  成分が零である`RationalPolynomial`の2次元配列を返します。

  パラメータ:
    `rowSize` - 行の数
    `columnSize` - 行の数
    `variableName` - 変数の名前
  戻り値:
    成分が零である`RationalPolynomial`の2次元配列を返します。

### setDisplayWidth

    public void setDisplayWidth(int displayWidth)

  出力の幅を設定します。

  パラメータ:
    `displayWidth` - 出力の幅

### getDisplayWidth

    public int getDisplayWidth()

  出力の幅を返します。

  戻り値:
    出力の幅

### setRealPart

    public void setRealPart(Scalar<?> realPart)

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

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

### setImaginaryPart

    public void setImaginaryPart(Scalar<?> imagPart)

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

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

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