Expression compiles a simple numerical expression into efficient byte-code for repeated evaluation. More...

#include <FXExpression.h>

Public Types
enum	Error { ErrOK, ErrEmpty, ErrMore, ErrMemory, ErrParent, ErrToken, ErrComma, ErrIdent, ErrColon, ErrLong }
	Expression error codes. More...

Public Member Functions
	FXExpression ()
	Construct empty expression object.

	FXExpression (const FXExpression &orig)
	Copy expression object.

	FXExpression (const FXchar expression, const FXchar variables=nullptr, Error *error=nullptr)
	Compile expression; if error is not NULL, error code is returned.

	FXExpression (const FXString &expression, const FXString &variables=FXString::null, Error *error=nullptr)
	Compile expression; if error is not NULL, error code is returned.

FXExpression &	operator= (const FXExpression &orig)
	Assign another expression to this one.

FXbool	empty () const
	See if expression is empty.

FXdouble	evaluate (const FXdouble *args=nullptr) const
	Evaluate expression with given arguments, if any. More...

Error	parse (const FXchar expression, const FXchar variables=nullptr)
	Parse expression, return error code if syntax error is found. More...

Error	parse (const FXString &expression, const FXString &variables=FXString::null)

void	clear ()
	Clear the expression.

	~FXExpression ()
	Delete.

Static Public Member Functions
static const FXchar *	getError (Error err)
	Returns error code for given error.

Friends
FXAPI FXStream &	operator<< (FXStream &store, const FXExpression &s)
	Saving and loading.

FXAPI FXStream &	operator>> (FXStream &store, FXExpression &s)

Detailed Description

Expression compiles a simple numerical expression into efficient byte-code for repeated evaluation.

When an expression is compiled, an optional comma-separated list of variable names may be passed; during evaluation, values may be provided for these variable by passing an array of values. For instance, when compiling an expression:

  b**2-4*a*c

with the list of variables:

  a,b,c

then a subsequent evaluation can pass an array of three numbers:

  [1 4 2]

which will then evaluate the expression:

  4**2-4*1*2

which should yield:

The expression syntax can be build from the following operators, in order of increasing precedence:

  ? :                     alternate expression
  <, <=, >, >=, ==, !=    comparisons
  <<, >>                  bit-shifts
  &, |, ^                 bit-wise operations
  +, -                    addition and subtraction
  *, /, %                 multiply, divide, modulo
  **                      power
  -, ~                    unary minus, bitwise not
  ( )                     parenthesized subexpressions

The following functions are available:

  abs, acos, acosh, asin, asinh, atan, atanh,
  cbrt, ceil, cos, cosh, cub, erf, erfc, exp, exp2,
  exp10, floor, inverf, inverfc, isfin, isinf, isnan,
  log, log2, log10, near, round, sin, sinh, sqr, sqrt,
  tan, tanh, trunc, wrap, wrap4, max, min, atan2

The expression engine also contains the following constants:

  PI, E, DTOR, RTOD

Variables should not use any of these reserved names.

Initially, FXExpression will be set to a dummy program which will return 0 when evaluated.

Member Enumeration Documentation

◆ Error

enum FX::FXExpression::Error

Expression error codes.

Enumerator
ErrEmpty	No errors.
ErrMore	Empty input.
ErrMemory	More characters after input.
ErrParent	Out of memory.
ErrToken	Unmatched parentheses.
ErrComma	Illegal token.
ErrIdent	Expected comma.
ErrColon	Unknown identifier.
ErrLong	Expected colon. Expression too long

Member Function Documentation

◆ evaluate()

FXdouble FX::FXExpression::evaluate ( const FXdouble * args = nullptr ) const

Evaluate expression with given arguments, if any.

The array of arguments should match the number of variables passed when compiling the expression.

◆ parse()

Error FX::FXExpression::parse	(	const FXchar *	expression,
		const FXchar *	variables = `nullptr`
	)

Parse expression, return error code if syntax error is found.

If a comma-separated list of variables is passed, then an array of equal number of doubles must be passed when calling evaluate. The values of the array will be read in place of the variable names in the expression.

The documentation for this class was generated from the following file:

/home/jeroen/FOX/fox/fox-1.7.86/include/FXExpression.h

Public Types

Public Member Functions