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

## org.mklab.tool.control.system.math
クラス ConstantSystem

    java.lang.Object
      org.mklab.tool.control.system.SystemOperator
          org.mklab.tool.control.system.continuous.BaseContinuousStaticSystem
              org.mklab.tool.control.system.math.ConstantSystem

すべての実装されたインタフェース:
  Cloneable, ArrayElement<SystemOperator>, GridElement<SystemOperator>, ContinuousAlgebraicSystem, ReversePolishNotationOperand, ReversePolishNotationSymbol, ContinuousStaticSystem, LinearSystemOperator, StaticSystem, SymbolicOperator

直系の既知のサブクラス:
  DeMultiplexer, LqrStateFeedback, LqServoIntegratorGain, LqServoStateFeedback, Multiplexer, NegativeUnitSystem, PolePlaceStateFeedback, UnitSystem, UserDefinedConstantSystem

    public class ConstantSystem

extends BaseContinuousStaticSystem
implements LinearSystemOperator, SymbolicOperator, ReversePolishNotationOperand

定数システムを表わすクラスです。

バージョン:
  $Revision: 1.41 $, 2004/11/12
作成者:
  Koga Laboratory

コンストラクタの概要
`ConstantSystem(int inputSize, int outputSize)` 新しく生成された`ConstantSystem`オブジェクトを初期化します。
`ConstantSystem(Matrix gain)` 新しく生成された`ConstantSystem`オブジェクトを初期化します。

メソッドの概要
`ConstantSystem` | `add(ConstantSystem opponent)` 二つのシステムの和システムを返します。
`LinearSystemOperator` | `add(LinearSystemOperator opponent)` 二つのシステムの和(並列結合)システムを求めます。
`LinearSystemOperator` | `add(LinearSystemOperator opponent, boolean simplify)` 二つのシステムの和(並列結合)システムを求めます。
`ReversePolishNotationOperand` | `add(ReversePolishNotationOperand opponent)` thisにopponentを加えたオペランドを返します。
`void` | `addSymbol(ReversePolishNotationSymbol symbol)` symbolを逆ポーランド記法のスタック(リスト)に追加します。
`void` | `addSymbols(List<ReversePolishNotationSymbol> symbols)` symbolのリストを逆ポーランド記法のスタック(リスト)に追加します。
`ConstantSystem` | `clone()` 複製を生成します。
`ReversePolishNotationOperand` | `createNegativeUnitOperand(int size)` 負の単位値をもつオペランドを返します。
`ReversePolishNotationOperand` | `createOperand(Object value)` 指定された値をもつオペランドを返します。
`List<ReversePolishNotationSymbol>` | `createSymbolStack(ReversePolishNotationOperand opponent, ReversePolishNotationOperator operator)` opponent、this、オペレーターのスタック(リスト)を返します。
`ReversePolishNotationOperand` | `createUnitOperand(int size)` 単位値をもつオペランドを返します。
`boolean` | `equals(Object o)`
`ConstantSystem` | `feedback(ConstantSystem opponent)` (ネガティブ)フィードバック結合したシステムを返します。
`ConstantSystem` | `feedback(ConstantSystem opponent, boolean negativeFeedback)` フィードバック結合したシステムを返します。
`LinearSystemOperator` | `feedback(LinearSystemOperator system)` 二つのシステムを(ネガティブ)フィードバック結合したシステムを求めます。
`LinearSystemOperator` | `feedback(LinearSystemOperator opponent, boolean negativeFeedback)` 二つのシステムをフィードバック結合したシステムを求めます。
`LinearSystemOperator` | `feedback(LinearSystemOperator opponent, boolean negativeFeedback, boolean simplify)` 二つのシステムをフィードバック結合したシステムを求めます。
`Matrix` | `getA()` システム行列Aを返します。
`Matrix` | `getB()` 入力行列Bを返します。
`Matrix` | `getC()` 出力行列Cを返します。
`Matrix` | `getD()` ゲイン行列Dを返します。
`String` | `getExpression()` 数式を返します。
`Matrix` | `getGain()` 定数ゲイン行列を返します。
`LinearSystem` | `getLinearSystem()` 線形システムの場合、線形システムの式を返します。
`ReversePolishNotationOperand` | `getMultipliedSystem()` 掛け合わされたExpressionを持つSystemが返されます。
`Matrix` | `getOperandValue()` オペランドの値を返します。
`ReversePolishNotationOperand` | `getParsedOperand()` リストの中の要素を`ReversePolishNotationOperand.isNegative()`を評価し、add結合させてoperandにセットして返します。
`ConstantSystem` | `getSensitivityOfUnityFeedback(boolean negativeFeedback)` 単一フィードバック系の感度関数「(I + K)~」(負フィードバック)、「(I - K)~」(正フィードバック)を返します。
`String` | `getSignedExpression()` 符号付き数式表現を返します。
`String` | `getStringOfSymbol()` シンボルの文字列を返します。
`List<ReversePolishNotationSymbol>` | `getSymbolStack()` 逆ポーランド記法のスタック(リスト)を返します。
`String` | `getTag()` 識別するためのタグを返します。
`int` | `hashCode()`
`boolean` | `hasVariableA()` A行列を変数として扱うか判定します。
`boolean` | `hasVariableB()` B行列を変数として扱うか判定します。
`boolean` | `hasVariableC()` C行列を変数として扱うか判定します。
`boolean` | `hasVariableD()` D行列を変数として扱うか判定します。
`ConstantSystem` | `inverse()` 逆(逆数)を返します。
`ConstantSystem` | `invertSign()` 符号を反転した値を返します。
`boolean` | `isNegative()` 符号が負であるか判定します。
`boolean` | `isNegativeUnit()` 負の単位システムであるか判定します。
`boolean` | `isNegativeUnitOperand()` 負の単位値であるかを判定します。
`static boolean` | `isRequiringABCD()` 状態空間を求めるから判定します。
`boolean` | `isReversePolishNotationOperator()` オペレータであるか判定します。
`boolean` | `isSingleTerm()` 1個の項からなるシステムであるか判定します。
`boolean` | `isUnit()` 単位システムであるか判定します。
`boolean` | `isUnitOperand()` 単位値であるかを判定します。
`boolean` | `isUnityFeedbackWellPosed(boolean negativeFeedback)` 単一フィードバック系がwell-posedであるか判定します。
`boolean` | `isVariable()` 変数として扱うかを判定します。
`boolean` | `isZeroOperand()` ゼロであるかを判定します。
`ConstantSystem` | `multiply(ConstantSystem opponent)` 二つのシステムの積システムを返します。
`LinearSystemOperator` | `multiply(LinearSystemOperator system)` 二つのシステムの積(直列結合)システムを求めます。
`LinearSystemOperator` | `multiply(LinearSystemOperator opponent, boolean simplify)` 二つのシステムの積(直列結合)システムを求めます。
`ReversePolishNotationOperand` | `multiply(ReversePolishNotationOperand opponent)` thisにopponentを掛けたオペランドを返します。
`Matrix` | `outputEquation(double t, Matrix u)` 直達項をもつシステムの出力を返します。
`void` | `setExpression(String expression)` 数式を設定します。
`void` | `setGain(Matrix gain)` 定数ゲイン行列を設定します。
`void` | `setHasVariableA(boolean hasVariableA)` A行列を変数として扱うか設定します。
`void` | `setHasVariableB(boolean hasVariableB)` B行列を変数として扱うか設定します。
`void` | `setHasVariableC(boolean hasVariableC)` C行列を変数として扱うか設定します。
`void` | `setHasVariableD(boolean hasVariableD)` D行列を変数として扱うか設定します。
`void` | `setLinearSystem(LinearSystem system)` 線形システムを設定します。
`void` | `setNegative(boolean isNegative)` 符号を設定します。
`static void` | `setRequiringABCD(boolean reruiringABCD)` 状態空間を求めるか設定します。
`void` | `setSingleTerm(boolean singleTerm)` 1個の項からなるシステムであるかを設定します。
`void` | `setSymbolStack(List<ReversePolishNotationSymbol> reversePolishNotationSymbolStack)` 逆ポーランド記法のスタック(リスト)をセットします。
`void` | `setTag(String tag)` 識別するためのタグを設定します。
`protected void` | `setUnaryMinusExpression(ConstantSystem system)` 符号を反転した数式を設定します。
`void` | `setVariable(boolean isVariable)` 変数として扱うかを設定します。
`ConstantSystem` | `subtract(ConstantSystem opponent)` 二つのシステムの差システムを返します。
`LinearSystemOperator` | `subtract(LinearSystemOperator opponent)` 二つのシステムの差(並列結合)システムを求めます。
`LinearSystemOperator` | `subtract(LinearSystemOperator opponent, boolean simplify)` 二つのシステムの差(並列結合)システムを求めます。
`ConstantSystem` | `unaryMinus()` 出力の符合を反転したシステムを求めます。
`ConstantSystem` | `unityFeedback()` (ネガティブ)単一フィードバック結合したシステムを求めます。
`ConstantSystem` | `unityFeedback(boolean negativeFeedback)` 単一フィードバック結合したシステムを求めます。
`ConstantSystem` | `unityFeedback(boolean negativeFeedback, boolean simplify)` 単一フィードバック結合したシステムを求めます。

クラス org.mklab.tool.control.system.continuous.BaseContinuousStaticSystem から継承されたメソッド
`initialize, inputOutputEquation, outputEquation`

クラス org.mklab.tool.control.system.SystemOperator から継承されたメソッド
`compare, createArray, createArray, createGrid, createGrid, createZero, getInputSize, getOutputSize, getParameter, getParameters, getStateSize, hasDirectFeedthrough, isAutoSize, isDynamic, isForecdSystem, isInlet, isLinear, isOutlet, isSISO, isSizeDefined, isStatic, isTransformableFrom, isTransformableTo, isZero, resetAutoSize, setAutoSize, setDynamic, setForcedSystem, setHasDirectFeedthrough, setInlet, setInputSize, setLinear, setOutlet, setOutputSize, setParameter, setStateSize, setupParameters, toString, toString, transformFrom, transformTo`

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

コンストラクタの詳細

### ConstantSystem

    public ConstantSystem(int inputSize,
                          int outputSize)

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

  パラメータ:
    `inputSize` - 入力数
    `outputSize` - 出力数

### ConstantSystem

    public ConstantSystem(Matrix gain)

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

  パラメータ:
    `gain` - 定数ゲイン行列

メソッドの詳細

### setGain

    public void setGain(Matrix gain)

  定数ゲイン行列を設定します。

  パラメータ:
    `gain` - 定数ゲイン行列

### outputEquation

    public Matrix outputEquation(double t,
                                 Matrix u)

  インタフェース `StaticSystem` の記述:
  直達項をもつシステムの出力を返します。

  出力方程式を表します。

  定義:
    インタフェース `StaticSystem` 内の `outputEquation`
  オーバーライド:
    クラス `BaseContinuousStaticSystem` 内の `outputEquation`
  パラメータ:
    `t` - 時刻
    `u` - 入力
  戻り値:
    出力
  関連項目:
    `BaseContinuousStaticSystem.outputEquation(double, org.mklab.nfc.matrix.Matrix)`

### isUnit

    public boolean isUnit()

  単位システムであるか判定します。

  戻り値:
    単位システムならtrue、そうでなければfalse

### isNegativeUnit

    public boolean isNegativeUnit()

  負の単位システムであるか判定します。

  戻り値:
    負の単位システムならtrue、そうでなければfalse

### add

    public ConstantSystem add(ConstantSystem opponent)

  二つのシステムの和システムを返します。

  パラメータ:
    `opponent` - 足すシステム
  戻り値:
    結合したシステム

### subtract

    public ConstantSystem subtract(ConstantSystem opponent)

  二つのシステムの差システムを返します。

  パラメータ:
    `opponent` - 引くシステム
  戻り値:
    結合したシステム

### multiply

    public ConstantSystem multiply(ConstantSystem opponent)

  二つのシステムの積システムを返します。

  パラメータ:
    `opponent` - 掛けるシステム
  戻り値:
    結合したシステム

### feedback

    public ConstantSystem feedback(ConstantSystem opponent)

  (ネガティブ)フィードバック結合したシステムを返します。

  パラメータ:
    `opponent` - フィードバック成分
  戻り値:
    結合したシステム

### feedback

    public ConstantSystem feedback(ConstantSystem opponent,
                                   boolean negativeFeedback)

  フィードバック結合したシステムを返します。

  パラメータ:
    `opponent` - フィードバック要素
    `negativeFeedback` - ネガティブフィードバックならばtrue、そうでなければfalse
  戻り値:
    結合したシステム

### getGain

    public Matrix getGain()

  定数ゲイン行列を返します。

  戻り値:
    定数ゲイン行列

### getLinearSystem

    public LinearSystem getLinearSystem()

  クラス `SystemOperator` の記述:
  線形システムの場合、線形システムの式を返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getLinearSystem`
  オーバーライド:
    クラス `SystemOperator` 内の `getLinearSystem`
  戻り値:
    線形システムの式
  関連項目:
    `LinearSystemOperator.getLinearSystem()`

### setLinearSystem

    public void setLinearSystem(LinearSystem system)

  インタフェース `LinearSystemOperator` の記述:
  線形システムを設定します。

  入力数、出力数、状態数は、自動的に設定されませんので、別途設定をして下さい。

  定義:
    インタフェース `LinearSystemOperator` 内の `setLinearSystem`
  パラメータ:
    `system` - 線形システムのデータ
  関連項目:
    `LinearSystemOperator.setLinearSystem(org.mklab.tool.control.LinearSystem)`

### hasVariableA

    public boolean hasVariableA()

  インタフェース `LinearSystemOperator` の記述:
  A行列を変数として扱うか判定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `hasVariableA`
  戻り値:
    A行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.hasVariableA()`

### hasVariableB

    public boolean hasVariableB()

  インタフェース `LinearSystemOperator` の記述:
  B行列を変数として扱うか判定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `hasVariableB`
  戻り値:
    B行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.hasVariableB()`

### hasVariableC

    public boolean hasVariableC()

  インタフェース `LinearSystemOperator` の記述:
  C行列を変数として扱うか判定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `hasVariableC`
  戻り値:
    C行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.hasVariableC()`

### hasVariableD

    public boolean hasVariableD()

  インタフェース `LinearSystemOperator` の記述:
  D行列を変数として扱うか判定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `hasVariableD`
  戻り値:
    D行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.hasVariableD()`

### setHasVariableA

    public void setHasVariableA(boolean hasVariableA)

  インタフェース `LinearSystemOperator` の記述:
  A行列を変数として扱うか設定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `setHasVariableA`
  パラメータ:
    `hasVariableA` - A行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.setHasVariableA(boolean)`

### setHasVariableB

    public void setHasVariableB(boolean hasVariableB)

  インタフェース `LinearSystemOperator` の記述:
  B行列を変数として扱うか設定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `setHasVariableB`
  パラメータ:
    `hasVariableB` - B行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.setHasVariableB(boolean)`

### setHasVariableC

    public void setHasVariableC(boolean hasVariableC)

  インタフェース `LinearSystemOperator` の記述:
  C行列を変数として扱うか設定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `setHasVariableC`
  パラメータ:
    `hasVariableC` - C行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.setHasVariableC(boolean)`

### setHasVariableD

    public void setHasVariableD(boolean hasVariableD)

  インタフェース `LinearSystemOperator` の記述:
  D行列を変数として扱うか設定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `setHasVariableD`
  パラメータ:
    `hasVariableD` - D行列を変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `LinearSystemOperator.setHasVariableD(boolean)`

### getA

    public Matrix getA()

  インタフェース `LinearSystemOperator` の記述:
  システム行列Aを返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getA`
  戻り値:
    システム行列A
  関連項目:
    `LinearSystemOperator.getA()`

### getB

    public Matrix getB()

  インタフェース `LinearSystemOperator` の記述:
  入力行列Bを返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getB`
  戻り値:
    入力行列B
  関連項目:
    `LinearSystemOperator.getB()`

### getC

    public Matrix getC()

  インタフェース `LinearSystemOperator` の記述:
  出力行列Cを返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getC`
  戻り値:
    出力行列C
  関連項目:
    `LinearSystemOperator.getC()`

### getD

    public Matrix getD()

  インタフェース `LinearSystemOperator` の記述:
  ゲイン行列Dを返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getD`
  戻り値:
    ゲイン行列D
  関連項目:
    `LinearSystemOperator.getD()`

### add

    public LinearSystemOperator add(LinearSystemOperator opponent)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの和(並列結合)システムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `add`
  パラメータ:
    `opponent` - 加えるシステム
  戻り値:
    並列結合システム
  関連項目:
    `LinearSystemOperator.add(org.mklab.tool.control.system.LinearSystemOperator)`

### add

    public LinearSystemOperator add(LinearSystemOperator opponent,
                                    boolean simplify)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの和(並列結合)システムを求めます。

  定義:
    インタフェース `LinearSystemOperator` 内の `add`
  パラメータ:
    `opponent` - 加えるシステム
    `simplify` - 生成されるシステムを簡単化するならばtrue、そうでなければfalse
  戻り値:
    並列結合システム
  関連項目:
    `LinearSystemOperator.add(org.mklab.tool.control.system.LinearSystemOperator, boolean)`

### subtract

    public LinearSystemOperator subtract(LinearSystemOperator opponent)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの差(並列結合)システムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `subtract`
  パラメータ:
    `opponent` - 引くシステム
  戻り値:
    並列結合システム
  関連項目:
    `LinearSystemOperator.subtract(org.mklab.tool.control.system.LinearSystemOperator)`

### subtract

    public LinearSystemOperator subtract(LinearSystemOperator opponent,
                                         boolean simplify)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの差(並列結合)システムを求めます。

  定義:
    インタフェース `LinearSystemOperator` 内の `subtract`
  パラメータ:
    `opponent` - 引くシステム
    `simplify` - 生成されるシステムを簡単化するならばtrue、そうでなければfalse
  戻り値:
    並列結合システム
  関連項目:
    `LinearSystemOperator.subtract(org.mklab.tool.control.system.LinearSystemOperator, boolean)`

### multiply

    public LinearSystemOperator multiply(LinearSystemOperator system)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの積(直列結合)システムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `multiply`
  パラメータ:
    `system` - 掛けられるシステム
  戻り値:
    直列結合システム
  関連項目:
    `LinearSystemOperator.multiply(org.mklab.tool.control.system.LinearSystemOperator)`

### multiply

    public LinearSystemOperator multiply(LinearSystemOperator opponent,
                                         boolean simplify)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムの積(直列結合)システムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `multiply`
  パラメータ:
    `opponent` - 掛けられるシステム
    `simplify` - 生成されるシステムを簡単化するならばtrue、そうでなければfalse
  戻り値:
    直列結合システム
  関連項目:
    `LinearSystemOperator.multiply(org.mklab.tool.control.system.LinearSystemOperator, boolean)`

### feedback

    public LinearSystemOperator feedback(LinearSystemOperator system)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムを(ネガティブ)フィードバック結合したシステムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `feedback`
  パラメータ:
    `system` - フィードバック要素のシステム
  戻り値:
    フィードバック結合システム
  関連項目:
    `LinearSystemOperator.feedback(org.mklab.tool.control.system.LinearSystemOperator)`

### feedback

    public LinearSystemOperator feedback(LinearSystemOperator opponent,
                                         boolean negativeFeedback)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムをフィードバック結合したシステムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `feedback`
  パラメータ:
    `opponent` - フィードバック要素のシステム
    `negativeFeedback` - ネガティブフィードバックならばtrue、そうでなければfalse
  戻り値:
    フィードバック結合システム
  関連項目:
    `LinearSystemOperator.feedback(org.mklab.tool.control.system.LinearSystemOperator, boolean)`

### feedback

    public LinearSystemOperator feedback(LinearSystemOperator opponent,
                                         boolean negativeFeedback,
                                         boolean simplify)

  インタフェース `LinearSystemOperator` の記述:
  二つのシステムをフィードバック結合したシステムを求めます。

  定義:
    インタフェース `LinearSystemOperator` 内の `feedback`
  パラメータ:
    `opponent` - フィードバック要素のシステム
    `negativeFeedback` - ネガティブフィードバックならばtrue、そうでなければfalse
    `simplify` - 生成されるシステムを簡単化するならばtrue、そうでなければfalse
  戻り値:
    フィードバック結合システム
  関連項目:
    `LinearSystemOperator.feedback(org.mklab.tool.control.system.LinearSystemOperator, boolean, boolean)`

### unaryMinus

    public ConstantSystem unaryMinus()

  インタフェース `LinearSystemOperator` の記述:
  出力の符合を反転したシステムを求めます。

  定義:
    インタフェース `LinearSystemOperator` 内の `unaryMinus`
  戻り値:
    出力の符合を反転したシステム
  関連項目:
    `LinearSystemOperator.unaryMinus()`

### setUnaryMinusExpression

    protected void setUnaryMinusExpression(ConstantSystem system)

  符号を反転した数式を設定します。

  パラメータ:
    `system` - 対象となるシステム

### unityFeedback

    public ConstantSystem unityFeedback()

  インタフェース `LinearSystemOperator` の記述:
  (ネガティブ)単一フィードバック結合したシステムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `unityFeedback`
  戻り値:
    (ネガティブ)単一フィードバック結合システム
  関連項目:
    `LinearSystemOperator.unityFeedback()`

### unityFeedback

    public ConstantSystem unityFeedback(boolean negativeFeedback)

  インタフェース `LinearSystemOperator` の記述:
  単一フィードバック結合したシステムを求めます。

  生成されるシステムを簡単化します。

  定義:
    インタフェース `LinearSystemOperator` 内の `unityFeedback`
  パラメータ:
    `negativeFeedback` - ネガティブフィードバックならばtrue、そうでなければfalse
  戻り値:
    (ネガティブ)単一フィードバック結合システム
  関連項目:
    `LinearSystemOperator.unityFeedback(boolean)`

### unityFeedback

    public ConstantSystem unityFeedback(boolean negativeFeedback,
                                        boolean simplify)

  インタフェース `LinearSystemOperator` の記述:
  単一フィードバック結合したシステムを求めます。

  定義:
    インタフェース `LinearSystemOperator` 内の `unityFeedback`
  パラメータ:
    `negativeFeedback` - ネガティブフィードバックならばtrue、そうでなければfalse
    `simplify` - 生成されるシステムを簡単化するならばtrue、そうでなければfalse
  戻り値:
    (ネガティブ)単一フィードバック結合システム
  関連項目:
    `LinearSystemOperator.unityFeedback(boolean, boolean)`

### isUnityFeedbackWellPosed

    public boolean isUnityFeedbackWellPosed(boolean negativeFeedback)

  単一フィードバック系がwell-posedであるか判定します。

  (I + G)または(I - G)が正則であるか判定します。

  パラメータ:
    `negativeFeedback` - 負フィードバックならばtrue、正フィードバックならばfalse
  戻り値:
    単一フィードバック系がwell-posedならばtrue、そうでなければfalse

### getSensitivityOfUnityFeedback

    public ConstantSystem getSensitivityOfUnityFeedback(boolean negativeFeedback)

  単一フィードバック系の感度関数「(I + K)~」(負フィードバック)、「(I - K)~」(正フィードバック)を返します。

  パラメータ:
    `negativeFeedback` - 負フィードバックならばtrue、正フィードバックならばfalse
  戻り値:
    単一フィードバック系の感度関数「(I + K)~」(負フィードバック)、「(I - K)~」(正フィードバック)

### inverse

    public ConstantSystem inverse()

  インタフェース `ReversePolishNotationOperand` の記述:
  逆(逆数)を返します。

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

### getExpression

    public String getExpression()

  インタフェース `SymbolicOperator` の記述:
  数式を返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `getExpression`
  定義:
    インタフェース `SymbolicOperator` 内の `getExpression`
  戻り値:
    数式
  関連項目:
    `SymbolicOperator.getExpression()`

### setExpression

    public void setExpression(String expression)

  インタフェース `SymbolicOperator` の記述:
  数式を設定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `setExpression`
  定義:
    インタフェース `SymbolicOperator` 内の `setExpression`
  パラメータ:
    `expression` - 数式
  関連項目:
    `SymbolicOperator.setExpression(java.lang.String)`

### getTag

    public String getTag()

  インタフェース `LinearSystemOperator` の記述:
  識別するためのタグを返します。

  定義:
    インタフェース `LinearSystemOperator` 内の `getTag`
  戻り値:
    識別するためのタグ
  関連項目:
    `LinearSystemOperator.getTag()`

### setTag

    public void setTag(String tag)

  インタフェース `LinearSystemOperator` の記述:
  識別するためのタグを設定します。

  定義:
    インタフェース `LinearSystemOperator` 内の `setTag`
  パラメータ:
    `tag` - タグ
  関連項目:
    `LinearSystemOperator.setTag(java.lang.String)`

### isRequiringABCD

    public static boolean isRequiringABCD()

  状態空間を求めるから判定します。

  戻り値:
    状態空間を求めるならばtrue、そうでなければfalse

### setRequiringABCD

    public static void setRequiringABCD(boolean reruiringABCD)

  状態空間を求めるか設定します。

  パラメータ:
    `reruiringABCD` - 状態空間を求めるならばtrue、そうでなければfalse

### isSingleTerm

    public boolean isSingleTerm()

  1個の項からなるシステムであるか判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isSingleTerm`
  戻り値:
    1個の項からなるシステムならばtrue、そうでなければfalse

### setSingleTerm

    public void setSingleTerm(boolean singleTerm)

  1個の項からなるシステムであるかを設定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `setSingleTerm`
  パラメータ:
    `singleTerm` - 1個の項からなるシステムならばtrue、そうでなければfalse

### clone

    public ConstantSystem clone()

  インタフェース `GridElement` の記述:
  複製を生成します。

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

### hashCode

    public int hashCode()

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

### getSignedExpression

    public String getSignedExpression()

  インタフェース `ReversePolishNotationOperand` の記述:
  符号付き数式表現を返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `getSignedExpression`
  戻り値:
    符号付き数式表現
  関連項目:
    `ReversePolishNotationOperand.getSignedExpression()`

### getParsedOperand

    public ReversePolishNotationOperand getParsedOperand()

  インタフェース `ReversePolishNotationOperand` の記述:
  リストの中の要素を`ReversePolishNotationOperand.isNegative()`を評価し、add結合させてoperandにセットして返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `getParsedOperand`
  戻り値:
    オペランド
  関連項目:
    `ReversePolishNotationOperand.getParsedOperand()`

### setSymbolStack

    public void setSymbolStack(List<ReversePolishNotationSymbol> reversePolishNotationSymbolStack)

  インタフェース `ReversePolishNotationOperand` の記述:
  逆ポーランド記法のスタック(リスト)をセットします。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `setSymbolStack`
  パラメータ:
    `reversePolishNotationSymbolStack` - 逆ポーランド記法のスタック(リスト)
  関連項目:
    `ReversePolishNotationOperand.setSymbolStack(java.util.List)`

### getSymbolStack

    public List<ReversePolishNotationSymbol> getSymbolStack()

  インタフェース `ReversePolishNotationOperand` の記述:
  逆ポーランド記法のスタック(リスト)を返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `getSymbolStack`
  戻り値:
    逆ポーランド記法のスタック(リスト)
  関連項目:
    `ReversePolishNotationOperand.getSymbolStack()`

### addSymbol

    public void addSymbol(ReversePolishNotationSymbol symbol)

  インタフェース `ReversePolishNotationOperand` の記述:
  symbolを逆ポーランド記法のスタック(リスト)に追加します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `addSymbol`
  パラメータ:
    `symbol` - 加えるシンボル
  関連項目:
    `ReversePolishNotationOperand.addSymbol(org.mklab.nfc.rpn.ReversePolishNotationSymbol)`

### addSymbols

    public void addSymbols(List<ReversePolishNotationSymbol> symbols)

  インタフェース `ReversePolishNotationOperand` の記述:
  symbolのリストを逆ポーランド記法のスタック(リスト)に追加します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `addSymbols`
  パラメータ:
    `symbols` - 加えるシンボルのリスト
  関連項目:
    `ReversePolishNotationOperand.addSymbols(java.util.List)`

### getStringOfSymbol

    public String getStringOfSymbol()

  インタフェース `ReversePolishNotationSymbol` の記述:
  シンボルの文字列を返します。

  定義:
    インタフェース `ReversePolishNotationSymbol` 内の `getStringOfSymbol`
  戻り値:
    シンボルの文字列
  関連項目:
    `ReversePolishNotationSymbol.getStringOfSymbol()`

### isNegative

    public boolean isNegative()

  インタフェース `ReversePolishNotationOperand` の記述:
  符号が負であるか判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isNegative`
  戻り値:
    負ならばtrue、正なら(ゼロを含む)false
  関連項目:
    `ReversePolishNotationOperand.isNegative()`

### isReversePolishNotationOperator

    public boolean isReversePolishNotationOperator()

  インタフェース `ReversePolishNotationSymbol` の記述:
  オペレータであるか判定します。

  定義:
    インタフェース `ReversePolishNotationSymbol` 内の `isReversePolishNotationOperator`
  戻り値:
    オペレータならばtrue、そうでなければfalse
  関連項目:
    `ReversePolishNotationSymbol.isReversePolishNotationOperator()`

### createSymbolStack

    public List<ReversePolishNotationSymbol> createSymbolStack(ReversePolishNotationOperand opponent,
                                                               ReversePolishNotationOperator operator)

  インタフェース `ReversePolishNotationOperand` の記述:
  opponent、this、オペレーターのスタック(リスト)を返します。

  オペランドのスタックは展開されます。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `createSymbolStack`
  パラメータ:
    `opponent` - 演算の対象オペランド
    `operator` - オペレーター
  戻り値:
    opponent、this、オペレーターのスタック(リスト)
  関連項目:
    `ReversePolishNotationOperand.createSymbolStack(org.mklab.nfc.rpn.ReversePolishNotationOperand, org.mklab.nfc.rpn.ReversePolishNotationOperator)`

### setNegative

    public void setNegative(boolean isNegative)

  インタフェース `ReversePolishNotationOperand` の記述:
  符号を設定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `setNegative`
  パラメータ:
    `isNegative` - 負ならばtrue、正(ゼロを含む)ならばfalse
  関連項目:
    `ReversePolishNotationOperand.setNegative(boolean)`

### invertSign

    public ConstantSystem invertSign()

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

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

### isZeroOperand

    public boolean isZeroOperand()

  インタフェース `ReversePolishNotationOperand` の記述:
  ゼロであるかを判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isZeroOperand`
  戻り値:
    ゼロならばtrue,そうでなければfalse
  関連項目:
    `ReversePolishNotationOperand.isZeroOperand()`

### add

    public ReversePolishNotationOperand add(ReversePolishNotationOperand opponent)

  インタフェース `ReversePolishNotationOperand` の記述:
  thisにopponentを加えたオペランドを返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `add`
  パラメータ:
    `opponent` - 加える値
  戻り値:
    thisにopponentを加えたオペランド
  関連項目:
    `ReversePolishNotationOperand.add(org.mklab.nfc.rpn.ReversePolishNotationOperand)`

### multiply

    public ReversePolishNotationOperand multiply(ReversePolishNotationOperand opponent)

  インタフェース `ReversePolishNotationOperand` の記述:
  thisにopponentを掛けたオペランドを返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `multiply`
  パラメータ:
    `opponent` - 掛ける値
  戻り値:
    thisにopponentを掛けたオペランド
  関連項目:
    `ReversePolishNotationOperand.multiply(org.mklab.nfc.rpn.ReversePolishNotationOperand)`

### getMultipliedSystem

    public ReversePolishNotationOperand getMultipliedSystem()

  掛け合わされたExpressionを持つSystemが返されます。

  戻り値:
    掛け合わされたExpressionを持つSystem

### equals

    public boolean equals(Object o)

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

### createOperand

    public ReversePolishNotationOperand createOperand(Object value)

  インタフェース `ReversePolishNotationOperand` の記述:
  指定された値をもつオペランドを返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `createOperand`
  パラメータ:
    `value` - 値
  戻り値:
    指定された値をもつオペランド
  関連項目:
    `ReversePolishNotationOperand.createOperand(java.lang.Object)`

### createUnitOperand

    public ReversePolishNotationOperand createUnitOperand(int size)

  インタフェース `ReversePolishNotationOperand` の記述:
  単位値をもつオペランドを返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `createUnitOperand`
  パラメータ:
    `size` - 大きさ
  戻り値:
    単位値をもつオペランド
  関連項目:
    `ReversePolishNotationOperand.createUnitOperand(int)`

### createNegativeUnitOperand

    public ReversePolishNotationOperand createNegativeUnitOperand(int size)

  インタフェース `ReversePolishNotationOperand` の記述:
  負の単位値をもつオペランドを返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `createNegativeUnitOperand`
  パラメータ:
    `size` - 大きさ
  戻り値:
    負の単位値をもつオペランド
  関連項目:
    `ReversePolishNotationOperand.createNegativeUnitOperand(int)`

### setVariable

    public void setVariable(boolean isVariable)

  インタフェース `ReversePolishNotationOperand` の記述:
  変数として扱うかを設定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `setVariable`
  パラメータ:
    `isVariable` - 変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `ReversePolishNotationOperand.setVariable(boolean)`

### isVariable

    public boolean isVariable()

  インタフェース `ReversePolishNotationOperand` の記述:
  変数として扱うかを判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isVariable`
  戻り値:
    変数として扱うならばtrue、そうでなければfalse
  関連項目:
    `ReversePolishNotationOperand.isVariable()`

### isUnitOperand

    public boolean isUnitOperand()

  インタフェース `ReversePolishNotationOperand` の記述:
  単位値であるかを判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isUnitOperand`
  戻り値:
    単位値ならばtrue,そうでなければfalse
  関連項目:
    `ReversePolishNotationOperand.isUnitOperand()`

### isNegativeUnitOperand

    public boolean isNegativeUnitOperand()

  インタフェース `ReversePolishNotationOperand` の記述:
  負の単位値であるかを判定します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `isNegativeUnitOperand`
  戻り値:
    負の単位値ならばtrue,そうでなければfalse
  関連項目:
    `ReversePolishNotationOperand.isNegativeUnitOperand()`

### getOperandValue

    public Matrix getOperandValue()

  インタフェース `ReversePolishNotationOperand` の記述:
  オペランドの値を返します。

  定義:
    インタフェース `ReversePolishNotationOperand` 内の `getOperandValue`
  戻り値:
    オペランドの値
  関連項目:
    `ReversePolishNotationOperand.getOperandValue()`

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