Quant DSL

Domain specific language for quantitative analytics in finance and trading.

Example of an American option expressed in Quant DSL.

AmericanOption(Date('2011-1-1'), Date('2012-1-1'), Market('Copper'), 7000, TimeDelta('1d'))

def AmericanOption(start, expiry, underlying, strike, step):
    if start <= expiry:
        Option(start, underlying, strike, AmericanOption(
            start + step, expiry, underlying, strike, step
        ))
    else:
        0

def Option(expiry, underlying, strike, alternative):
    Wait(expiry, Choice(underlying - strike, alternative))

Install

Use pip to install the latest distribution from the Python Package Index. You may feedback issues on GitHub.

pip install quantdsl

Please note, this library depends on SciPy, which can fail to install with some older versions of pip. In case of difficulty, please try again after upgrading pip.

pip install --upgrade pip

After successfully installing this library, the test suite should pass.

python -m unittest discover quantdsl

Overview

Quant DSL is domain specific language for quantitative analytics in finance and trading.

At the heart of Quant DSL is a set of elements (e.g. "Settlement", "Fixing", "Market", "Choice"). The elements involve mathematical expressions commonly used within quantitative analytics, such as: present value discounting; geometric Brownian motion; and least squares Monte Carlo.

The elements of the language can be freely composed into expressions of value. The validity of Monte Carlo simulation for all possible expressions in the language is proven by induction.

Syntax

The syntax of Quant DSL expressions is defined with Backus–Naur Form.

<Expression> ::= <Constant>
    | "Settlement(" <Date> "," <Expression> ")"
    | "Fixing(" <Date> "," <Expression> ")"
    | "Market(" <MarketName> ")"
    | "Wait(" <Date> "," <Expression> ")"
    | "Choice(" <Expression> "," <Expression> ")"
    | "Max(" <Expression> "," <Expression> ")"
    | <Expression> "+" <Expression>
    | <Expression> "-" <Expression>
    | <Expression> "*" <Expression>
    | <Expression> "/" <Expression>
    | "-" <Expression>

<Constant> ::= <Float> | <Integer>

<Date> ::= "'"<Year>"-"<Month>"-"<Day>"'"

<MarketName> ::= "'"<MarketName><NameChar> | <NameChar>"'"

<Year> ::= <Digit><Digit><Digit><Digit>

<Month> ::= <Digit><Digit>

<Day> ::= <Digit><Digit>

<Float> ::= <Integer>"."<Integer>

<Integer> ::= <Integer><Digit> | <Digit>

<NameChar> ::= "A" | "B" | "C" | "D" | "E" | "F" |
               "G" | "H" | "I" | "J" | "K" | "L" |
               "M" | "N" | "O" | "P" | "Q" | "R" |
               "S" | "T" | "U" | "V" | "W" | "X" |
               "Y" | "Z" | "_" | <Digit>

<Digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"

Semantics

In the definitions below, Quant DSL expression v defines a function [[v]](t) from present time t to a random variable in a probability space.

Constant interest rate r is used in discounting settlements.

For market i, the last price Si and volatility σi are determined using only market price data generated before t0. Brownian motion z is used in diffusion. In the software, this Market semantic is a user option, so that other market models can be used to simulate prices, for example models with multiple factors, mean reversion, and jump diffusion.

Choices are made using conditioning, expectation E is conditioned on filtration F at t, so that choices are made only with information at the time of the choice. In practice, information is "lost" from included expressions by fitting the value of the expression (a random variable in a probability space) to the underlying simulated prices at that time using least squares. This leads to a quantitative difference from maximisation ("Max").

[[Settlement(d, x)]](t) = e ** (r * (t−d)) * [[x]](t)

[[Fixing(d, x)]](t) = [[x]](d)

[[Market(i)]](t) = Si * e ** (σi * z(t − t0)) − 0.5 * σi ** 2 * (t − t0)

[[Wait(d, x)]](t) = [[Settlement(d, Fixing(d, x))]](t)

[[Choice(x, y)]](t) = max(E[[[x]](t) | F(t)], E[[[y]](t) | F(t)])

[[Max(x, y)]](t) = max([[x]](t), [[y]](t))

[[x + y]](t) = [[x]](t) + [[y]](t)

[[x - y]](t) = [[x]](t) - [[y]](t)

[[x * y]](t) = [[x]](t) * [[y]](t)

[[x / y]](t) = [[x]](t) / [[y]](t)

[[-x]](t) = -[[x]](t)

Todo: Format the above as proper math symbols.

Please note, these default semantics can be substituted using the dsl_classes arg of calc() below.

Software

The scope of the work of a quantitative analyst involves modelling optionality, simulating future prices, and evaluating the model against the simulation. In implementing the syntax and semantics of Quant DSL, this software provides an application object class QuantDslApplication which has methods that support this work: compile(), simulate(), and evaluate().

During compilation of Quant DSL source code, the application QuantDslApplication constructs a graph of Quant DSL expressions. The simulation is generated by a calibrated price process, according to requirements derived from the compiled dependency graph. During evaluation, the nodes of the dependency graph are evaluated when they are ready to be evaluated. Intermediate results are discarded as soon as they are no longer required, such that memory usage is mostly constant during evaluation. For the "greeks", nodes are selectively re-evaluated with perturbed values, according to the periods and markets they involve, avoiding unnecessary computation.

In addition to the Quant DSL expressions above, function def statements are supported. User defined functions can be used to refactor complex Quant DSL expressions, in order to model complex optionality concisely. The import statement is also supported, so Quant DSL function definitions and expressions can be developed and maintained as Python files. Since Quant DSL syntax is a strict subset of Python, the full power of Python IDEs can be used to write, navigate and refactor Quant DSL source code.

Examples

calc()

The examples below use the library function calc() to evaluate Quant DSL source code. calc() uses the methods of the QuantDslApplication mentioned above.

from quantdsl.calculate import calc

When called, the function calc() returns a results object, with an attribute fair_value that is the simulated value, under the semantics, of the given Quant DSL expression.

results = calc(source_code="2 + 3")
assert results.fair_value == 5

The function calc() has many optional arguments that can be used to control the evaluation of an expression.

source_code

The Quant DSL module that will be evaluated. It must contain one expression, and may contain many function definitions. It may also contain import statements that import functions from Quant DSL modules saved as normal Python files.

observation_date

Sets the time t0 in the semantics from when the forward curve is evolved by the price process. Also conditions the effective present time t of the outermost element in an evaluation.

interest_rate

The continuously compounding short run risk free rate, used for discounting (default 0).

price_process

The name and configuration parameters for the price process that will estimate (by simulation) prices that could be agreed in the future.

periodisation

Delta granularity can be set with the periodisation arg of calc() e.g. 'daily' or 'monthly'.

Todo: Rename the arg to delta_granularity.

is_double_sided_deltas

Evaluate with either single- or double-sided deltas (default True).

path_count

Determines the accuracy of the simulated random variables (default 20000).

perturbation_factor

Used to calculate "greeks". If the path_count is larger, a smaller perturbation factor may give better result (default 0.01).

max_dependency_graph_size

Sets the limit on the maximum number of nodes the can be compiled from Quant DSL source with the max_dependency_graph_size arg of calc().

timeout

You can set a calculation to timeout after a given number of seconds.

dsl_classes

Custom DSL classes can be passed in using the dsl_classes argument of calc().

is_verbose

Setting is_verbose will cause progress of a calculation to be printed to standard output.

Settlement

The Settlement element discounts the value of the included Expression from its given Date to the effective present time t when the element is evaluated.

<Settlement> ::= "Settlement(" <Date> ", " <Expression> ")"

[[Settlement(d, x)]](t) = e ** (r * (t−d)) * [[x]](t)

For example, with a continuously compounding interest_rate of 2.5 percent per year, the value 10 settled on '2111-1-1' has a present value of 82.08 on '2011-1-1'.

results = calc("Settlement('2111-1-1', 1000)",
    observation_date='2011-1-1',
    interest_rate=2.5,
)

assert round(results.fair_value, 2) == 82.08

Similarly, the value of 82.085 settled in '2011-1-1' has a present value of 1000.00 on '2111-1-1' .

results = calc("Settlement('2011-1-1', 82.085)",
    observation_date='2111-1-1',
    interest_rate=2.5,
)

assert round(results.fair_value, 2) == 1000.00

Discounting is a function of the interest_rate and the duration in time between the date of the Settlement element and the effective present time t of its evaluation. The formula used for discounting by the Settlement element is e**-rt. The interest_rate is the therefore the continuously compounding risk free rate (not the annual equivalent rate).

Fixing

The Fixing element simply conditions the effective present time of its included Expression with its given Date.

<Fixing> ::= "Fixing(" <Date> "," <Expression> ")"

[[Fixing(d, x)]](t) = [[x]](d)

For example, if a Fixing element includes a Settlement element, then the effective present time of the included Settlement element will be the given date of the Fixing.

The expression below represents the present value in '2051-1-1' of the value of 1000 to be settled on '2111-1-1'.

results = calc("Fixing('2051-1-1', Settlement('2111-1-1', 1000))",
    interest_rate=2.5,
)

assert round(results.fair_value, 2) == 223.13

Market

The Market element effectively estimates prices that could be agreed in the future.

<Market> ::= "Market(" <MarketName> ")"

[[Market(i)]](t) = Si * e ** (σi * z(t − t0)) − 0.5 * σi ** 2 * (t − t0)

When a Market element is evaluated, it returns a random variable selected from a simulation of market prices.

Selecting an estimated price from the simulation requires the name of the market, a fixing date (when the price would be agreed), and a delivery date (when the goods would be delivered).

The name of the Market is included in the element (e.g. 'GAS' or 'POWER'). Both the fixing date and the delivery date are determined by the effective present time when the element is evaluated.

Simulation

The price simulation is generated by a price process. In this example, the library's one-factor multi-market Black Scholes price process BlackScholesPriceProcess is used to generate correlated geometric Brownian motions.

The calibration parameters required by BlackScholesPriceProcess are market (a list of market names), and sigma, (a list of annualised historical volatilities, expressed as a fraction of 1, rather than as a percentage).

price_process = {
    'name': 'quantdsl.priceprocess.blackscholes.BlackScholesPriceProcess',
    'market': ['GAS', 'POWER'],
    'sigma': [0.02, 0.02],
    'rho': [
        [1.0, 0.8],
        [0.8, 1.0]
    ],
    'curve': {
        'GAS': [
            ('2011-1-1', 10),
            ('2111-1-1', 1000)
        ],
        'POWER': [
            ('2011-1-1', 11),
            ('2111-1-1', 1100)
        ]
    },
}

When a simulation generated by this price process involves two or more markets, an additional parameter rho is required, which represents the correlation between the markets (a symmetric matrix expressed as a list of lists).

Forward curve

A forward curve is required by the price process to provide estimates of current prices for each market at the given observation_date. The prices in the forward curve are prices that can be agreed at the observation_date for delivery at the specified dates. These prices are then diffused according to the risk-neutral dynamics of the price process.

Requirements for the simulation (dates and markets) are derived from the expression to be evaluated. If the expression involves observing at a future date the price for particular goods to be delivered at a particular date, then the simulation will provide a random variable which simulates that observation.

A Market element evaluated at the observation_date will simply return the last value from the given forward curve for that market at the given observation_date.

results = calc("Market('GAS')",
    observation_date='2011-1-1',
    price_process=price_process,
)

Since the Market element uses random variables from the price simulation, so the results are random variables, and we need to take the mean() to obtain a scalar value.

assert results.fair_value.mean() == 10

If the forward curve doesn't contain a price at the required delivery date, a price at an earlier delivery date is used (with zero order hold).

results = calc("Market('GAS')",
    observation_date='2012-3-4',
    price_process=price_process,
)

assert results.fair_value.mean() == 10

Evaluating at a later observation date will return the later value from the forward curve.

results = calc("Market('GAS')",
    observation_date='2111-1-1',
    price_process=price_process,
)
assert results.fair_value.mean() == 1000

Stochastic evolution

In the examples so far, there has been no difference between the fixing date of the Market element and the observation_date of the evaluation. Therefore, there is no stochastic evolution of the forward curve, and the standard deviation of the result value is zero.

assert results.fair_value.std() == 0.0

If a Market element is included within a Fixing element, the effective present time will be different from the observation date, so the fixing date used to select a price from the simulation will be different from the observation date. The simulated price will be taken from the forward curve, but will also be subjected to stochastic evolution.

With Brownian motion provided by the BlackScholesPriceProcess, the random variable used to estimate a price observed in the future has a statistical distribution with non-zero standard deviation.

results = calc("Fixing('2051-1-1', Market('GAS'))",
    observation_date='2011-1-1',
    price_process=price_process,
)
assert results.fair_value.std() > 0.0

Accuracy

The number of samples from the distribution in the simulated random variable defaults to 20000.

assert len(results.fair_value) == 20000

The number can be adjusted by setting path_count. The accuracy of results can be doubled by increasing the path count by a factor of four.

results = calc("Market('GAS')",
    observation_date='2011-1-1',
    price_process=price_process,
    path_count=80000,
)
assert len(results.fair_value) == 80000

Different fixing and delivery dates

The ForwardMarket element can be used to specify a delivery date that is different from the fixing date (when the price for that delivery would be agreed). This can be used to model trading in forward markets, and also to express the value of an index at maturity (see below).

Wait

The Wait element combines Settlement and Fixing, so that its Date is used both to condition the effective present time of the included Expression, and also the value of that expression is discounted to the effective present time when evaluating the Wait element.

<Wait> ::= "Wait(" <Date> "," <Expression> ")"

[[Wait(d, x)]](t) = [[Settlement(d, Fixing(d, x))]](t)

For example, the present value at the observation_date of '2011-1-1' of one unit of 'GAS' delivered on '2111-1-1' is approximately 82.18. The Wait element sets the delivery date of the Market element, which is used to pick the value 1000 from the forward curve. The Wait element also sets the fixing date of the Market element, which is used to control the stochastic evolution of the forward value. The evolved value is then discounted by the Wait element from 2111 to the observation date 2011.

import scipy
# Setting random seed makes test results repeatable.
scipy.random.seed(1234)

results = calc("Wait('2111-1-1', Market('GAS'))",
    price_process=price_process,
    observation_date='2011-1-1',
    interest_rate=2.5,
)

assert round(results.fair_value.mean(), 2) == 82.18
assert round(results.fair_value.std(), 2) == 16.46

Choice

The Choice element uses the least-squares Monte Carlo approach (Longstaff Schwartz, 1998) to compare the conditional expected value of each alternative Expression.

<Choice> ::= "Choice(" <Expression> "," <Expression> ")"

[[Choice(x, y)]](t) = max(E[[[x]](t) | F(t)], E[[[y]](t) | F(t)])

For example, the value of the choice at observation_date of '2011-1-1' between one unit of 'GAS' either on '2051-1-1' or '2111-1-1' is 217.39.

source_code = """
Choice(
    Wait('2051-1-1', Market('GAS')),
    Wait('2111-1-1', Market('GAS'))
)
"""

results = calc(source_code,
    observation_date='2011-1-1',
    price_process=price_process,
    interest_rate=2.5,
)
assert round(results.fair_value.mean(), 2) == 82.06

When the Choice element is evaluated, the value of each alternative is regressed as a random variable by least squares with second order polynomial regression to the underlying simulated values at the effective present time of the choice. The choice of alternative on each path is then made using the regressed value (the "conditional expected value") but the chosen value on each path is taken from the unregressed value of the chosen alternative for that path (the "expected continuation value"). The result is a new simulated value that combines the expected continuation value of the alternatives, according to information in the simulation at the time of the choice. This conditioning gives a quantitatively different result from simple maximisation of the alternative expected continuation values (Max).

Function definitions

Quant DSL source code can include function definitions. Expressions can involve calls to functions.

When evaluating an expression that involves a call to a function definition, the call to the function definition is effectively replaced with the expression returned by the function definition, so that a larger expression is formed. Hence, the body of a function can have only one statement.

The call args of the function definition can be used as names in the function definition's expressions. The call arg values will be substituted for those names in the expression when the expression is returned by the function.

results = calc("""
def Function(a):
    2 * a

Function(10)
""")

assert results.fair_value == 20

Although the function body can have only one statement, that statement can be an if-else block. The call args of the function definition can be used in an if-else block, to select different expressions according to the value of the function call arguments, which effectively implements a "case branch".

Each function call becomes a node on a dependency graph. For efficiency, each call is cached, so if a function is called many times with the same argument values (and at the same effective present time), the function is only evaluated once, and the result reused. This allows branched calculations to recombine efficiently. For example, the following Fibonacci function definition will evaluate in linear time (proportional to n).

results = calc("""
def Fib(n):
    if n > 1:
        Fib(n-1) + Fib(n-2)
    else:
        n

Fib(60)
""")

assert results.fair_value == 1548008755920

Function definitions can be used to refactor complex expressions. For example, if the expression is the sum of a series of settlements on different dates, the expression without a function definition might be:

source_code = """
Settlement(Date('2011-1-1'), 10) + Settlement(Date('2011-2-1'), 10) + Settlement(Date('2011-3-1'), 10) + \
Settlement(Date('2011-4-1'), 10) + Settlement(Date('2011-5-1'), 10) + Settlement(Date('2011-6-1'), 10) + \
Settlement(Date('2011-8-1'), 10) + Settlement(Date('2011-8-1'), 10) + Settlement(Date('2011-9-1'), 10) + \
Settlement(Date('2011-10-1'), 10) + Settlement(Date('2011-11-1'), 10) + Settlement(Date('2011-12-1'), 10)
"""
results = calc(source_code,
    observation_date='2011-1-1',
    interest_rate=10,
)
assert round(results.fair_value, 2) == 114.59

Instead the expression could be refactored with a function definition.

source_code = """
def Settlements(start, end, installment):
    if start <= end:
        Settlement(start, installment) + Settlements(start + TimeDelta('1m'), end, installment)
    else:
        0
        
Settlements(Date('2011-1-1'), Date('2011-12-1'), 10)
"""
results = calc(source_code,
    observation_date='2011-1-1',
    interest_rate=10,
)
assert round(results.fair_value, 2) == 114.67

European and American options

In general, an option can be expressed as waiting until an expiry date to choose between, on one hand, the difference between the value of an underlying expression and a strike expression, and, on the other hand, an alternative expression.

def Option(expiry, strike, underlying, alternative):
    Wait(expiry, Choice(underlying - strike, alternative))

A European option can then be expressed simply as an Option with zero alternative.

def EuropeanOption(expiry, strike, underlying):
    Option(expiry, strike, underlying, 0)

An American option can be expressed as an Option to exercise at a given strike price on the start date, with the alternative being another AmericanOption starting on the next date - and so on until the expiry date, when the alternative becomes zero.

def AmericanOption(start, expiry, strike, underlying, step):
    if start <= expiry:
        Option(
            start, strike, underlying, AmericanOption(
                start + step, expiry, strike, underlying, step
            )
        )
    else:
        0

A European put option can be expressed as a EuropeanOption, with negated underlying and strike expressions.

def EuropeanPut(expiry, strike, underlying):
    EuropeanOption(expiry, -strike, -underlying)

A European stock option can be expressed as a EuropeanOption, with the underlying being the index at maturity. The IndexAtMaturity has the spot price at the observation date (using ForwardMarket) observed at a time in the future, discounted forward from the observation date (due to the Settlement) to a time in the future. This "time in the future" is the effective present time set by the Wait element of the Option definition above.

def EuropeanStockOption(expiry, strike, stock):
    EuropeanOption(expiry, strike, IndexAtMaturity(stock))

The expression IndexAtMaturity is passed into the Option definition and, due to the Wait element in that definition, is evaluated with expiry as the present time. Therefore the spot price is discounted forward to the expiry, and the fixing date of the ForwardMarket is expiry, so that the spot price is subjected to stochastic evolution as well as interest rates.

def IndexAtMaturity(stock):
    Settlement(ObservationDate(), ForwardMarket(ObservationDate(), stock))

The built-in ObservationDate element evaluates to the observation_date passed to the the calc() function.

Let's evaluate a European stock option at different strike prices, volatilities, and interest rates.

The following function calc_european will make it easier to evaluate the option several times.

def calc_european(spot, strike, sigma, rate):
    source_code = """
def Option(expiry, strike, underlying, alternative):
    Wait(expiry, Choice(underlying - strike, alternative))

def EuropeanOption(expiry, strike, underlying):
    Option(expiry, strike, underlying, 0)
   
def EuropeanStockOption(expiry, strike, stock):
    EuropeanOption(expiry, strike, IndexAtMaturity(stock))

def IndexAtMaturity(stock):
    Settlement(ObservationDate(), ForwardMarket(ObservationDate(), stock))
    
EuropeanStockOption(Date('2012-1-1'), {strike}, 'ACME')
    """.format(strike=strike)
    
    results = calc(
        source_code=source_code,
        observation_date='2011-1-1',
        price_process={
            'name': 'quantdsl.priceprocess.blackscholes.BlackScholesPriceProcess',
            'market': ['ACME'],
            'sigma': [sigma],
            'curve': {
                'ACME': [
                    ('2011-1-1', spot),
                ]
            },
        },
        interest_rate=rate,
    )
    return round(results.fair_value.mean(), 2)

If the strike price of a European option is the same as the price of the underlying, without any volatility (sigma is 0) the value is zero.

assert calc_european(spot=10, strike=10, sigma=0, rate=0) == 0.0

If the strike price is less than the underlying, without any volatility, the value is the difference between the strike and the underlying.

assert calc_european(spot=10, strike=8, sigma=0, rate=0) == 2.0

If the strike price is greater than the underlying, without any volatility, the value is zero.

assert calc_european(spot=10, strike=12, sigma=0, rate=0) == 0.0

If the strike price is the same as the underlying, with some volatility in the price of the underlying, there is some value in the option.

assert calc_european(spot=10, strike=10, sigma=0.9, rate=0) == 3.42

If the strike price is less than the underlying, with some volatility in the price of the underlying (sigma) there is more value in the option than without volatility.

assert calc_european(spot=10, strike=8, sigma=0.9, rate=0) == 4.23

If the strike price is greater than the underlying, with some volatility in the price of the underlying (sigma) there is still a little bit of value in the option.

assert calc_european(spot=10, strike=12, sigma=0.9, rate=0) == 2.90

These results compare well with results from the Black-Scholes analytic formula for European stock options.

Gas storage

An evaluation of a gas storage facility. The value of the gas storage facility follows from the difference between the price when gas is injected and the price when gas is withdrawn.

The Quant DSL source code below models a gas storage facility as a lattice of choices to inject or withdraw a quantity of gas. If the facility is full, injecting gas is not an option. Similarly, if the facility is empty, withdrawing gas is not an option.

gas_storage = """
def GasStorage(start, end, market, quantity, target, limit, step):
    if ((start < end) and (limit > 0)):
        if quantity <= 0:
            Wait(start, Choice(
                Continue(start, end, market, quantity, target, limit, step),
                Inject(start, end, market, quantity, target, limit, step, 1),
            ))
        elif quantity >= limit:
            Wait(start, Choice(
                Continue(start, end, market, quantity, target, limit, step),
                Inject(start, end, market, quantity, target, limit, step, -1),
            ))
        else:
            Wait(start, Choice(
                Continue(start, end, market, quantity, target, limit, step),
                Inject(start, end, market, quantity, target, limit, step, 1),
                Inject(start, end, market, quantity, target, limit, step, -1),
            ))
    else:
        if target < 0 or target == quantity:
            0
        else:
            BreachOfContract()


@inline
def Continue(start, end, market, quantity, target, limit, step):
    GasStorage(start + step, end, market, quantity, target, limit, step)


@inline
def Inject(start, end, market, quantity, target, limit, step, vol):
    Continue(start, end, market, quantity + vol, target, limit, step) - \
    vol * market


@inline
def BreachOfContract():
    -10000000000000000

@inline
def Empty():
    0

@inline
def Full():
    50000


GasStorage(Date('2011-4-1'), Date('2012-4-1'), Market('GAS'), Empty(), Empty(), Full(), TimeDelta('1m'))
"""

This example uses a forward curve that has seasonal variation (prices are high in winter and low in summer).

gas = {
    'name': 'quantdsl.priceprocess.blackscholes.BlackScholesPriceProcess',
    'market': ['GAS'],
    'sigma': [0.3],
    'curve': {
        'GAS': (
            ('2011-1-1', 13.5),
            ('2011-2-1', 11.0),
            ('2011-3-1', 10.0),
            ('2011-4-1', 9.0),
            ('2011-5-1', 7.5),
            ('2011-6-1', 7.0),
            ('2011-7-1', 6.5),
            ('2011-8-1', 7.5),
            ('2011-9-1', 8.5),
            ('2011-10-1', 10.0),
            ('2011-11-1', 11.5),
            ('2011-12-1', 12.0),
            ('2012-1-1', 13.5),
            ('2012-2-1', 11.0),
            ('2012-3-1', 10.0),
            ('2012-4-1', 9.0),
            ('2012-5-1', 7.5),
            ('2012-6-1', 7.0),
            ('2012-7-1', 6.5),
            ('2012-8-1', 7.5),
            ('2012-9-1', 8.5),
            ('2012-10-1', 10.0),
            ('2012-11-1', 11.5),
            ('2012-12-1', 12.0)
        )
    }
}

Because the periodisation argument is set to 'monthly', the deltas for each market in each month will be calculated, and estimated risk neutral hedge positions will be printed for each market in each period, along with the overall fair value.

results = calc(
    source_code=gas_storage,
    observation_date='2011-1-1',
    interest_rate=2.5,
    periodisation='monthly',
    price_process=gas,
    verbose=True,
)

assert round(results.fair_value.mean(), 2) == 20.78

print(results)

The results, showing deltas for each month for each market, and the fair value.

Compiled 92 nodes 
Compilation in 0.463s
Simulation in 0.061s
Starting 844 node evaluations, please wait...
844/844 100.00% complete 99.68 eval/s running 9s eta 0s
Evaluation in 8.468s


2011-04-01 GAS
Price:     9.00
Delta:    -0.99
Hedge:     1.00 ± 0.00
Cash:     -8.94 ± 0.03

2011-05-01 GAS
Price:     7.50
Delta:    -0.99
Hedge:     1.00 ± 0.00
Cash:     -7.44 ± 0.03

2011-06-01 GAS
Price:     7.00
Delta:    -0.99
Hedge:     1.00 ± 0.00
Cash:     -6.93 ± 0.03

2011-07-01 GAS
Price:     6.49
Delta:    -0.99
Hedge:     1.00 ± 0.00
Cash:     -6.41 ± 0.03

2011-08-01 GAS
Price:     7.49
Delta:    -0.99
Hedge:     1.00 ± 0.00
Cash:     -7.38 ± 0.04

2011-09-01 GAS
Price:     8.49
Delta:    -0.98
Hedge:     1.00 ± 0.00
Cash:     -8.35 ± 0.04

2011-10-01 GAS
Price:     9.97
Delta:     0.98
Hedge:    -1.00 ± 0.00
Cash:      9.79 ± 0.05

2011-11-01 GAS
Price:    11.47
Delta:     0.98
Hedge:    -1.00 ± 0.00
Cash:     11.23 ± 0.07

2011-12-01 GAS
Price:    11.98
Delta:     0.98
Hedge:    -1.00 ± 0.00
Cash:     11.70 ± 0.07

2012-01-01 GAS
Price:    13.46
Delta:     0.98
Hedge:    -1.00 ± 0.00
Cash:     13.13 ± 0.09

2012-02-01 GAS
Price:    10.98
Delta:     0.97
Hedge:    -1.00 ± 0.00
Cash:     10.68 ± 0.07

2012-03-01 GAS
Price:     9.99
Delta:     0.97
Hedge:    -1.00 ± 0.00
Cash:      9.70 ± 0.07

Net hedge GAS:       0.00 ± 0.00
Net hedge cash:     20.78 ± 0.28

Fair value: 20.78 ± 0.28

The value obtained is the extrinsic value. The intrinsic value can be obtained by setting the volatility sigma to 0, and can be evaluated with path_count of 1.

The recommended hedge positions suggest injecting gas when the price is low, and withdrawing when the price is high.

Gas fired power station

An evaluation of a gas fired power station. The value of a gas fired power station follows from selling generated power whilst paying for gas.

The Quant DSL source code below models a gas fired power station as a lattice of choices whether or not to run the power station. The efficiency of generation is modelled to be lower if the power station has been stopped.

Dispatch decisions are made daily, with gas and power traded one day ahead.

power_plant = """
from quantdsl.semantics import Choice, Market, TimeDelta, Wait, inline, Min


def PowerPlant(start, end, temp):
    if (start < end):
        Wait(start, Choice(
            PowerPlant(Tomorrow(start), end, Hot()) + ProfitFromRunning(start, temp),
            PowerPlant(Tomorrow(start), end, Stopped(temp))
        ))
    else:
        return 0

@inline
def Power(start):
    DayAhead(start, 'POWER')

@inline
def Gas(start):
    DayAhead(start, 'GAS')

@inline
def DayAhead(start, name):
    ForwardMarket(Tomorrow(start), name)
    
@inline
def Tomorrow(start):
    start + TimeDelta('1d')

@inline
def ProfitFromRunning(start, temp):
    if temp == Cold():
        return 0.3 * Power(start) - Gas(start)
    elif temp == Warm():
        return 0.6 * Power(start) - Gas(start)
    else:
        return Power(start) - Gas(start)

@inline
def Stopped(temp):
    if temp == Hot():
        Warm()
    else:
        Cold()

@inline
def Hot():
    2

@inline
def Warm():
    1

@inline
def Cold():
    0
    

PowerPlant(Date('2012-1-1'), Date('2012-1-5'), Cold())
"""

The prices process is calibrated with two correlated markets.

gas_and_power = {
    'name': 'quantdsl.priceprocess.blackscholes.BlackScholesPriceProcess',
    'market': ['GAS', 'POWER'],
    'sigma': [0.3, 0.3],
    'rho': [[1.0, 0.8], [0.8, 1.0]],
    'curve': {
            'GAS': [
                ('2012-1-1', 11.0),
                ('2012-1-2', 11.0),
                ('2012-1-3', 1.0),
                ('2012-1-4', 1.0),
                ('2012-1-5', 11.0),
            ],
            'POWER': [
                ('2012-1-1', 1.0),
                ('2012-1-2', 1.0),
                ('2012-1-3', 11.0),
                ('2012-1-4', 11.0),
                ('2012-1-5', 11.0),
            ]
        }
}

Because the periodisation is set to 'daily', the deltas for each market in each day will be calculated, and estimated risk neutral hedge positions will be printed for each market in each period, along with the overall fair value.

results = calc(
    source_code=power_plant,
    observation_date='2011-1-1',
    interest_rate=2.5,
    periodisation='daily',
    price_process=gas_and_power,
    verbose=True
)

assert round(results.fair_value.mean(), 2) == 12.82

print(results)

These are the results, showing monthly deltas for each of the two markets. The recommended hedge positions suggest running the plant when the price of power is high and the price of gas is low. The relative inefficiency of running the plant from Cold() is reflected in the delta for POWER in 2012-01-03.

Compiled 16 nodes 
Compilation in 0.038s
Simulation in 0.043s
Starting 112 node evaluations, please wait...
112/112 100.00% complete 115.57 eval/s running 1s eta 0s
Evaluation in 0.970s


2012-01-02 GAS
Price:    10.98
Delta:    -0.05
Hedge:     0.05 ± 0.00
Cash:     -0.41 ± 0.04

2012-01-02 POWER
Price:     1.00
Delta:     0.02
Hedge:    -0.02 ± 0.00
Cash:      0.02 ± 0.00

2012-01-03 GAS
Price:     1.00
Delta:    -0.98
Hedge:     1.00 ± 0.00
Cash:     -0.97 ± 0.01

2012-01-03 POWER
Price:    10.98
Delta:     0.32
Hedge:    -0.33 ± 0.00
Cash:      3.64 ± 0.05

2012-01-04 GAS
Price:     1.00
Delta:    -0.98
Hedge:     1.00 ± 0.00
Cash:     -0.97 ± 0.01

2012-01-04 POWER
Price:    10.98
Delta:     0.98
Hedge:    -1.00 ± 0.00
Cash:     10.71 ± 0.07

2012-01-05 GAS
Price:    10.98
Delta:    -0.49
Hedge:     0.50 ± 0.00
Cash:     -4.95 ± 0.11

2012-01-05 POWER
Price:    10.98
Delta:     0.49
Hedge:    -0.50 ± 0.00
Cash:      5.76 ± 0.13

Net hedge GAS:       2.55 ± 0.01
Net hedge POWER:    -1.85 ± 0.01
Net hedge cash:     12.82 ± 0.10

Fair value: 12.82 ± 0.10

Jupyter notebooks

It's easy to use Quant DSL in a Jupyter notebook. See example_notebook.ipynb.

Jupyter notebooks can be executed on a Jupyter hub.

Library

There is a small collection of Quant DSL modules in a library under quantdsl.lib. Putting Quant DSL source code in dedicated Python files makes it much easier to use a Python IDE to develop and maintain Quant DSL function definitions.

Acknowledgments

The Quant DSL language was partly inspired by the paper Composing contracts: an adventure in financial engineering (functional pearl) by Simon Peyton Jones and others. The idea of orchestrating evaluations with a dependency graph, to help with parallel and distributed execution, was inspired by a talk about dependency graphs by Kirat Singh. This implementation uses NumPy and SciPy packages, and the Python ast ("Absract Syntax Trees") module. We have also been encourged by members of the London Financial Python User Group, where Quant DSL expression syntax and semantics were first presented.