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

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

gets translated to Julia/Python object:




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

f = compile_function(eqs, symbols, api)

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