johnbywater / quantdsl / 146

pending completion

Build # 146

Build Type

push

travis-ci

Committed by

johnbywater

Commit Message

<a href="https://github.com/johnbywater/quantdsl/commit/<a class=hub.com/johnbywater/quantdsl/commit/f7d94f3f051ea7ee575ec2add4f1c6c1f7c411a0">f7d94f3f0<a href="https://github.com/johnbywater/quantdsl/commit/f7d94f3f051ea7ee575ec2add4f1c6c1f7c411a0">&quot;&gt;Added support for forward markets, so that delivery dates can be taken into account.

(cherry picked from commit </a><a class="double-link" href="https://github.com/johnbywater/quantdsl/commit/<a class="double-link" href="https://github.com/johnbywater/quantdsl/commit/d04bd2a8456c5e0432040749f96057bd58a80360">d04bd2a84</a>">d04bd2a84</a><a href="https://github.com/johnbywater/quantdsl/commit/f7d94f3f051ea7ee575ec2add4f1c6c1f7c411a0">)

Run Details

77 of 77 new or added lines in 7 files covered. (100.0%)

2963 of 4033 relevant lines covered (73.47%)

2.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.04

/quantdsl/test_application.py

import datetime
import unittest

from abc import ABCMeta
from time import sleep

import scipy
from eventsourcing.domain.model.events import assert_event_handlers_empty
from six import with_metaclass

from quantdsl.application.with_pythonobjects import QuantDslApplicationWithPythonObjects
from quantdsl.domain.model.call_result import make_call_result_id, CallResult
from quantdsl.domain.model.contract_valuation import create_contract_valuation_id
from quantdsl.domain.model.market_calibration import MarketCalibration
from quantdsl.domain.model.market_simulation import MarketSimulation
from quantdsl.domain.services.call_links import regenerate_execution_order
from quantdsl.semantics import Market
from quantdsl.services import DEFAULT_PRICE_PROCESS_NAME


class ApplicationTestCaseMixin(with_metaclass(ABCMeta)):
    skip_assert_event_handers_empty = False
    NUMBER_DAYS = 5
    NUMBER_MARKETS = 2
    NUMBER_WORKERS = 30
    PATH_COUNT = 2000

    def setUp(self):
        if not self.skip_assert_event_handers_empty:
            assert_event_handlers_empty()
        # super(ContractValuationTestCase, self).setUp()

        scipy.random.seed(1354802735)

        self.setup_application()

    def tearDown(self):
        if self.app is not None:
            self.app.close()
        if not self.skip_assert_event_handers_empty:
            assert_event_handlers_empty()
        # super(ContractValuationTestCase, self).tearDown()

    def setup_application(self):
        self.app = QuantDslApplicationWithPythonObjects()


class TestCase(ApplicationTestCaseMixin, unittest.TestCase):

    def setUp(self):
        super(TestCase, self).setUp()

    def tearDown(self):
        super(TestCase, self).tearDown()


class ContractValuationTestCase(ApplicationTestCaseMixin):

    def setup_market_simulation(self, contract_specification):
        price_process_name = DEFAULT_PRICE_PROCESS_NAME
        calibration_params = \
{
    '#1-LAST-PRICE': 10,
    '#2-LAST-PRICE': 10,
    '#1-ACTUAL-HISTORICAL-VOLATILITY': 50,
    '#2-ACTUAL-HISTORICAL-VOLATILITY': 50,
    '#1-#2-CORRELATION': 0.0,
    'NBP-LAST-PRICE': 10,
    'TTF-LAST-PRICE': 11,
    'NBP-ACTUAL-HISTORICAL-VOLATILITY': 50,
    'TTF-ACTUAL-HISTORICAL-VOLATILITY': 40,
    'NBP-TTF-CORRELATION': 0.4,
    'NBP-2011-01-LAST-PRICE': 10,
    'NBP-2011-01-ACTUAL-HISTORICAL-VOLATILITY': 10,
    'NBP-2012-01-LAST-PRICE': 10,
    'NBP-2012-01-ACTUAL-HISTORICAL-VOLATILITY': 10,
    'NBP-2012-01-NBP-2012-02-CORRELATION': 0.4,
    'NBP-2012-02-NBP-2012-03-CORRELATION': 0.4,
}
        market_calibration = self.app.register_market_calibration(price_process_name, calibration_params)
        market_names, fixing_dates = self.app.list_market_names_and_fixing_dates(contract_specification)
        observation_date = datetime.date(2011, 1, 1)
        path_count = self.PATH_COUNT
        market_simulation = self.app.register_market_simulation(
            market_calibration_id=market_calibration.id,
            market_names=market_names,
            fixing_dates=fixing_dates,
            observation_date=observation_date,
            path_count=path_count,
            interest_rate='2.5',
        )
        return market_simulation

    def assert_contract_value(self, specification, expected_value, expected_deltas=None, expected_call_count=None):
        # Register the specification (creates call dependency graph).
        contract_specification = self.app.register_contract_specification(specification=specification)

        # Check the call count (the number of nodes of the call dependency graph).
        call_count = len(list(regenerate_execution_order(contract_specification.id, self.app.call_link_repo)))

        if expected_call_count is not None:
            self.assertEqual(call_count, expected_call_count)

        # Generate the market simulation.
        market_simulation = self.setup_market_simulation(contract_specification)

        # Generate the contract valuation ID.
        contract_valuation_id = create_contract_valuation_id()
        call_result_id = make_call_result_id(contract_valuation_id, contract_specification.id)

        # Listen for the call result, if possible.
        # Todo: Listen for results, rather than polling for results - there will be less lag.
        # call_result_listener = None

        # Start the contract valuation.
        self.app.start_contract_valuation(contract_valuation_id, contract_specification.id, market_simulation)

        # # Get the call result.
        # if call_result_listener:
        #     call_result_listener.wait()

        main_result = self.get_result(call_result_id, call_count)

        # Check the call result.
        assert isinstance(main_result, CallResult)
        self.assertAlmostEqual(self.scalar(main_result.result_value), expected_value, places=2)

        if expected_deltas is None:
            return

        # Generate the contract valuation deltas.
        assert isinstance(market_simulation, MarketSimulation)
        for market_name in expected_deltas.keys():

            # Compute the delta.
            if market_name not in main_result.perturbed_values:
                self.fail("There isn't a perturbed value for market name '{}': {}"
                          "".format(market_name, tuple(main_result.perturbed_values.keys())))

            perturbed_value = main_result.perturbed_values[market_name].mean()
            market_calibration = self.app.market_calibration_repo[market_simulation.market_calibration_id]
            assert isinstance(market_calibration, MarketCalibration)
            last_price = market_calibration.calibration_params['%s-LAST-PRICE' % market_name]
            price_perturbation = Market.PERTURBATION_FACTOR * last_price
            contract_delta = (perturbed_value - main_result.result_value) / price_perturbation

            # Check the delta.
            actual_value = contract_delta.mean()
            expected_value = expected_deltas[market_name]
            error_msg = "{} != {}".format(actual_value, expected_value)
            self.assertAlmostEqual(actual_value, expected_value, places=2, msg=error_msg)

    def scalar(self, contract_value):
        if isinstance(contract_value, scipy.ndarray):
            contract_value = contract_value.mean()
        return contract_value

    def get_result(self, call_result_id, call_count):
        patience = max(call_count, 10) * 1.5 * (max(self.PATH_COUNT, 2000) / 1000)  # Guesses.
        # while patience > 0:
        while True:
            if call_result_id in self.app.call_result_repo:
                break
            interval = 0.1
            self.sleep(interval)
            patience -= interval
        else:
            self.fail("Timeout whilst waiting for result")
        call_result = self.app.call_result_repo[call_result_id]
        return call_result

    def sleep(self, interval):
        sleep(interval)


class ExpressionTests(ContractValuationTestCase):

    def test_generate_valuation_addition(self):
        self.assert_contract_value("""1 + 2""", 3)
        self.assert_contract_value("""2 + 4""", 6)

    def test_market(self):
        self.assert_contract_value("Market('#1')", 10, {'#1': 1})
        self.assert_contract_value("Market('#2')", 10, {'#2': 1})

    def test_market_plus(self):
        self.assert_contract_value("Market('#1') + 10", 20)
        self.assert_contract_value("Market('#2') + 20", 30)

    def test_market_minus(self):
        self.assert_contract_value("Market('#1') - 10", 0)
        self.assert_contract_value("Market('#2') - 10", 0)

    def test_market_multiply_market(self):
        self.assert_contract_value("Market('#1') * Market('#2')", 100)

    def test_market_divide(self):
        self.assert_contract_value("Market('#1') / 10", 1)

    def test_fixing(self):
        specification = "Fixing(Date('2012-01-01'), Market('NBP'))"
        self.assert_contract_value(specification, 10.1083)

    def test_wait(self):
        specification = "Wait(Date('2012-01-01'), Market('NBP'))"
        self.assert_contract_value(specification, 9.8587)

    def test_settlement(self):
        specification = "Settlement(Date('2012-01-01'), Market('NBP'))"
        self.assert_contract_value(specification, 9.753)

    def test_choice(self):
        specification = "Fixing(Date('2012-01-01'), Choice( Market('NBP') - 9, 0))"
        self.assert_contract_value(specification, 2.5178)

    def test_max(self):
        specification = "Fixing(Date('2011-01-01'), Max(Market('#1'), Market('#2')))"
        self.assert_contract_value(specification, 10.0000)
        specification = "Fixing(Date('2012-01-01'), Max(Market('#1'), Market('#2')))"
        self.assert_contract_value(specification, 13.0250)

    def test_bermudan(self):
        specification = """
Fixing(Date('2011-06-01'), Choice(Market('NBP') - 9,
    Fixing(Date('2012-01-01'), Choice(Market('NBP') - 9, 0))))
"""
        self.assert_contract_value(specification, 2.6093, expected_deltas={'NBP': 0.7123})

    def test_identical_fixings(self):
        specification = "Fixing(Date('2012-01-02'), Market('#1')) - Fixing(Date('2012-01-02'), Market('#1'))"
        self.assert_contract_value(specification, 0)

    def test_uncorrelated_markets(self):
        specification = """
Max(
    Fixing(
        Date('2012-01-01'),
        Market('#1')
    ) *
    Fixing(
        Date('2012-01-01'),
        Market('#2')
    ) / 10.0,
    0.0
) - Max(
    Fixing(
        Date('2013-01-01'),
        Market('#1')
    ), 0
)"""
        self.assert_contract_value(specification, -0.264)

    def test_correlated_markets(self):
        specification = """
Max(
    Fixing(
        Date('2012-01-01'),
        Market('TTF')
    ) *
    Fixing(
        Date('2012-01-01'),
        Market('NBP')
    ) / 10.0,
    0.0
) - Max(
    Fixing(
        Date('2013-01-01'),
        Market('TTF')
    ), 0
)"""
        self.assert_contract_value(specification, 0.9355)

    def test_futures(self):
        specification = "Wait(Date('2012-01-01'), Market('#1') - 9)"
        self.assert_contract_value(specification, 1.0809)

    def test_european_zero_volatility(self):
        self.assert_contract_value("Wait(Date('2012-01-01'), Choice(Market('#1') - 9, 0))", 2.4557)

    def test_european_high_volatility(self):
        self.assert_contract_value("Wait(Date('2012-01-01'), Choice(Market('NBP') - 9, 0))", 2.4557)

    def test_sum_contracts(self):
        specification = """
Fixing(
    Date('2011-06-01'),
    Choice(
        Market('NBP') - 9,
        Fixing(
            Date('2012-01-01'),
            Choice(
                Market('NBP') - 9,
                0
            )
        )
    )
) + Fixing(
    Date('2011-06-01'),
    Choice(
        Market('NBP') - 9,
        Fixing(
            Date('2012-01-01'),
            Choice(
                Market('NBP') - 9,
                0
            )
        )
    )
)
"""
        self.assert_contract_value(specification, 5.2187)

    def test_brownian_increments(self):
        specification = """
Wait(
    Date('2012-03-15'),
    Max(
        Fixing(
            Date('2012-01-01'),
            Market('#1')
        ) /
        Fixing(
            Date('2011-01-01'),
            Market('#1')
        ),
        1.0
    ) -
    Max(
        Fixing(
            Date('2013-01-01'),
            Market('#1')
        ) /
        Fixing(
            Date('2012-01-01'),
            Market('#1')
        ),
        1.0
    )
)"""
        self.assert_contract_value(specification, 0.005, expected_deltas={'#1': 0})


class FunctionTests(ContractValuationTestCase):

    def test_functional_fibonacci_numbers(self):
        fib_tmpl = """
def fib(n): return fib(n-1) + fib(n-2) if n > 1 else n
fib(%d)
"""
        # self.assert_contract_value(fib_tmpl % 0, 0, expected_call_count=2)
        # self.assert_contract_value(fib_tmpl % 1, 1, expected_call_count=2)
        # self.assert_contract_value(fib_tmpl % 2, 1, expected_call_count=4)
        # self.assert_contract_value(fib_tmpl % 3, 2, expected_call_count=5)
        self.assert_contract_value(fib_tmpl % 4, 3, expected_call_count=6)
        # self.assert_contract_value(fib_tmpl % 5, 5, expected_call_count=7)
        # self.assert_contract_value(fib_tmpl % 6, 8, expected_call_count=8)
        # self.assert_contract_value(fib_tmpl % 7, 13, expected_call_count=9)
        # self.assert_contract_value(fib_tmpl % 17, 1597, expected_call_count=19)

    def test_functional_derivative_option_definition(self):
        specification = """
def Option(date, strike, x, y):
    return Wait(date, Choice(x - strike, y))

Option(Date('2012-01-01'), 9, Underlying(Market('NBP')), 0)
"""
        self.assert_contract_value(specification, 2.4557, expected_call_count=2)

    def test_functional_european_option_definition(self):
        specification = """
def Option(date, strike, underlying, alternative):
    return Wait(date, Choice(underlying - strike, alternative))

def European(date, strike, underlying):
    return Option(date, strike, underlying, 0)

European(Date('2012-01-01'), 9, Market('NBP'))
"""
        self.assert_contract_value(specification, 2.4557, {'NBP': 0.6743}, expected_call_count=3)

    def test_generate_valuation_american_option(self):
        american_option_tmpl = """
def American(starts, ends, strike, underlying):
    if starts < ends:
        Option(starts, strike, underlying,
            American(starts + TimeDelta('1d'), ends, strike, underlying)
        )
    else:
        Option(starts, strike, underlying, 0)

@nostub
def Option(date, strike, underlying, alternative):
    Wait(date, Choice(underlying - strike, alternative))

American(Date('%(starts)s'), Date('%(ends)s'), %(strike)s, Market('%(underlying)s'))
"""
        self.assert_contract_value(american_option_tmpl % {
            'starts':'2011-01-02',
            'ends': '2011-01-04',
            'strike': 9,
            'underlying': '#1'
        }, 1.1874, {'#1': 1.0185}, expected_call_count=4)

    def test_generate_valuation_swing_option(self):
        specification = """
def Swing(start_date, end_date, underlying, quantity):
    if (quantity != 0) and (start_date < end_date):
        return Choice(
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, underlying),
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
        )
    else:
        return 0

Swing(Date('2011-01-01'), Date('2011-01-05'), Market('NBP'), 3)
"""
        self.assert_contract_value(specification, 30.20756, {'NBP': 3.02076}, expected_call_count=15)


class LongerTests(ContractValuationTestCase):

    def test_value_swing_option(self):
        specification = """
def Swing(start_date, end_date, underlying, quantity):
    if (quantity != 0) and (start_date < end_date):
        return Choice(
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, Market(underlying)),
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
        )
    else:
        return 0

Swing(Date('2011-1-1'), Date('2011-1-5'), 'NBP', 3)
"""
        self.assert_contract_value(specification, 30.2081, expected_call_count=15)

    def _test_generate_valuation_power_plant_option(self):
        specification = """
def PowerPlant(start_date, end_date, underlying, time_since_off):
    if (start_date < end_date):
        Choice(
            PowerPlant(start_date + TimeDelta('1d'), end_date, underlying, 0) + ProfitFromRunning(start_date, underlying, time_since_off),
            PowerPlant(start_date + TimeDelta('1d'), end_date, underlying, NextTime(time_since_off)),
        )
    else:
        return 0

@nostub
def NextTime(time_since_off):
    if time_since_off == 2:
        return 2
    else:
        return time_since_off + 1

@nostub
def ProfitFromRunning(start_date, underlying, time_since_off):
    if time_since_off == 0:
        return Fixing(start_date, underlying)
    elif time_since_off == 1:
        return 0.9 * Fixing(start_date, underlying)
    else:
        return 0.8 * Fixing(start_date, underlying)

PowerPlant(Date('2012-01-01'), Date('2013-06-01'), Market('#1'), 30)
"""
        self.assert_contract_value(specification, 48, expected_call_count=2067)


class SpecialTests(ContractValuationTestCase):

    def test_simple_expression_with_market(self):
        dsl = "Market('NBP') + 2 * Market('TTF')"
        self.assert_contract_value(dsl, 32, {'NBP': 1, 'TTF': 2}, expected_call_count=1)

    def test_simple_function_with_market(self):
        dsl = """
def F():
  Market('NBP') + 2 * Market('TTF')

F()
"""
        self.assert_contract_value(dsl, 32, {'NBP': 1, 'TTF': 2}, expected_call_count=2)

    def test_generate_valuation_swing_option(self):
        specification = """
def Swing(start_date, end_date, underlying, quantity):
    if (quantity != 0) and (start_date < end_date):
        return Choice(
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, underlying),
            Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
        )
    else:
        return 0

Swing(Date('2011-01-01'), Date('2011-01-05'), Market('NBP'), 3)
"""
        self.assert_contract_value(specification, 30.20756, {'NBP': 3.0207}, expected_call_count=15)
        # self.assert_contract_value(specification, 30.20756, {}, expected_call_count=15)

    def test_reuse_unperturbed_call_results(self):
        specification = """
def SumTwoMarkets(market_name1, market_name2):
    GetMarket(market_name1) + GetMarket(market_name2)

def GetMarket(market_name):
    Market(market_name)

SumTwoMarkets('NBP', 'TTF')
"""
        self.assert_contract_value(specification,
                                   expected_value=21,
                                   expected_deltas={'NBP': 1, 'TTF': 1},
                                   expected_call_count=4,
                                   )

    def test_reuse_unperturbed_call_results2(self):
        specification = """
def Swing(start_date, end_date, underlying, quantity):
    if (quantity != 0) and (start_date < end_date):
        return Choice(
            Exercise(Swing, start_date, end_date, underlying, quantity),
            Hold(Swing, start_date, end_date, underlying, quantity)
        )
    else:
        return 0

@nostub
def Exercise(f, start_date, end_date, underlying, quantity):
    return Hold(f, start_date, end_date, underlying, quantity - 1) + Fixing(start_date, underlying)

@nostub
def Hold(f, start_date, end_date, underlying, quantity):
    return f(start_date + TimeDelta('1d'), end_date, underlying, quantity)

Swing(Date('2011-1-1'), Date('2011-1-4'), Market('#1'), 2) * 1 + \
Swing(Date('2011-1-1'), Date('2011-1-4'), Market('#2'), 2) * 2
"""
        self.assert_contract_value(specification,
                                   expected_call_count=19,
                                   expected_value=60.4826,
                                   expected_deltas={'#1': 2.0168, '#2': 4.0313},
                                   )

class ExperimentalTests(ContractValuationTestCase):

    def _test_simple_expression_with_market(self):
        dsl = """
def Swing(start, end, step, market, quantity):
    if (quantity != 0) and (start <= end):
        Max(
            HoldSwing(start, end, step, market, quantity),
            ExerciseSwing(start, end, step, market, quantity, 1)
        )
    else:
        0

@nostub
def HoldSwing(start, end, step, market, quantity):
    On(start, Swing(start+step, end, step, market, quantity))

@nostub
def ExerciseSwing(start, end, step, market, quantity, vol):
    Settlement(start, vol*market) + HoldSwing(start, end, step, market, quantity-vol)

Swing(Date('2011-01-01'), Date('2011-01-02'), TimeDelta('1d'), Market('NBP'), 1)
"""
        self.assert_contract_value(dsl, 10, {'NBP': 1}, expected_call_count=6)

    def test_value_swing_option_with_forward_markets(self):
        specification = """
def Swing(start_date, end_date, quantity):
    if (quantity != 0) and (start_date < end_date):
        return Choice(
            Swing(start_date + TimeDelta('1d'), end_date, quantity-1) + Fixing(start_date, ForwardMarket('NBP', start_date + TimeDelta('1d'))),
            Swing(start_date + TimeDelta('1d'), end_date, quantity)
        )
    else:
        return 0

Swing(Date('2011-01-01'), Date('2011-1-4'), 30)
"""
        self.assert_contract_value(specification, 30.00, {'NBP-2011-01': 3.0}, expected_call_count=11)

    def test_simple_forward_market(self):
        specification = """ForwardMarket('NBP', '2012-1-1')"""
        self.assert_contract_value(specification, 10.00, {'NBP-2012-01': 1.0}, expected_call_count=1)


class ContractValuationTests(
    ExperimentalTests,
    SpecialTests,
    ExpressionTests,
    FunctionTests,
    LongerTests
): pass


1	import datetime	3✔
2	import unittest	3✔
3
4	from abc import ABCMeta	3✔
5	from time import sleep	3✔
6
7	import scipy	3✔
8	from eventsourcing.domain.model.events import assert_event_handlers_empty	3✔
9	from six import with_metaclass	3✔
10
11	from quantdsl.application.with_pythonobjects import QuantDslApplicationWithPythonObjects	3✔
12	from quantdsl.domain.model.call_result import make_call_result_id, CallResult	3✔
13	from quantdsl.domain.model.contract_valuation import create_contract_valuation_id	3✔
14	from quantdsl.domain.model.market_calibration import MarketCalibration	3✔
15	from quantdsl.domain.model.market_simulation import MarketSimulation	3✔
16	from quantdsl.domain.services.call_links import regenerate_execution_order	3✔
17	from quantdsl.semantics import Market	3✔
18	from quantdsl.services import DEFAULT_PRICE_PROCESS_NAME	3✔
19
20
21	class ApplicationTestCaseMixin(with_metaclass(ABCMeta)):	3✔
22	skip_assert_event_handers_empty = False	3✔
23	NUMBER_DAYS = 5	3✔
24	NUMBER_MARKETS = 2	3✔
25	NUMBER_WORKERS = 30	3✔
26	PATH_COUNT = 2000	3✔
27
28	def setUp(self):	3✔
29	if not self.skip_assert_event_handers_empty:	3✔
30	assert_event_handlers_empty()	3✔
31	# super(ContractValuationTestCase, self).setUp()
32
33	scipy.random.seed(1354802735)	3✔
34
35	self.setup_application()	3✔
36
37	def tearDown(self):	3✔
38	if self.app is not None:	3✔
39	self.app.close()	3✔
40	if not self.skip_assert_event_handers_empty:	3✔
41	assert_event_handlers_empty()	3✔
42	# super(ContractValuationTestCase, self).tearDown()
43
44	def setup_application(self):	3✔
45	self.app = QuantDslApplicationWithPythonObjects()	3✔
46
47
48	class TestCase(ApplicationTestCaseMixin, unittest.TestCase):	3✔
49
50	def setUp(self):	3✔
51	super(TestCase, self).setUp()	3✔
52
53	def tearDown(self):	3✔
54	super(TestCase, self).tearDown()	3✔
55
56
57	class ContractValuationTestCase(ApplicationTestCaseMixin):	3✔
58
59	def setup_market_simulation(self, contract_specification):	3✔
60	price_process_name = DEFAULT_PRICE_PROCESS_NAME	3✔
61	calibration_params = \	3✔
62	{
63	'#1-LAST-PRICE': 10,
64	'#2-LAST-PRICE': 10,
65	'#1-ACTUAL-HISTORICAL-VOLATILITY': 50,
66	'#2-ACTUAL-HISTORICAL-VOLATILITY': 50,
67	'#1-#2-CORRELATION': 0.0,
68	'NBP-LAST-PRICE': 10,
69	'TTF-LAST-PRICE': 11,
70	'NBP-ACTUAL-HISTORICAL-VOLATILITY': 50,
71	'TTF-ACTUAL-HISTORICAL-VOLATILITY': 40,
72	'NBP-TTF-CORRELATION': 0.4,
73	'NBP-2011-01-LAST-PRICE': 10,
74	'NBP-2011-01-ACTUAL-HISTORICAL-VOLATILITY': 10,
75	'NBP-2012-01-LAST-PRICE': 10,
76	'NBP-2012-01-ACTUAL-HISTORICAL-VOLATILITY': 10,
77	'NBP-2012-01-NBP-2012-02-CORRELATION': 0.4,
78	'NBP-2012-02-NBP-2012-03-CORRELATION': 0.4,
79	}
80	market_calibration = self.app.register_market_calibration(price_process_name, calibration_params)	3✔
81	market_names, fixing_dates = self.app.list_market_names_and_fixing_dates(contract_specification)	3✔
82	observation_date = datetime.date(2011, 1, 1)	3✔
83	path_count = self.PATH_COUNT	3✔
84	market_simulation = self.app.register_market_simulation(	3✔
85	market_calibration_id=market_calibration.id,
86	market_names=market_names,
87	fixing_dates=fixing_dates,
88	observation_date=observation_date,
89	path_count=path_count,
90	interest_rate='2.5',
91	)
92	return market_simulation	3✔
93
94	def assert_contract_value(self, specification, expected_value, expected_deltas=None, expected_call_count=None):	3✔
95	# Register the specification (creates call dependency graph).
96	contract_specification = self.app.register_contract_specification(specification=specification)	3✔
97
98	# Check the call count (the number of nodes of the call dependency graph).
99	call_count = len(list(regenerate_execution_order(contract_specification.id, self.app.call_link_repo)))	3✔
100
101	if expected_call_count is not None:	3✔
102	self.assertEqual(call_count, expected_call_count)	3✔
103
104	# Generate the market simulation.
105	market_simulation = self.setup_market_simulation(contract_specification)	3✔
106
107	# Generate the contract valuation ID.
108	contract_valuation_id = create_contract_valuation_id()	3✔
109	call_result_id = make_call_result_id(contract_valuation_id, contract_specification.id)	3✔
110
111	# Listen for the call result, if possible.
112	# Todo: Listen for results, rather than polling for results - there will be less lag.
113	# call_result_listener = None
114
115	# Start the contract valuation.
116	self.app.start_contract_valuation(contract_valuation_id, contract_specification.id, market_simulation)	3✔
117
118	# # Get the call result.
119	# if call_result_listener:
120	# call_result_listener.wait()
121
122	main_result = self.get_result(call_result_id, call_count)	3✔
123
124	# Check the call result.
125	assert isinstance(main_result, CallResult)	3✔
126	self.assertAlmostEqual(self.scalar(main_result.result_value), expected_value, places=2)	3✔
127
128	if expected_deltas is None:	3✔
129	return	3✔
130
131	# Generate the contract valuation deltas.
132	assert isinstance(market_simulation, MarketSimulation)	3✔
133	for market_name in expected_deltas.keys():	3✔
134
135	# Compute the delta.
136	if market_name not in main_result.perturbed_values:	3✔
137	self.fail("There isn't a perturbed value for market name '{}': {}"	×
138	"".format(market_name, tuple(main_result.perturbed_values.keys())))
139
140	perturbed_value = main_result.perturbed_values[market_name].mean()	3✔
141	market_calibration = self.app.market_calibration_repo[market_simulation.market_calibration_id]	3✔
142	assert isinstance(market_calibration, MarketCalibration)	3✔
143	last_price = market_calibration.calibration_params['%s-LAST-PRICE' % market_name]	3✔
144	price_perturbation = Market.PERTURBATION_FACTOR * last_price	3✔
145	contract_delta = (perturbed_value - main_result.result_value) / price_perturbation	3✔
146
147	# Check the delta.
148	actual_value = contract_delta.mean()	3✔
149	expected_value = expected_deltas[market_name]	3✔
150	error_msg = "{} != {}".format(actual_value, expected_value)	3✔
151	self.assertAlmostEqual(actual_value, expected_value, places=2, msg=error_msg)	3✔
152
153	def scalar(self, contract_value):	3✔
154	if isinstance(contract_value, scipy.ndarray):	3✔
155	contract_value = contract_value.mean()	3✔
156	return contract_value	3✔
157
158	def get_result(self, call_result_id, call_count):	3✔
159	patience = max(call_count, 10) * 1.5 * (max(self.PATH_COUNT, 2000) / 1000) # Guesses.	3✔
160	# while patience > 0:
161	while True:	3✔
162	if call_result_id in self.app.call_result_repo:	3✔
163	break	3✔
164	interval = 0.1	3✔
165	self.sleep(interval)	3✔
166	patience -= interval	3✔
167	else:
168	self.fail("Timeout whilst waiting for result")	×
169	call_result = self.app.call_result_repo[call_result_id]	3✔
170	return call_result	3✔
171
172	def sleep(self, interval):	3✔
173	sleep(interval)	3✔
174
175
176	class ExpressionTests(ContractValuationTestCase):	3✔
177
178	def test_generate_valuation_addition(self):	3✔
179	self.assert_contract_value("""1 + 2""", 3)	3✔
180	self.assert_contract_value("""2 + 4""", 6)	3✔
181
182	def test_market(self):	3✔
183	self.assert_contract_value("Market('#1')", 10, {'#1': 1})	3✔
184	self.assert_contract_value("Market('#2')", 10, {'#2': 1})	3✔
185
186	def test_market_plus(self):	3✔
187	self.assert_contract_value("Market('#1') + 10", 20)	3✔
188	self.assert_contract_value("Market('#2') + 20", 30)	3✔
189
190	def test_market_minus(self):	3✔
191	self.assert_contract_value("Market('#1') - 10", 0)	3✔
192	self.assert_contract_value("Market('#2') - 10", 0)	3✔
193
194	def test_market_multiply_market(self):	3✔
195	self.assert_contract_value("Market('#1') * Market('#2')", 100)	3✔
196
197	def test_market_divide(self):	3✔
198	self.assert_contract_value("Market('#1') / 10", 1)	3✔
199
200	def test_fixing(self):	3✔
201	specification = "Fixing(Date('2012-01-01'), Market('NBP'))"	3✔
202	self.assert_contract_value(specification, 10.1083)	3✔
203
204	def test_wait(self):	3✔
205	specification = "Wait(Date('2012-01-01'), Market('NBP'))"	3✔
206	self.assert_contract_value(specification, 9.8587)	3✔
207
208	def test_settlement(self):	3✔
209	specification = "Settlement(Date('2012-01-01'), Market('NBP'))"	3✔
210	self.assert_contract_value(specification, 9.753)	3✔
211
212	def test_choice(self):	3✔
213	specification = "Fixing(Date('2012-01-01'), Choice( Market('NBP') - 9, 0))"	3✔
214	self.assert_contract_value(specification, 2.5178)	3✔
215
216	def test_max(self):	3✔
217	specification = "Fixing(Date('2011-01-01'), Max(Market('#1'), Market('#2')))"	3✔
218	self.assert_contract_value(specification, 10.0000)	3✔
219	specification = "Fixing(Date('2012-01-01'), Max(Market('#1'), Market('#2')))"	3✔
220	self.assert_contract_value(specification, 13.0250)	3✔
221
222	def test_bermudan(self):	3✔
223	specification = """	3✔
224	Fixing(Date('2011-06-01'), Choice(Market('NBP') - 9,
225	Fixing(Date('2012-01-01'), Choice(Market('NBP') - 9, 0))))
226	"""
227	self.assert_contract_value(specification, 2.6093, expected_deltas={'NBP': 0.7123})	3✔
228
229	def test_identical_fixings(self):	3✔
230	specification = "Fixing(Date('2012-01-02'), Market('#1')) - Fixing(Date('2012-01-02'), Market('#1'))"	3✔
231	self.assert_contract_value(specification, 0)	3✔
232
233	def test_uncorrelated_markets(self):	3✔
234	specification = """	3✔
235	Max(
236	Fixing(
237	Date('2012-01-01'),
238	Market('#1')
239	) *
240	Fixing(
241	Date('2012-01-01'),
242	Market('#2')
243	) / 10.0,
244	0.0
245	) - Max(
246	Fixing(
247	Date('2013-01-01'),
248	Market('#1')
249	), 0
250	)"""
251	self.assert_contract_value(specification, -0.264)	3✔
252
253	def test_correlated_markets(self):	3✔
254	specification = """	3✔
255	Max(
256	Fixing(
257	Date('2012-01-01'),
258	Market('TTF')
259	) *
260	Fixing(
261	Date('2012-01-01'),
262	Market('NBP')
263	) / 10.0,
264	0.0
265	) - Max(
266	Fixing(
267	Date('2013-01-01'),
268	Market('TTF')
269	), 0
270	)"""
271	self.assert_contract_value(specification, 0.9355)	3✔
272
273	def test_futures(self):	3✔
274	specification = "Wait(Date('2012-01-01'), Market('#1') - 9)"	3✔
275	self.assert_contract_value(specification, 1.0809)	3✔
276
277	def test_european_zero_volatility(self):	3✔
278	self.assert_contract_value("Wait(Date('2012-01-01'), Choice(Market('#1') - 9, 0))", 2.4557)	3✔
279
280	def test_european_high_volatility(self):	3✔
281	self.assert_contract_value("Wait(Date('2012-01-01'), Choice(Market('NBP') - 9, 0))", 2.4557)	3✔
282
283	def test_sum_contracts(self):	3✔
284	specification = """	3✔
285	Fixing(
286	Date('2011-06-01'),
287	Choice(
288	Market('NBP') - 9,
289	Fixing(
290	Date('2012-01-01'),
291	Choice(
292	Market('NBP') - 9,
293	0
294	)
295	)
296	)
297	) + Fixing(
298	Date('2011-06-01'),
299	Choice(
300	Market('NBP') - 9,
301	Fixing(
302	Date('2012-01-01'),
303	Choice(
304	Market('NBP') - 9,
305	0
306	)
307	)
308	)
309	)
310	"""
311	self.assert_contract_value(specification, 5.2187)	3✔
312
313	def test_brownian_increments(self):	3✔
314	specification = """	3✔
315	Wait(
316	Date('2012-03-15'),
317	Max(
318	Fixing(
319	Date('2012-01-01'),
320	Market('#1')
321	) /
322	Fixing(
323	Date('2011-01-01'),
324	Market('#1')
325	),
326	1.0
327	) -
328	Max(
329	Fixing(
330	Date('2013-01-01'),
331	Market('#1')
332	) /
333	Fixing(
334	Date('2012-01-01'),
335	Market('#1')
336	),
337	1.0
338	)
339	)"""
340	self.assert_contract_value(specification, 0.005, expected_deltas={'#1': 0})	3✔
341
342
343	class FunctionTests(ContractValuationTestCase):	3✔
344
345	def test_functional_fibonacci_numbers(self):	3✔
346	fib_tmpl = """	3✔
347	def fib(n): return fib(n-1) + fib(n-2) if n > 1 else n
348	fib(%d)
349	"""
350	# self.assert_contract_value(fib_tmpl % 0, 0, expected_call_count=2)
351	# self.assert_contract_value(fib_tmpl % 1, 1, expected_call_count=2)
352	# self.assert_contract_value(fib_tmpl % 2, 1, expected_call_count=4)
353	# self.assert_contract_value(fib_tmpl % 3, 2, expected_call_count=5)
354	self.assert_contract_value(fib_tmpl % 4, 3, expected_call_count=6)	3✔
355	# self.assert_contract_value(fib_tmpl % 5, 5, expected_call_count=7)
356	# self.assert_contract_value(fib_tmpl % 6, 8, expected_call_count=8)
357	# self.assert_contract_value(fib_tmpl % 7, 13, expected_call_count=9)
358	# self.assert_contract_value(fib_tmpl % 17, 1597, expected_call_count=19)
359
360	def test_functional_derivative_option_definition(self):	3✔
361	specification = """	3✔
362	def Option(date, strike, x, y):
363	return Wait(date, Choice(x - strike, y))
364
365	Option(Date('2012-01-01'), 9, Underlying(Market('NBP')), 0)
366	"""
367	self.assert_contract_value(specification, 2.4557, expected_call_count=2)	3✔
368
369	def test_functional_european_option_definition(self):	3✔
370	specification = """	3✔
371	def Option(date, strike, underlying, alternative):
372	return Wait(date, Choice(underlying - strike, alternative))
373
374	def European(date, strike, underlying):
375	return Option(date, strike, underlying, 0)
376
377	European(Date('2012-01-01'), 9, Market('NBP'))
378	"""
379	self.assert_contract_value(specification, 2.4557, {'NBP': 0.6743}, expected_call_count=3)	3✔
380
381	def test_generate_valuation_american_option(self):	3✔
382	american_option_tmpl = """	3✔
383	def American(starts, ends, strike, underlying):
384	if starts < ends:
385	Option(starts, strike, underlying,
386	American(starts + TimeDelta('1d'), ends, strike, underlying)
387	)
388	else:
389	Option(starts, strike, underlying, 0)
390
391	@nostub
392	def Option(date, strike, underlying, alternative):
393	Wait(date, Choice(underlying - strike, alternative))
394
395	American(Date('%(starts)s'), Date('%(ends)s'), %(strike)s, Market('%(underlying)s'))
396	"""
397	self.assert_contract_value(american_option_tmpl % {	3✔
398	'starts':'2011-01-02',
399	'ends': '2011-01-04',
400	'strike': 9,
401	'underlying': '#1'
402	}, 1.1874, {'#1': 1.0185}, expected_call_count=4)
403
404	def test_generate_valuation_swing_option(self):	3✔
405	specification = """	×
406	def Swing(start_date, end_date, underlying, quantity):
407	if (quantity != 0) and (start_date < end_date):
408	return Choice(
409	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, underlying),
410	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
411	)
412	else:
413	return 0
414
415	Swing(Date('2011-01-01'), Date('2011-01-05'), Market('NBP'), 3)
416	"""
417	self.assert_contract_value(specification, 30.20756, {'NBP': 3.02076}, expected_call_count=15)	×
418
419
420	class LongerTests(ContractValuationTestCase):	3✔
421
422	def test_value_swing_option(self):	3✔
423	specification = """	3✔
424	def Swing(start_date, end_date, underlying, quantity):
425	if (quantity != 0) and (start_date < end_date):
426	return Choice(
427	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, Market(underlying)),
428	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
429	)
430	else:
431	return 0
432
433	Swing(Date('2011-1-1'), Date('2011-1-5'), 'NBP', 3)
434	"""
435	self.assert_contract_value(specification, 30.2081, expected_call_count=15)	3✔
436
437	def _test_generate_valuation_power_plant_option(self):	3✔
438	specification = """	×
439	def PowerPlant(start_date, end_date, underlying, time_since_off):
440	if (start_date < end_date):
441	Choice(
442	PowerPlant(start_date + TimeDelta('1d'), end_date, underlying, 0) + ProfitFromRunning(start_date, underlying, time_since_off),
443	PowerPlant(start_date + TimeDelta('1d'), end_date, underlying, NextTime(time_since_off)),
444	)
445	else:
446	return 0
447
448	@nostub
449	def NextTime(time_since_off):
450	if time_since_off == 2:
451	return 2
452	else:
453	return time_since_off + 1
454
455	@nostub
456	def ProfitFromRunning(start_date, underlying, time_since_off):
457	if time_since_off == 0:
458	return Fixing(start_date, underlying)
459	elif time_since_off == 1:
460	return 0.9 * Fixing(start_date, underlying)
461	else:
462	return 0.8 * Fixing(start_date, underlying)
463
464	PowerPlant(Date('2012-01-01'), Date('2013-06-01'), Market('#1'), 30)
465	"""
466	self.assert_contract_value(specification, 48, expected_call_count=2067)	×
467
468
469	class SpecialTests(ContractValuationTestCase):	3✔
470
471	def test_simple_expression_with_market(self):	3✔
472	dsl = "Market('NBP') + 2 * Market('TTF')"	3✔
473	self.assert_contract_value(dsl, 32, {'NBP': 1, 'TTF': 2}, expected_call_count=1)	3✔
474
475	def test_simple_function_with_market(self):	3✔
476	dsl = """	3✔
477	def F():
478	Market('NBP') + 2 * Market('TTF')
479
480	F()
481	"""
482	self.assert_contract_value(dsl, 32, {'NBP': 1, 'TTF': 2}, expected_call_count=2)	3✔
483
484	def test_generate_valuation_swing_option(self):	3✔
485	specification = """	3✔
486	def Swing(start_date, end_date, underlying, quantity):
487	if (quantity != 0) and (start_date < end_date):
488	return Choice(
489	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity-1) + Fixing(start_date, underlying),
490	Swing(start_date + TimeDelta('1d'), end_date, underlying, quantity)
491	)
492	else:
493	return 0
494
495	Swing(Date('2011-01-01'), Date('2011-01-05'), Market('NBP'), 3)
496	"""
497	self.assert_contract_value(specification, 30.20756, {'NBP': 3.0207}, expected_call_count=15)	3✔
498	# self.assert_contract_value(specification, 30.20756, {}, expected_call_count=15)
499
500	def test_reuse_unperturbed_call_results(self):	3✔
501	specification = """	3✔
502	def SumTwoMarkets(market_name1, market_name2):
503	GetMarket(market_name1) + GetMarket(market_name2)
504
505	def GetMarket(market_name):
506	Market(market_name)
507
508	SumTwoMarkets('NBP', 'TTF')
509	"""
510	self.assert_contract_value(specification,	3✔
511	expected_value=21,
512	expected_deltas={'NBP': 1, 'TTF': 1},
513	expected_call_count=4,
514	)
515
516	def test_reuse_unperturbed_call_results2(self):	3✔
517	specification = """	3✔
518	def Swing(start_date, end_date, underlying, quantity):
519	if (quantity != 0) and (start_date < end_date):
520	return Choice(
521	Exercise(Swing, start_date, end_date, underlying, quantity),
522	Hold(Swing, start_date, end_date, underlying, quantity)
523	)
524	else:
525	return 0
526
527	@nostub
528	def Exercise(f, start_date, end_date, underlying, quantity):
529	return Hold(f, start_date, end_date, underlying, quantity - 1) + Fixing(start_date, underlying)
530
531	@nostub
532	def Hold(f, start_date, end_date, underlying, quantity):
533	return f(start_date + TimeDelta('1d'), end_date, underlying, quantity)
534
535	Swing(Date('2011-1-1'), Date('2011-1-4'), Market('#1'), 2) * 1 + \
536	Swing(Date('2011-1-1'), Date('2011-1-4'), Market('#2'), 2) * 2
537	"""
538	self.assert_contract_value(specification,	3✔
539	expected_call_count=19,
540	expected_value=60.4826,
541	expected_deltas={'#1': 2.0168, '#2': 4.0313},
542	)
543
544	class ExperimentalTests(ContractValuationTestCase):	3✔
545
546	def _test_simple_expression_with_market(self):	3✔
547	dsl = """	×
548	def Swing(start, end, step, market, quantity):
549	if (quantity != 0) and (start <= end):
550	Max(
551	HoldSwing(start, end, step, market, quantity),
552	ExerciseSwing(start, end, step, market, quantity, 1)
553	)
554	else:
555	0
556
557	@nostub
558	def HoldSwing(start, end, step, market, quantity):
559	On(start, Swing(start+step, end, step, market, quantity))
560
561	@nostub
562	def ExerciseSwing(start, end, step, market, quantity, vol):
563	Settlement(start, vol*market) + HoldSwing(start, end, step, market, quantity-vol)
564
565	Swing(Date('2011-01-01'), Date('2011-01-02'), TimeDelta('1d'), Market('NBP'), 1)
566	"""
567	self.assert_contract_value(dsl, 10, {'NBP': 1}, expected_call_count=6)	×
568
569	def test_value_swing_option_with_forward_markets(self):	3✔
570	specification = """	3✔
571	def Swing(start_date, end_date, quantity):
572	if (quantity != 0) and (start_date < end_date):
573	return Choice(
574	Swing(start_date + TimeDelta('1d'), end_date, quantity-1) + Fixing(start_date, ForwardMarket('NBP', start_date + TimeDelta('1d'))),
575	Swing(start_date + TimeDelta('1d'), end_date, quantity)
576	)
577	else:
578	return 0
579
580	Swing(Date('2011-01-01'), Date('2011-1-4'), 30)
581	"""
582	self.assert_contract_value(specification, 30.00, {'NBP-2011-01': 3.0}, expected_call_count=11)	3✔
583
584	def test_simple_forward_market(self):	3✔
585	specification = """ForwardMarket('NBP', '2012-1-1')"""	3✔
586	self.assert_contract_value(specification, 10.00, {'NBP-2012-01': 1.0}, expected_call_count=1)	3✔
587
588
589	class ContractValuationTests(	3✔
590	ExperimentalTests,
591	SpecialTests,
592	ExpressionTests,
593	FunctionTests,
594	LongerTests
595	): pass
596

johnbywater / quantdsl / 146

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous