com.singularsys.jep

## Class EmptyOperatorTable

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

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

      public class EmptyOperatorTable
      extends java.lang.Object
      implements OperatorTableI

  A base class for operator tables, this class has no pre-defined operators. For most cases its subclass `OperatorTable2` should be used which has the standard set of operators.

  This class has a sub-interface `OperatorKey` which is used to index operators, enums using this are defined in `OperatorTable2`.

  Since:
    3.4
  Author:
    Richard Morris
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `EmptyOperatorTable.OperatorKey` All operators enums must implement this interface.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `EmptyOperatorTable()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `Operator` | `addOperator(EmptyOperatorTable.OperatorKey key, Operator op)` Add a operator with a given key.
    `Operator` | `addOperator(EmptyOperatorTable.OperatorKey key, Operator op, Operator existingOp)` Add operator with the same precedence level as an existing operator.
    `Operator` | `appendOperator(EmptyOperatorTable.OperatorKey key, Operator op, Operator existingOp)` Add an operator with a new precedence level which is lower than the existing op.
    `java.util.Set<java.util.Map.Entry<EmptyOperatorTable.OperatorKey,Operator>>` | `entrySet()`
    `Operator` | `getAdd()` Returns the operator used for addition.
    `Operator` | `getAnd()`
    `Operator` | `getAssign()`
    `Operator` | `getCross()`
    `Operator` | `getDivide()`
    `Operator` | `getDot()`
    `Operator` | `getEle()`
    `Operator` | `getEQ()`
    `Operator` | `getGE()`
    `Operator` | `getGT()`
    `EmptyOperatorTable.OperatorKey` | `getKey(Operator op)` Gets the key associated with a specific operator
    `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(EmptyOperatorTable.OperatorKey key)` Get operator by its key code.
    `java.util.Collection<Operator>` | `getOperators()` Return the full list of operators
    `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(EmptyOperatorTable.OperatorKey key, Operator op, Operator existingOp)` Add operator with the same precedence level as an existing operator.
    `java.util.Set<EmptyOperatorTable.OperatorKey>` | `keySet()`
    `void` | `removeOperator(EmptyOperatorTable.OperatorKey key)` Remove a give operator from the table
    `void` | `removeOperator(Operator op)` Remove a give operator from the table
    `void` | `replaceOperator(EmptyOperatorTable.OperatorKey key, Operator op)` Replace a give operator with a new one.
    `void` | `replaceOperator(Operator oldOp, Operator op)` Replace a give operator with a new one.
    `protected boolean` | `setBinaryInverseOp(EmptyOperatorTable.OperatorKey key1, EmptyOperatorTable.OperatorKey key2)`
    `protected boolean` | `setDistributiveOver(EmptyOperatorTable.OperatorKey key1, EmptyOperatorTable.OperatorKey key2)`
    `protected void` | `setGroupOperatorRelations(EmptyOperatorTable.OperatorKey root, EmptyOperatorTable.OperatorKey inv, EmptyOperatorTable.OperatorKey composite)` Sets relations of three operators.
    `protected void` | `setGroupOperatorRelations(Operator root, Operator inv, Operator composite)` Sets relations of three operators.
    `protected boolean` | `setInverseOp(EmptyOperatorTable.OperatorKey key1, EmptyOperatorTable.OperatorKey key2)`
    `boolean` | `setPrecedenceTable(EmptyOperatorTable.OperatorKey[][] precArray)` Sets the precedence of all operators at one time.
    `protected boolean` | `setRootOp(EmptyOperatorTable.OperatorKey key1, EmptyOperatorTable.OperatorKey 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`

- - ### Constructor Detail

    - #### EmptyOperatorTable

          public EmptyOperatorTable()

  - ### Method Detail

    - #### getAdd

          public Operator getAdd()

      Returns the operator used for addition.
      Specified by:
        `getAdd` in interface `OperatorTableI`

    - #### getAnd

          public Operator getAnd()

      Specified by:
        `getAnd` in interface `OperatorTableI`

    - #### getAssign

          public Operator getAssign()

      Specified by:
        `getAssign` in interface `OperatorTableI`

    - #### getCross

          public Operator getCross()

      Specified by:
        `getCross` in interface `OperatorTableI`

    - #### getDivide

          public Operator getDivide()

      Specified by:
        `getDivide` in interface `OperatorTableI`

    - #### getDot

          public Operator getDot()

      Specified by:
        `getDot` in interface `OperatorTableI`

    - #### getEQ

          public Operator getEQ()

      Specified by:
        `getEQ` in interface `OperatorTableI`

    - #### getEle

          public Operator getEle()

      Specified by:
        `getEle` in interface `OperatorTableI`

    - #### getGE

          public Operator getGE()

      Specified by:
        `getGE` in interface `OperatorTableI`

    - #### getGT

          public Operator getGT()

      Specified by:
        `getGT` in interface `OperatorTableI`

    - #### getLE

          public Operator getLE()

      Specified by:
        `getLE` in interface `OperatorTableI`

    - #### getLT

          public Operator getLT()

      Specified by:
        `getLT` in interface `OperatorTableI`

    - #### getList

          public Operator getList()

      Specified by:
        `getList` in interface `OperatorTableI`

    - #### getMod

          public Operator getMod()

      Specified by:
        `getMod` in interface `OperatorTableI`

    - #### getMultiply

          public Operator getMultiply()

      Specified by:
        `getMultiply` in interface `OperatorTableI`

    - #### getNE

          public Operator getNE()

      Specified by:
        `getNE` in interface `OperatorTableI`

    - #### getNop

          public Operator getNop()

      Specified by:
        `getNop` in interface `OperatorTableI`

    - #### getNot

          public Operator getNot()

      Specified by:
        `getNot` in interface `OperatorTableI`

    - #### getOr

          public Operator getOr()

      Specified by:
        `getOr` in interface `OperatorTableI`

    - #### getPower

          public Operator getPower()

      Specified by:
        `getPower` in interface `OperatorTableI`

    - #### getRange

          public Operator getRange()

      Specified by:
        `getRange` in interface `OperatorTableI`

    - #### getSubtract

          public Operator getSubtract()

      Specified by:
        `getSubtract` in interface `OperatorTableI`

    - #### getUDivide

          public Operator getUDivide()

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

    - #### getUMinus

          public Operator getUMinus()

      Specified by:
        `getUMinus` in interface `OperatorTableI`

    - #### getUPlus

          public Operator getUPlus()

      Specified by:
        `getUPlus` in interface `OperatorTableI`

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

    - #### getNumOps

          public int getNumOps()

    - #### addOperator

          public Operator addOperator(EmptyOperatorTable.OperatorKey key,
                                      Operator op)

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

    - #### addOperator

          public Operator addOperator(EmptyOperatorTable.OperatorKey key,
                                      Operator op,
                                      Operator existingOp)

      Add operator with the same precedence level as an existing operator.
      Returns:
        the operator

    - #### insertOperator

          public Operator insertOperator(EmptyOperatorTable.OperatorKey key,
                                         Operator op,
                                         Operator existingOp)

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

    - #### appendOperator

          public Operator appendOperator(EmptyOperatorTable.OperatorKey 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

    - #### getKey

          public EmptyOperatorTable.OperatorKey getKey(Operator op)

      Gets the key associated with a specific operator
      Parameters:
        `op` -
      Returns:
        the key, null if op is not in the table

    - #### removeOperator

          public void removeOperator(Operator op)

      Remove a give operator from the table
      Parameters:
        `op` -

    - #### removeOperator

          public void removeOperator(EmptyOperatorTable.OperatorKey key)

      Remove a give operator from the table
      Parameters:
        `key` -

    - #### replaceOperator

          public void replaceOperator(Operator oldOp,
                                      Operator op)

      Replace a give operator with a new one. The new operator will have the same precedence as the old one
      Parameters:
        `oldOp` - the operator to be replaced
        `op` - the new operator

    - #### replaceOperator

          public void replaceOperator(EmptyOperatorTable.OperatorKey key,
                                      Operator op)

      Replace a give operator with a new one. The new operator will have the same precedence as the old one
      Parameters:
        `key` - the key for the operator
        `op` - the new operator

    - #### getOperator

          public Operator getOperator(EmptyOperatorTable.OperatorKey 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()

      Return the full list of operators
      Specified by:
        `getOperators` in interface `OperatorTableI`

    - #### entrySet

          public java.util.Set<java.util.Map.Entry<EmptyOperatorTable.OperatorKey,Operator>> entrySet()

    - #### keySet

          public java.util.Set<EmptyOperatorTable.OperatorKey> keySet()

    - #### setPrecedenceTable

          public final boolean setPrecedenceTable(EmptyOperatorTable.OperatorKey[][] 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 OperatorKey[][] { { POWER }, { NEG, UPLUS, NOT }, { MUL, DIV, MOD, DOT, CROSS },
                          { ADD, SU }, { LT, LE, GT, GE }, { EQ, NE }, { AND }, { OR }, { ASSIGN }, });

      Parameters:
        `precArray` -
      Returns:
        flag

    - #### setInverseOp

          protected boolean setInverseOp(EmptyOperatorTable.OperatorKey key1,
                                         EmptyOperatorTable.OperatorKey key2)

    - #### setBinaryInverseOp

          protected boolean setBinaryInverseOp(EmptyOperatorTable.OperatorKey key1,
                                               EmptyOperatorTable.OperatorKey key2)

    - #### setRootOp

          protected boolean setRootOp(EmptyOperatorTable.OperatorKey key1,
                                      EmptyOperatorTable.OperatorKey key2)

    - #### setDistributiveOver

          protected boolean setDistributiveOver(EmptyOperatorTable.OperatorKey key1,
                                                EmptyOperatorTable.OperatorKey key2)

    - #### setGroupOperatorRelations

          protected void setGroupOperatorRelations(Operator root,
                                                   Operator inv,
                                                   Operator composite)

      Sets relations of three operators. A mathematical group has three related operators the root operator `x+y`, the inverse `uminus z`, and composite `x-y = x+(uminus y)`
      Parameters:
        `root` - the root operator i.e. ADD
        `inv` - the inverse operator i.e. UMINUS
        `composite` - the composite operator i.e. SUBTRACT

    - #### setGroupOperatorRelations

          protected void setGroupOperatorRelations(EmptyOperatorTable.OperatorKey root,
                                                   EmptyOperatorTable.OperatorKey inv,
                                                   EmptyOperatorTable.OperatorKey composite)

      Sets relations of three operators. A mathematical group has three related operators the root operator `x+y`, the inverse `uminus z`, and composite `x-y = x+(uminus y)`
      Parameters:
        `root` - the root operator i.e. ADD
        `inv` - the inverse operator i.e. UMINUS
        `composite` - the composite operator i.e. SUBTRACT

    - #### setStandardOperatorRelations

          protected void setStandardOperatorRelations()

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

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