com.singularsys.jep

## Class OperatorTable

- java.lang.Object
- - com.singularsys.jep.OperatorTable

- All Implemented Interfaces:
    JepComponent, OperatorTableI, java.io.Serializable
  Direct Known Subclasses:
    StandardOperatorTable

      public class OperatorTable
      extends java.lang.Object
      implements OperatorTableI

  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static int` | `baseNumOps` Number operators in this table.
    `protected int` | `numOps`
    `protected static int` | `OP_ADD`
    `protected static int` | `OP_AND`
    `protected static int` | `OP_ASSIGN`
    `protected static int` | `OP_CROSS`
    `protected static int` | `OP_DIVIDE`
    `protected static int` | `OP_DOT`
    `protected static int` | `OP_ELEMENT`
    `protected static int` | `OP_EQ`
    `protected static int` | `OP_GE`
    `protected static int` | `OP_GT`
    `protected static int` | `OP_LE`
    `protected static int` | `OP_LIST`
    `protected static int` | `OP_LT`
    `protected static int` | `OP_MOD`
    `protected static int` | `OP_MULTIPLY`
    `protected static int` | `OP_NE`
    `protected static int` | `OP_NEGATE`
    `protected static int` | `OP_NOP`
    `protected static int` | `OP_NOT`
    `protected static int` | `OP_OR`
    `protected static int` | `OP_POWER`
    `protected static int` | `OP_RANGE`
    `protected static int` | `OP_RECIP` unary division i.e. 1/x or x^(-1) *
    `protected static int` | `OP_SUBTRACT`
    `protected static int` | `OP_UPLUS`
    `protected Operator[]` | `ops`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `OperatorTable()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Operator` | `addOperator(int key, Operator op)` Add a operator with a given key.
    `Operator` | `addOperator(int key, Operator op, Operator existingOp)` Add operator with the same precedence level as an existing operator.
    `Operator` | `addOperator(Operator op)` Add a operator with no key specified.
    `Operator` | `addOperator(Operator op, Operator existingOp)` Add operator with the same precedence level as an existing operator.
    `Operator` | `appendOperator(int key, Operator op, Operator existingOp)` Add an operator which a new precedence level which is higher than the existing op
    `Operator` | `appendOperator(Operator op, Operator existingOp)` Add an operator which a new precedence level which is higher than the existing op
    `Operator` | `getAdd()`
    `Operator` | `getAnd()`
    `Operator` | `getAssign()`
    `Operator` | `getCross()`
    `Operator` | `getDivide()`
    `Operator` | `getDot()`
    `Operator` | `getEle()`
    `Operator` | `getEQ()`
    `Operator` | `getGE()`
    `Operator` | `getGT()`
    `Operator` | `getLE()`
    `JepComponent` | `getLightWeightInstance()` Gets a light-weight instance suitable for using in multiple threads.
    `Operator` | `getList()`
    `Operator` | `getLT()`
    `Operator` | `getMod()`
    `Operator` | `getMultiply()`
    `Operator` | `getNE()`
    `Operator` | `getNop()`
    `Operator` | `getNot()`
    `int` | `getNumOps()`
    `Operator` | `getOperator(int key)` Get operator by its key code.
    `java.util.Collection<Operator>` | `getOperators()`
    `Operator` | `getOperatorsByName(java.lang.String name)` Get the operator with a given name
    `java.util.List<Operator>` | `getOperatorsBySymbol(java.lang.String symbol)` Gets all the operators with a given symbol
    `Operator` | `getOr()`
    `Operator` | `getPower()`
    `Operator` | `getRange()`
    `Operator` | `getSubtract()`
    `Operator` | `getUDivide()` unary division i.e. 1/x or x^(-1) *
    `Operator` | `getUMinus()`
    `Operator` | `getUPlus()`
    `void` | `init(Jep jep)` Initialize the component.
    `Operator` | `insertOperator(int key, Operator op, Operator existingOp)` Add an operator with a new precedence level which is lower than the existing op.
    `Operator` | `insertOperator(Operator op, Operator existingOp)` Add an operator which a new precedence level which is lower than the existing op
    `void` | `removeOperator(Operator op)` Remove an operator from the table.
    `Operator` | `replaceOperator(Operator oldOp, Operator op)` replace an existing operator by a new one.
    `protected boolean` | `setBinaryInverseOp(int key1, int key2)`
    `protected boolean` | `setDistributiveOver(int key1, int key2)`
    `protected boolean` | `setInverseOp(int key1, int key2)`
    `protected void` | `setNumOps(int size)`
    `boolean` | `setPrecedenceTable(int[][] precArray)` Sets the precedence of all operators at one time.
    `protected boolean` | `setRootOp(int key1, int key2)`
    `protected void` | `setStandardOperatorRelations()` Sets up the standard relations between +,-,*,/
    `java.lang.String` | `toString()` String rep operators ordered by precedence, one per line.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### ops

          protected Operator[] ops

    - #### OP_NOP

          protected static final int OP_NOP

      See Also:
        Constant Field Values

    - #### OP_ADD

          protected static final int OP_ADD

      See Also:
        Constant Field Values

    - #### OP_SUBTRACT

          protected static final int OP_SUBTRACT

      See Also:
        Constant Field Values

    - #### OP_NEGATE

          protected static final int OP_NEGATE

      See Also:
        Constant Field Values

    - #### OP_UPLUS

          protected static final int OP_UPLUS

      See Also:
        Constant Field Values

    - #### OP_MULTIPLY

          protected static final int OP_MULTIPLY

      See Also:
        Constant Field Values

    - #### OP_DIVIDE

          protected static final int OP_DIVIDE

      See Also:
        Constant Field Values

    - #### OP_MOD

          protected static final int OP_MOD

      See Also:
        Constant Field Values

    - #### OP_RECIP

          protected static final int OP_RECIP

      unary division i.e. 1/x or x^(-1) *
      See Also:
        Constant Field Values

    - #### OP_POWER

          protected static final int OP_POWER

      See Also:
        Constant Field Values

    - #### OP_GT

          protected static final int OP_GT

      See Also:
        Constant Field Values

    - #### OP_LT

          protected static final int OP_LT

      See Also:
        Constant Field Values

    - #### OP_EQ

          protected static final int OP_EQ

      See Also:
        Constant Field Values

    - #### OP_LE

          protected static final int OP_LE

      See Also:
        Constant Field Values

    - #### OP_GE

          protected static final int OP_GE

      See Also:
        Constant Field Values

    - #### OP_NE

          protected static final int OP_NE

      See Also:
        Constant Field Values

    - #### OP_AND

          protected static final int OP_AND

      See Also:
        Constant Field Values

    - #### OP_OR

          protected static final int OP_OR

      See Also:
        Constant Field Values

    - #### OP_NOT

          protected static final int OP_NOT

      See Also:
        Constant Field Values

    - #### OP_ASSIGN

          protected static final int OP_ASSIGN

      See Also:
        Constant Field Values

    - #### OP_DOT

          protected static final int OP_DOT

      See Also:
        Constant Field Values

    - #### OP_CROSS

          protected static final int OP_CROSS

      See Also:
        Constant Field Values

    - #### OP_LIST

          protected static final int OP_LIST

      See Also:
        Constant Field Values

    - #### OP_ELEMENT

          protected static final int OP_ELEMENT

      See Also:
        Constant Field Values

    - #### OP_RANGE

          protected static final int OP_RANGE

      See Also:
        Constant Field Values

    - #### baseNumOps

          protected static final int baseNumOps

      Number operators in this table. Can be used by subclasses
      See Also:
        Constant Field Values

    - #### numOps

          protected int numOps

  - ### Constructor Detail

    - #### OperatorTable

          public OperatorTable()

  - ### Method Detail

    - #### init

          public void init(Jep jep)

      Description copied from interface: `JepComponent`
      Initialize the component. This methods is called whenever a component is added to Jep. Hence it allows components to keep track of the other components they may rely on.
      Specified by:
        `init` in interface `JepComponent`
      Parameters:
        `jep` - the current Jep instance

    - #### setNumOps

          protected void setNumOps(int size)

    - #### getNumOps

          public int getNumOps()

    - #### addOperator

          public Operator addOperator(int key,
                                      Operator op)

      Add a operator with a given key.
      Parameters:
        `key` - integer key value
        `op` -
      Returns:
        the operator op

    - #### addOperator

          public Operator addOperator(Operator op)

      Add a operator with no key specified.
      Parameters:
        `op` -
      Returns:
        the operator op

    - #### addOperator

          public Operator addOperator(int key,
                                      Operator op,
                                      Operator existingOp)

      Add operator with the same precedence level as an existing operator.
      Parameters:
        `key` -
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### addOperator

          public Operator addOperator(Operator op,
                                      Operator existingOp)

      Add operator with the same precedence level as an existing operator.
      Parameters:
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### insertOperator

          public Operator insertOperator(int key,
                                         Operator op,
                                         Operator existingOp)

      Add an operator with a new precedence level which is lower than the existing op. Increments the precedence of all operators with a greater precedence by one.
      Parameters:
        `key` -
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### insertOperator

          public Operator insertOperator(Operator op,
                                         Operator existingOp)

      Add an operator which a new precedence level which is lower than the existing op
      Parameters:
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### appendOperator

          public Operator appendOperator(int key,
                                         Operator op,
                                         Operator existingOp)

      Add an operator which a new precedence level which is higher than the existing op
      Parameters:
        `key` -
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### appendOperator

          public Operator appendOperator(Operator op,
                                         Operator existingOp)

      Add an operator which a new precedence level which is higher than the existing op
      Parameters:
        `op` -
        `existingOp` -
      Returns:
        the operator

    - #### removeOperator

          public void removeOperator(Operator op)

      Remove an operator from the table.
      Parameters:
        `op` - the operator to be removed

    - #### replaceOperator

          public Operator replaceOperator(Operator oldOp,
                                          Operator op)

      replace an existing operator by a new one.
      Parameters:
        `oldOp` - the old operator
        `op` - the new operator
      Returns:
        the new operator

    - #### getOperator

          public Operator getOperator(int key)

      Get operator by its key code. Most efficient way to get an operator.
      Parameters:
        `key` - code used in the table
      Returns:
        the operator or null if not found

    - #### getOperatorsBySymbol

          public java.util.List<Operator> getOperatorsBySymbol(java.lang.String symbol)

      Gets all the operators with a given symbol
      Specified by:
        `getOperatorsBySymbol` in interface `OperatorTableI`
      Parameters:
        `symbol` - symbol used for operator
      Returns:
        list of operators with a given symbol, empty list if none are found.

    - #### getOperatorsByName

          public Operator getOperatorsByName(java.lang.String name)

      Get the operator with a given name
      Specified by:
        `getOperatorsByName` in interface `OperatorTableI`
      Parameters:
        `name` - unique name of operator
      Returns:
        the operator or null if not found

    - #### getOperators

          public java.util.Collection<Operator> getOperators()

      Specified by:
        `getOperators` in interface `OperatorTableI`

    - #### setPrecedenceTable

          public final boolean setPrecedenceTable(int[][] precArray)

      Sets the precedence of all operators at one time. An array of arrays of key codes of operators is used to set the table operators with the same precedence are grouped together and listed from tighter binding to loose binding. For example

           setPrecedenceTable(new int[][] { { OP_NEGATE, OP_UPLUS, OP_NOT }, { OP_POWER },
                          { OP_MULTIPLY, OP_DIVIDE, OP_MOD, OP_DOT, OP_CROSS },
                          { OP_ADD, OP_SUBTRACT }, { OP_LT, OP_LE, OP_GT, OP_GE },
                          { OP_EQ, OP_NE }, { OP_AND }, { OP_OR }, { OP_ASSIGN },

           });

      Parameters:
        `precArray` -
      Returns:
        flag

    - #### setInverseOp

          protected boolean setInverseOp(int key1,
                                         int key2)

    - #### setBinaryInverseOp

          protected boolean setBinaryInverseOp(int key1,
                                               int key2)

    - #### setRootOp

          protected boolean setRootOp(int key1,
                                      int key2)

    - #### setDistributiveOver

          protected boolean setDistributiveOver(int key1,
                                                int key2)

    - #### setStandardOperatorRelations

          protected void setStandardOperatorRelations()

      Sets up the standard relations between +,-,*,/

    - #### getNop

          public Operator getNop()

      Specified by:
        `getNop` in interface `OperatorTableI`

    - #### getAdd

          public Operator getAdd()

      Specified by:
        `getAdd` in interface `OperatorTableI`

    - #### getSubtract

          public Operator getSubtract()

      Specified by:
        `getSubtract` in interface `OperatorTableI`

    - #### getUMinus

          public Operator getUMinus()

      Specified by:
        `getUMinus` in interface `OperatorTableI`

    - #### getUPlus

          public Operator getUPlus()

      Specified by:
        `getUPlus` in interface `OperatorTableI`

    - #### getMultiply

          public Operator getMultiply()

      Specified by:
        `getMultiply` in interface `OperatorTableI`

    - #### getDivide

          public Operator getDivide()

      Specified by:
        `getDivide` in interface `OperatorTableI`

    - #### getMod

          public Operator getMod()

      Specified by:
        `getMod` in interface `OperatorTableI`

    - #### getUDivide

          public Operator getUDivide()

      unary division i.e. 1/x or x^(-1) *
      Specified by:
        `getUDivide` in interface `OperatorTableI`

    - #### getPower

          public Operator getPower()

      Specified by:
        `getPower` in interface `OperatorTableI`

    - #### getGT

          public Operator getGT()

      Specified by:
        `getGT` in interface `OperatorTableI`

    - #### getLT

          public Operator getLT()

      Specified by:
        `getLT` in interface `OperatorTableI`

    - #### getEQ

          public Operator getEQ()

      Specified by:
        `getEQ` in interface `OperatorTableI`

    - #### getLE

          public Operator getLE()

      Specified by:
        `getLE` in interface `OperatorTableI`

    - #### getGE

          public Operator getGE()

      Specified by:
        `getGE` in interface `OperatorTableI`

    - #### getNE

          public Operator getNE()

      Specified by:
        `getNE` in interface `OperatorTableI`

    - #### getAnd

          public Operator getAnd()

      Specified by:
        `getAnd` in interface `OperatorTableI`

    - #### getOr

          public Operator getOr()

      Specified by:
        `getOr` in interface `OperatorTableI`

    - #### getNot

          public Operator getNot()

      Specified by:
        `getNot` in interface `OperatorTableI`

    - #### getAssign

          public Operator getAssign()

      Specified by:
        `getAssign` in interface `OperatorTableI`

    - #### getDot

          public Operator getDot()

      Specified by:
        `getDot` in interface `OperatorTableI`

    - #### getCross

          public Operator getCross()

      Specified by:
        `getCross` in interface `OperatorTableI`

    - #### getList

          public Operator getList()

      Specified by:
        `getList` in interface `OperatorTableI`

    - #### getEle

          public Operator getEle()

      Specified by:
        `getEle` in interface `OperatorTableI`

    - #### getRange

          public Operator getRange()

      Specified by:
        `getRange` in interface `OperatorTableI`

    - #### toString

          public java.lang.String toString()

      String rep operators ordered by precedence, one per line.
      Overrides:
        `toString` in class `java.lang.Object`

    - #### getLightWeightInstance

          public JepComponent getLightWeightInstance()

      Description copied from interface: `JepComponent`
      Gets a light-weight instance suitable for using in multiple threads.
      Specified by:
        `getLightWeightInstance` in interface `JepComponent`
      Returns:
        this

Copyright © 2018 Singular Systems http://www.singularsys.com/jep