Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## 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 JepComponent, OperatorTableI

See Also:
  Serialized Form

Field Summary
`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
`OperatorTable()`

Method Summary
`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

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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