Main functions

Symbolic operations

parse(s: string) -> expression
str(e: expression) -> string     # dump(e) in python ?

We recognize several types of symbols in expressions. Each of them is mapped to a unique string:

Symbol types	Example	Simple structure	Normalized string	Latex
parameter	p	:p	_p_	p
variable	v, v(-1), v(1)	(:v,0), (:v,-1), (:v,1)	_v___, _v__m1_, _v__p1	v_{t}, v_{t-1}, v_{t+1}

Normalized symbols are created and converted back with:

normalize_symbol(e: expression) -> string
denormalize_symbol(s: string) -> expression

For full expressions:

normalize(e: expression) -> string
denormalize(s: string) -> expression

There are special functions to operate on expressions:

# shift timing in equations
# timeshift(:(a+b(1)+c),[:b,:c],1) == :(a+b(2)+c(1))
#
timeshift(expr: Expression, vars: List[variable], n) -> expr: Expression

# list variables
# list_variables(:(a+b(1)+c), [:b,:c,:d]) == [(:b,1),(:c,0)]
#
list_variables(expr: Expression, vars: List[variables]) -> List[Variables]

# list symbols
# list_symbols(:(a+b(1)+c), {:parameters=>[:a],:variables=>[:b,:c]}) == [:a,(:b,1),(:c,0)]
#
list_symbols(expr: Expression, types: SomeDict) -> List[Symbols]

# substitute expression
# subs(:(a + b), :b, :(c+d(1)) == :(a+c+d(1))
#
subs(expr: Expression, symbol: Symbol, sexpr: Expression) -> Expression

# substitute expressions
# subs(:(a + b), {:b => :(c+d(1)}) == :(a+c+d(1))
#
subs(expr: Expression, sexpr: Dict) -> Expression


# cleverly substitute expression
# csubs(:(a + b + b(1)), :b, :(c+d(1)) == :(a+c+d(1)+c(1)+d(2))
#
csubs(expr: Expression, symbol: Symbol, sexpr: Expression) -> Expression

# cleverly substitute expression
# csubs(:(a + b + b(1)), {:b => :(c+d(1)}) == :(a+c+d(1)+c(1)+d(2))
#
csubs(expr: Expression, sexpr: Dict) -> Expression


# trisolve: solve triangular system
# trisove({:a=>:(k+b), :b=>:(c+d)}) == {:a=>:(k+c+d), :b=>:(c+d)}
#
trisolve(system: Dict) -> solution: OrderedDict

# ctrisolve: cleverly solve triangular system
# trisove({:a=>:(k+b(1)), :b=>:(c+d)}) == {:a=>:(k+c(1)+d(1)), :b=>:(c+d)}
ctrisolve(system: Dict) -> solution: OrderedDict