expr

README

expr - tiny yet super fast math expression evaluator in Go

Example

vars := map[string]expr.Var{
	"x": NewVar(5),
}
funcs := map[string]expr.Func{
	"next": NewFunc(func(args expr.FuncArgs, env expr.FuncEnv) expr.Num {
		return expr.Num(args[0].Eval()+1)
	}),
}
vars["x"].Set(5)
e, err := expr.Parse("y=x+5/next(x)", vars, funcs)
if err != nil {
	log.Fatal(err)
}
result := e.Eval()
log.Println(result)
log.Println(vars["y"])

Performance

The goal is to speed up frequent evaluations of immutable expressions. For example, user enters a formula to calculate some metrics and backend does the calculation. Formula itself changes rarely, but is evaluated very often.

On my dual-core laptop the benchmark shows that:

• Parsing expression x=2+3*(x/(42+plusone(x))),x takes 14us, evaluation takes 65ns.
• Parsing a more complex expression of 280 chars takes 112us, evaluation takes 649ns.
• Parsing an even more complex expresison of ~3k chars takes 1ms, evaluation takes 7us.

This probably means that time grows linearly depending on the formula length and the performance is really good for short (human-generated) formulas.

Documentation

Index

• Variables
• type Expr
  • func Parse(input string, vars map[string]Var, funcs map[string]Func) (Expr, error)
• type Func
• type FuncContext
  • func (f *FuncContext) Eval() Num
  • func (f *FuncContext) String() string
• type Num
• type Var
  • func NewVar(value Num) Var

Variables

var (
	ErrParen                = errors.New("parenthesis mismatch")
	ErrUnexpectedNumber     = errors.New("unexpected number")
	ErrUnexpectedIdentifier = errors.New("unexpected identifier")

	ErrBadCall        = errors.New("function call expected")
	ErrBadVar         = errors.New("variable expected in assignment")
	ErrBadOp          = errors.New("unknown operator or function")
	ErrOperandMissing = errors.New("missing operand")
)

Types

type Expr

type Expr interface {
	Eval() Num
}

func Parse

func Parse(input string, vars map[string]Var, funcs map[string]Func) (Expr, error)

type Func

type Func func(f *FuncContext) Num

type FuncContext

type FuncContext struct {
	Args []Expr
	Vars map[string]Var
	Env  interface{}
	// contains filtered or unexported fields
}

func (*FuncContext) Eval

func (f *FuncContext) Eval() Num

func (*FuncContext) String

func (f *FuncContext) String() string

type Num

type Num float64

type Var

type Var interface {
	Expr
	Set(value Num)
	Get() Num
}

Mutable variable expression returns the currently stored value of the variable

func NewVar

func NewVar(value Num) Var