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, java.io.Serializable

Direct Known Subclasses:
  BigDecOperatorTable, StandardOperatorTable

    public class OperatorTable

extends java.lang.Object
implements JepComponent

See Also:
  Serialized Form

Field Summary
`protected static int` | `baseNumOps` Number operators in this table.
`protected int` | `numOps`
`static int` | `OP_ADD`
`static int` | `OP_AND`
`static int` | `OP_ASSIGN`
`static int` | `OP_CROSS`
`static int` | `OP_DIVIDE`
`static int` | `OP_DOT`
`static int` | `OP_ELEMENT`
`static int` | `OP_EQ`
`static int` | `OP_GE`
`static int` | `OP_GT`
`static int` | `OP_LE`
`static int` | `OP_LIST`
`static int` | `OP_LT`
`static int` | `OP_MOD`
`static int` | `OP_MULTIPLY`
`static int` | `OP_NE`
`static int` | `OP_NEGATE`
`static int` | `OP_NOP`
`static int` | `OP_NOT`
`static int` | `OP_OR`
`static int` | `OP_POWER`
`static int` | `OP_RANGE`
`static int` | `OP_RECIP` unary division i.e. 1/x or x^(-1) *
`static int` | `OP_SUBTRACT`
`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)`
`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

    public static final int OP_NOP

See Also:
  Constant Field Values

### OP_ADD

    public static final int OP_ADD

See Also:
  Constant Field Values

### OP_SUBTRACT

    public static final int OP_SUBTRACT

See Also:
  Constant Field Values

### OP_NEGATE

    public static final int OP_NEGATE

See Also:
  Constant Field Values

### OP_UPLUS

    public static final int OP_UPLUS

See Also:
  Constant Field Values

### OP_MULTIPLY

    public static final int OP_MULTIPLY

See Also:
  Constant Field Values

### OP_DIVIDE

    public static final int OP_DIVIDE

See Also:
  Constant Field Values

### OP_MOD

    public static final int OP_MOD

See Also:
  Constant Field Values

### OP_RECIP

    public static final int OP_RECIP

  unary division i.e. 1/x or x^(-1) *

  See Also:
    Constant Field Values

### OP_POWER

    public static final int OP_POWER

See Also:
  Constant Field Values

### OP_GT

    public static final int OP_GT

See Also:
  Constant Field Values

### OP_LT

    public static final int OP_LT

See Also:
  Constant Field Values

### OP_EQ

    public static final int OP_EQ

See Also:
  Constant Field Values

### OP_LE

    public static final int OP_LE

See Also:
  Constant Field Values

### OP_GE

    public static final int OP_GE

See Also:
  Constant Field Values

### OP_NE

    public static final int OP_NE

See Also:
  Constant Field Values

### OP_AND

    public static final int OP_AND

See Also:
  Constant Field Values

### OP_OR

    public static final int OP_OR

See Also:
  Constant Field Values

### OP_NOT

    public static final int OP_NOT

See Also:
  Constant Field Values

### OP_ASSIGN

    public static final int OP_ASSIGN

See Also:
  Constant Field Values

### OP_DOT

    public static final int OP_DOT

See Also:
  Constant Field Values

### OP_CROSS

    public static final int OP_CROSS

See Also:
  Constant Field Values

### OP_LIST

    public static final int OP_LIST

See Also:
  Constant Field Values

### OP_ELEMENT

    public static final int OP_ELEMENT

See Also:
  Constant Field Values

### OP_RANGE

    public 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

    public 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 precendence 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

  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

  Parameters:
    `name` - unique name of operator
  Returns:
    the operator or null if not found

### getOperators

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

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

### getAdd

    public Operator getAdd()

### getSubtract

    public Operator getSubtract()

### getUMinus

    public Operator getUMinus()

### getUPlus

    public Operator getUPlus()

### getMultiply

    public Operator getMultiply()

### getDivide

    public Operator getDivide()

### getMod

    public Operator getMod()

### getUDivide

    public Operator getUDivide()

  unary division i.e. 1/x or x^(-1) *

### getPower

    public Operator getPower()

### getGT

    public Operator getGT()

### getLT

    public Operator getLT()

### getEQ

    public Operator getEQ()

### getLE

    public Operator getLE()

### getGE

    public Operator getGE()

### getNE

    public Operator getNE()

### getAnd

    public Operator getAnd()

### getOr

    public Operator getOr()

### getNot

    public Operator getNot()

### getAssign

    public Operator getAssign()

### getDot

    public Operator getDot()

### getCross

    public Operator getCross()

### getList

    public Operator getList()

### getEle

    public Operator getEle()

### getRange

    public Operator getRange()

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