Dolo modeling language
Julia Python Jupyter Notebook
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
conda
docs
dolang
examples
experiments
src
test
tests
.gitignore
.travis.yml
README.md
REQUIRE
setup.py

README.md

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)