What is dolang ?

It is the current codename for a complete rewrite of the dolo language. It aims at:

• being a first stone for the rewrite of dolo in julia
• improving model validity checks and providing not so cryptic error messages (for dolo 0.5)
• allow for easy language extensions
• being reusable in conjunction with other libraries (like pandas, or bttt)

What does it consist in ?

• a standardized way of describing equations with different types of variables as well as methods to operate on these equations
• compilation routines to turn these equations into vectorized/optimized functions
• rules to define arbitrary objects with a yaml file and a collection of useful objects (distributions, markov chains, approximation spaces, priors, ...)

Equation description (codename dolex)

• unicode fomulas: use crazy hebrew letters !

• latex output (and input ?)

• time subscripts (default to be determined):

  • implicit time: a(1), a(-1) for a_{t} and a_{t-1}
  • explicit time: a(t+1), a(t-1) for a_{t} and a_{t-1}
  • continuous time: a(t), a(t+dt) for a_{t} and a_{t+dt}

• other subscripts:

  • subscripted variables a[i,j](t) for `a_{i,j,t}``
  • superscripts a[~i,j](t) for `a^i_{j,t}``

• expressions defined on an event tree (see bttt)

  • v[s-1] + v[s] + E[ s[1] | s[1], S(s) ]

• common constructs:

  • expectations: E[...] or E_t[ ... ]
  • differential operators: ??

• basic symbolic operations on expressions:

  • count/check incidence of symbols
  • substitutions
  • differentiation

How does it work (for now)?

- expressions are parsed by python/julia parser
- pattern matching is used to substitute symbols by a unique string identifier:

    - a[x,y] -> a__x__y
    - a(t,t+dt,t-dt) -> a__t__tpdt__tmdt
    - a(1, -1) -> a____p1__m1

- symbolic operations can then be done by manipulating the expression trees directly or by using a symbolic engine

Objects in Yaml (codename dolaml)

For instance

FunctionalSpace:
    domain:
        SmolyakGrid:
            a: [0,0]
            b: [1,1]
            m: 4
    interp_type: polynomial

gets translated to Julia/Python object:

FunctionalSpace(
     domain=SmolyakGrid(
          a=[0,0],
          b=[1,1],
          l=4
     ),
     interp_type='polynomial'
)

Compilation

Example:

eqs = [
    'a*x + y(1)',
    'x(1) - b*y',
]
from collections import OrderedDict
symbols = OrderedDict(
    states=['x', 'y'],
    parameters=['a', 'b']
)
api = [
    ('states',0,'s'),        # represents all variables v(0) where v is a state
    ('states',1,'s'),        # represents all variables v(1) where v is a state
    ('parameters',0,'p')
]

f = compile_function(eqs, symbols, api)

# returns a function f(s_0, s_1, p)