Пример #1
0
        public void Test_DataRetrieval()
        {
            var ds = DataSourceFromBars.New("tiingo:msft");

            ds.LoadData(DateTime.Parse("01/01/2019"), DateTime.Parse("01/12/2019"));

            Assert.IsTrue(ds.Info[TuringTrader.Simulator.DataSourceParam.name].ToLower().Contains("microsoft"));
            Assert.IsTrue(((DateTime)ds.FirstTime).Date == DateTime.Parse("03/13/1986"));
            //Assert.IsTrue(((DateTime)ds.LastTime).Date == DateTime.Parse("01/11/2019"));
            Assert.IsTrue(ds.Data.Count() == 8);
            Assert.IsTrue(Math.Abs(ds.Data.Last().Close / ds.Data.First().Open - 102.36056 / 99.12445) < 1e-3);
        }
        public void Test_DataRetrieval()
        {
            var ds = DataSourceFromBars.New("fred:GDPC1");

            ds.LoadData(DateTime.Parse("09/30/2018"), DateTime.Parse("01/03/2019"));

            Assert.IsTrue(ds.Info[TuringTrader.Simulator.DataSourceParam.name].ToLower().Contains("real gross domestic product"));
            Assert.IsTrue(((DateTime)ds.FirstTime).Date == DateTime.Parse("01/01/1947"));
            //Assert.IsTrue(((DateTime)ds.LastTime).Date == DateTime.Parse("01/11/2019"));
            Assert.IsTrue(ds.Data.Count() == 64);
            Assert.IsTrue(Math.Abs(ds.Data.First().Open - 18765.256) < 1e-2);
            Assert.IsTrue(Math.Abs(ds.Data.Last().Close - 18912.326) < 1e-2);
        }
Пример #3
0
        public void Test_MarkowitzCLA()
        {
            // the instruments serves no function, other than as a key
            Dictionary <Instrument, int> instruments = Enumerable.Range(0, 10)
                                                       .ToDictionary(i =>
            {
                Dictionary <DataSourceParam, string> info = new Dictionary <DataSourceParam, string>
                {
                    { DataSourceParam.name, string.Format("X{0}", i) },
                    { DataSourceParam.nickName, string.Format("X{0}", i) },
                };
                var dataSource = new DataSourceFromBars(null, info);

                return(new Instrument(null, dataSource));
            },
                                                                     i => i);

            #region test vector #1 (William F. Sharpe)
            {
                // taken from https://web.stanford.edu/~wfsharpe/mia/opt/mia_opt3.htm
                double[] mean =
                {
                    2.8000,
                    6.3000,
                    10.8000
                };

                /*double[] sd =
                 * {   // from source above, translated to covar matrix
                 *  1.0000,
                 *  7.4000,
                 *  15.4000,
                 * };
                 *
                 * double[,] corr =
                 * {   // from source above, translated to covar matrix
                 *  { 1.0000, 0.4000, 0.1500 },
                 *  { 0.4000, 1.0000, 0.3500 },
                 *  { 0.1500, 0.3500, 1.0000 },
                 * };*/

                double[,] covar =
                {   // from lequant40, should equal sd and corr above
                    {    1,   2.96,   2.31 },
                    { 2.96,  54.76, 39.886 },
                    { 2.31, 39.886, 237.16 },
                };

                double[,] expectedWeights =
                {   // => from source above
                    {                 0.2, 0.30000000000000004,                 0.5 },
                    {                 0.2,                 0.5, 0.30000000000000004 },
                    { 0.22180737780348653,                 0.5, 0.27819262219651353 },
                    {   0.451915610952186,   0.348084389047814,                 0.2 },
                    {                 0.5,  0.2999999999999999,                 0.2 },
                };

                /* double[] expectedIDontKnow =
                 * {   // from lequant40
                 *  20.898844444444443,
                 *  11.1475,
                 *  10.51088812347172,
                 *  7.55192170004087,
                 *  0,
                 * };*/

                /* double[] expectedRiskTolerance =
                 * {   // => see source above, unclear how this is calculated
                 *  41.80,
                 *  22.94,
                 *  22.30,
                 *  21.02,
                 *  15.10,
                 *  13.73,
                 * };*/

                double[] expectedReturn =
                {   // added by FUB
                    7.85,
                    6.95000000000006,
                    6.77554097757211,
                    5.61829536166734,
                    5.45,
                };

                double[] expectedRisk =
                {   // added by FUB
                    8.77732305432584,
                    6.92166165021094,
                    6.64310912002921,
                    4.81952189552386,
                    4.56082448686638,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(3),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => 0.2,
                    i => 0.5);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                                               - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    Assert.IsTrue(Math.Abs(turningPoint.Risk
                                           - expectedRisk[i]) < 1e-5);

                    Assert.IsTrue(Math.Abs(turningPoint.Return
                                           - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region test vector #2 (H. Markowitz)
            {
                // Reference: Portfolio Selection, H. Markowitz example, chapter VIII "The computing procedure"
                double[] mean =
                {
                    0.062,
                    0.146,
                    0.128
                };

                double[,] covar =
                {
                    { 0.0146, 0.0187, 0.0145 },
                    { 0.0187, 0.0854, 0.0104 },
                    { 0.0145, 0.0104, 0.0289 },
                };

                double[,] expectedWeights =
                {
                    {                  0,                   1,                    0 },
                    {                  0, 0.22496808316614988,   0.7750319168338501 },
                    { 0.8414051841746248,                   0,  0.15859481582537516 },
                    { 0.9931034482758623,                   0, 0.006896551724137813 },
                };

                /* double[] expectedIDontKnow =
                 * {
                 *  4.16666666666667,
                 *  0.1408064320019454,
                 *  0.03332764893133244,
                 *  0,
                 * };*/

                double[] expectedReturn =
                {
                    0.146,
                    0.132049425496991,
                    0.0724672578444748,
                    0.0624551724137931,
                };

                double[] expectedRisk =
                {
                    0.292232783924048,
                    0.159085749259056,
                    0.122200612163491,
                    0.120827605888835,
                };


                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(3),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => 0.0,
                    i => 1.0);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                                               - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    Assert.IsTrue(Math.Abs(turningPoint.Risk
                                           - expectedRisk[i]) < 1e-5);

                    Assert.IsTrue(Math.Abs(turningPoint.Return
                                           - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region test vector #3 (Clarence C. Kwan)
            {
                // Reference: A Simple Spreadsheet-Based Exposition of the Markowitz Critical Line Method for Portfolio Selection, Clarence C. Kwan
                double[] mean =
                {
                    0.05,
                    0.08,
                    0.12
                };

                double[,] covar =
                {
                    { 0.0004, 0.0004, 0.0002 },
                    { 0.0004, 0.0025,  0.001 },
                    { 0.0002,  0.001,   0.01 },
                };

                double[,] expectedWeights =
                {
                    {                  0,                  0,                   1 },
                    {                  0, 0.6485013623978204,  0.3514986376021796 },
                    //{ 0.9754098360655736, 0, 0.024590163934426246 }, // FUB removed
                    { 0.9799999999999999,                  0, 0.02000000000000001 },
                };

                /* double[] expectedIDontKnow =
                 * {
                 *  0.22500000000000006,
                 *  0.05476839237057218,
                 *  0.0006557377049180337,
                 *  0,
                 * };*/

                double[] expectedReturn =
                {
                    0.12,
                    0.0940599455040872,
                    0.0514,
                };

                double[] expectedRisk =
                {
                    0.1,
                    0.052371677991768,
                    0.0198997487421324,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(3),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => 0.0,
                    i => 1.0);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                                               - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    Assert.IsTrue(Math.Abs(turningPoint.Risk
                                           - expectedRisk[i]) < 1e-5);

                    Assert.IsTrue(Math.Abs(turningPoint.Return
                                           - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region test vector #4 (Clarence C. Kwan)
            {
                // Reference: A Simple Spreadsheet-Based Exposition of the Markowitz Critical Line Method for Portfolio Selection, Clarence C. Kwan
                double[] mean =
                {
                    0.05,
                    0.08,
                    0.12
                };

                double[,] covar =
                {
                    { 0.0004, 0.0004, 0.0002 },
                    { 0.0004, 0.0025,  0.001 },
                    { 0.0002,  0.001,   0.01 },
                };

                double[,] expectedWeights =
                {
                    {   0, 0.30000000000000004,                 0.7 },
                    {   0,  0.6485013623978203,  0.3514986376021798 },
                    //{ 0.7, 0.18310626702997274, 0.11689373297002724 }, // FUB removed
                    { 0.7,  0.2438095238095238, 0.05619047619047619 },
                };

                /* double[] expectedIDontKnow =
                 * {
                 * 0.14625
                 * 0.05476839237057221
                 * 0.015934604904632152
                 * 0
                 * };*/

                double[] expectedReturn =
                {   // FUB
                    0.108,
                    0.094059945504087,
                    0.061247619047619,
                };

                double[] expectedRisk =
                {   // FUB
                    0.0744647567645259,
                    0.0523716779917679,
                    0.0235764208277597,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(3),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => 0.0,
                    i => 0.7);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                                               - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    Assert.IsTrue(Math.Abs(turningPoint.Risk
                                           - expectedRisk[i]) < 1e-5);

                    Assert.IsTrue(Math.Abs(turningPoint.Return
                                           - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region test vector #5 (David H. Bailey, Marcos Lopez de Prado)
            {
                // Reference: An Open-Source Implementation of the Critical-Line Algorithm for Portfolio Optimization, David H. Bailey and Marcos Lopez de Prado
                // section 5, A Numerical Example
                double[] mean =
                {
                    1.175,
                    1.19,
                    0.396,
                    1.12,
                    0.346,
                    0.679,
                    0.089,
                    0.73,
                    0.481,
                    1.08
                };

                double[,] covar =
                {
                    { 0.40755159, 0.03175842, 0.05183923, 0.05663904,  0.0330226, 0.00827775, 0.02165938, 0.01332419,  0.0343476, 0.02249903 },
                    { 0.03175842,  0.9063047, 0.03136385, 0.02687256, 0.01917172, 0.00934384, 0.02495043, 0.00761036, 0.02874874, 0.01336866 },
                    { 0.05183923, 0.03136385, 0.19490901, 0.04408485, 0.03006772, 0.01322738, 0.03525971,  0.0115493,  0.0427563, 0.02057303 },
                    { 0.05663904, 0.02687256, 0.04408485, 0.19528471, 0.02777345, 0.00526665, 0.01375808, 0.00780878, 0.02914176, 0.01640377 },
                    {  0.0330226, 0.01917172, 0.03006772, 0.02777345, 0.34059105, 0.00777055, 0.02067844, 0.00736409, 0.02542657, 0.01284075 },
                    { 0.00827775, 0.00934384, 0.01322738, 0.00526665, 0.00777055, 0.15983874, 0.02105575, 0.00518686, 0.01723737, 0.00723779 },
                    { 0.02165938, 0.02495043, 0.03525971, 0.01375808, 0.02067844, 0.02105575, 0.68056711, 0.01377882, 0.04627027, 0.01926088 },
                    { 0.01332419, 0.00761036,  0.0115493, 0.00780878, 0.00736409, 0.00518686, 0.01377882, 0.95526918,  0.0106553, 0.00760955 },
                    {  0.0343476, 0.02874874,  0.0427563, 0.02914176, 0.02542657, 0.01723737, 0.04627027,  0.0106553, 0.31681584, 0.01854318 },
                    { 0.02249903, 0.01336866, 0.02057303, 0.01640377, 0.01284075, 0.00723779, 0.01926088, 0.00760955, 0.01854318, 0.11079287 },
                };

                double[,] expectedWeights =
                {
                    {                   0,                    1,                    0,                   0,                    0,                   0,                    0,                    0,                    0,                   0 },
                    {  0.6493694070931811,   0.3506305929068189,                    0,                   0,                    0,                   0,                    0,                    0,                    0,                   0 },
                    {  0.4339841341086239,  0.23124750065448754,                    0,   0.334768365236889,                    0,                   0,                    0,                    0,                    0,                   0 },
                    { 0.12688785385570883,  0.07234334721032556,                    0, 0.28125374926334057,                    0,                   0,                    0,                    0,                    0,  0.5195150496706249 },
                    { 0.12320100405906734,  0.07044407130753655,                    0,  0.2789935668090118,                    0,                   0,                    0, 0.006435564362887149,                    0,  0.5209257934614971 },
                    {  0.0869215492990579, 0.050451042268558385,                    0, 0.22359401742288823,                    0, 0.17383161507156486,                    0,  0.03017301555135618,                    0,  0.4350287603865743 },
                    {  0.0846709411996219, 0.049253858741118525,                    0, 0.21963390336360733,                    0, 0.18003923464176064,                    0,  0.03102980185535347, 0.006485702415438152, 0.42888655778310003 },
                    { 0.07378925302280315, 0.043828660769718863,                    0, 0.19897560805881487, 0.026158159857441972, 0.19815187227970524,                    0,  0.03341958639919798, 0.027902966026643668,  0.3977738935856743 },
                    { 0.06834400480527462, 0.041387026820649334, 0.015215259551836627, 0.18813443107045838,  0.03416248599274816, 0.20231943214747125,                    0,   0.0339293235595669,  0.03363264959172938, 0.38287538646026537 },
                    { 0.03696858147921504,  0.02690083780081047,   0.0949424305647986,  0.1257759521946726,   0.0767460810325476, 0.21935567131616898, 0.029987096882220312, 0.035963284621386274,  0.06134983772972688, 0.29201022637845325 },
                };

                /* double[] expectedIDontKnow =
                 * {
                 * 58.30308533333371
                 * 4.1742728458857385
                 * 1.9455661414558894
                 * 0.16458117494477595
                 * 0.1473887508934171
                 * 0.056172204002751545
                 * 0.05204819067458028
                 * 0.03652161374727064
                 * 0.030971168861678777
                 * 0
                 * };*/

                double[] expectedReturn =
                {   // Table 2
                    1.18999999999995,
                    1.1802594588936,
                    1.16005645242179,
                    1.11126226427996,
                    1.10836023837479,
                    1.02248388944319,
                    1.01530592052246,
                    0.972720434034985,
                    0.949936815755027,
                    0.803215359876534,
                };

                double[] expectedRisk =
                {   // Table 2
                    0.952000367646947,
                    0.545656874268239,
                    0.41725565037332,
                    0.266719614211323,
                    0.265016995301471,
                    0.229680073596095,
                    0.22798274842085,
                    0.219554880082679,
                    0.216024571686891,
                    0.205237619813865,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(10),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => 0.0,
                    i => 1.0);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                                               - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    Assert.IsTrue(Math.Abs(turningPoint.Risk
                                           - expectedRisk[i]) < 1e-5);

                    Assert.IsTrue(Math.Abs(turningPoint.Return
                                           - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region vector #6 (FUB, MarkowitzCLA: aborted after 201 iterations)
            {
                double[] mean =
                {
                    1.924775229385712E-001,
                    3.047470098437341E-002,
                    3.600448981380029E-002,
                    1.771499702814230E-002
                };
                double[,] covar =
                {
                    { 5.173614384902067E-003,  5.563709795663105E-003,  6.879256076222439E-005, 1.046411951839147E-006, },
                    { 5.563709795663105E-003,  1.192747981284741E-002, -2.159113135212455E-004, 8.210747330824326E-006, },
                    { 6.879256076222439E-005, -2.159113135212455E-004,  3.263193293253446E-004, 8.122710323505884E-006, },
                    { 1.046411951839147E-006,  8.210747330824326E-006,  8.122710323505884E-006, 8.273639320440565E-007, },
                };
                double[] lbound =
                {
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                };
                double[] ubound =
                {
                    7.500000000000000E-001,
                    3.000000000000000E-001,
                    1.000000000000000E+000,
                    1.000000000000000E+000,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(mean.Count()),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => lbound[instruments[i]],
                    i => ubound[instruments[i]]);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        //Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                        //    - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    //Assert.IsTrue(Math.Abs(turningPoint.Risk
                    //    - expectedRisk[i]) < 1e-5);

                    //Assert.IsTrue(Math.Abs(turningPoint.Return
                    //    - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion
            #region vector #6 (FUB, MarkowitzCLA: aborted after 601 iterations)
            {
                double[] mean =
                {
                    -1.452452351127411E+000,
                    -1.790134620283237E+000,
                    -1.748238206213537E+000,
                    2.763028800375313E-001,
                    1.219050250899282E-001,
                    -2.371535989891006E+000,
                    -2.362385628920209E+000,
                    -4.345226550223316E-001,
                    -1.917733811334479E+000,
                    -1.886615646689930E+000,
                    -1.016593945085099E+000,
                    -2.180839753535210E+000,
                };
                double[,] covar =
                {
                    {  4.107667557689510E-001,  3.532770338212708E-001,  3.920114515455653E-001, -6.397854059553235E-002, -2.342593174622205E-002,  6.235865058863653E-001,  5.103235914057721E-001,  5.769579319939092E-002,  4.637175699581909E-001,  2.234971094290169E-001,  3.931823752513509E-001,  4.236514050136496E-001, },
                    {  3.532770338212708E-001,  3.304477192804682E-001,  3.452738727085928E-001, -6.222848366575079E-002, -2.751843965308908E-002,  5.748535972479941E-001,  4.692451254532845E-001,  3.967304767223456E-002,  4.054424818170270E-001,  1.997384020454393E-001,  3.323921922263131E-001,  3.411631700478977E-001, },
                    {  3.920114515455653E-001,  3.452738727085928E-001,  4.317189033893861E-001, -7.400102899188042E-002, -2.850117040169742E-002,  6.039546143920506E-001,  5.630294416931898E-001,  2.936752803539871E-002,  4.389400300421475E-001,  1.982114609578972E-001,  3.294655288657495E-001,  4.162231314394415E-001, },
                    { -6.397854059553235E-002, -6.222848366575079E-002, -7.400102899188042E-002,  4.770878570857436E-002,  2.335142331965847E-002, -1.189553139504919E-001, -1.106745510298056E-001, -1.269822420551352E-002, -7.111001726644241E-002, -3.499608798785736E-002, -5.336890446270736E-002, -6.281607416760732E-002, },
                    { -2.342593174622205E-002, -2.751843965308908E-002, -2.850117040169742E-002,  2.335142331965847E-002,  1.452926950496856E-002, -5.995475036431692E-002, -4.293730406468507E-002, -8.729972561009053E-003, -2.665821670530143E-002, -1.524705100923784E-002, -1.997829761215913E-002, -2.015972460232533E-002, },
                    {  6.235865058863653E-001,  5.748535972479941E-001,  6.039546143920506E-001, -1.189553139504919E-001, -5.995475036431692E-002,  1.221232689432789E+000,  8.118393849671881E-001,  1.019587546988631E-001,  7.579084955172553E-001,  3.448708981352991E-001,  6.186443380390989E-001,  6.503743963305754E-001, },
                    {  5.103235914057721E-001,  4.692451254532845E-001,  5.630294416931898E-001, -1.106745510298056E-001, -4.293730406468507E-002,  8.118393849671881E-001,  8.447658647509614E-001,  7.376862934900393E-002,  5.941244050822955E-001,  2.682387280553992E-001,  4.306022120966404E-001,  5.040965017479671E-001, },
                    {  5.769579319939092E-002,  3.967304767223456E-002,  2.936752803539871E-002, -1.269822420551352E-002, -8.729972561009053E-003,  1.019587546988631E-001,  7.376862934900393E-002,  1.836339363503214E-001,  8.670894228186039E-002,  8.068006861263177E-002,  8.570350597393994E-002,  4.944293677683691E-002, },
                    {  4.637175699581909E-001,  4.054424818170270E-001,  4.389400300421475E-001, -7.111001726644241E-002, -2.665821670530143E-002,  7.579084955172553E-001,  5.941244050822955E-001,  8.670894228186039E-002,  5.672084581519490E-001,  2.681297372418839E-001,  4.554381142124682E-001,  4.934809498023794E-001, },
                    {  2.234971094290169E-001,  1.997384020454393E-001,  1.982114609578972E-001, -3.499608798785736E-002, -1.524705100923784E-002,  3.448708981352991E-001,  2.682387280553992E-001,  8.068006861263177E-002,  2.681297372418839E-001,  1.820220307339481E-001,  2.240698610401698E-001,  2.150697944198728E-001, },
                    {  3.931823752513509E-001,  3.323921922263131E-001,  3.294655288657495E-001, -5.336890446270736E-002, -1.997829761215913E-002,  6.186443380390989E-001,  4.306022120966404E-001,  8.570350597393994E-002,  4.554381142124682E-001,  2.240698610401698E-001,  4.827661636654928E-001,  4.158546001993272E-001, },
                    {  4.236514050136496E-001,  3.411631700478977E-001,  4.162231314394415E-001, -6.281607416760732E-002, -2.015972460232533E-002,  6.503743963305754E-001,  5.040965017479671E-001,  4.944293677683691E-002,  4.934809498023794E-001,  2.150697944198728E-001,  4.158546001993272E-001,  5.559629287257121E-001, },
                };
                double[] lbound =
                {
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                };
                double[] ubound =
                {
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    3.000000000000000E-001,
                    1.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                    0.000000000000000E+000,
                };

                var cla = new TuringTrader.Support.PortfolioSupport.MarkowitzCLA(
                    instruments.Keys.Take(mean.Count()),
                    i => mean[instruments[i]],
                    (i, j) => covar[instruments[i], instruments[j]],
                    i => lbound[instruments[i]],
                    i => ubound[instruments[i]]);

                var turningPoints = cla.TurningPoints().ToList();

                for (int i = 0; i < turningPoints.Count(); i++)
                {
                    var turningPoint = turningPoints[i];

                    foreach (var j in turningPoint.Weights.Keys)
                    {
                        //Assert.IsTrue(Math.Abs(turningPoint.Weights[j]
                        //    - expectedWeights[i, instruments[j]]) < 1e-5);
                    }

                    //Assert.IsTrue(Math.Abs(turningPoint.Risk
                    //    - expectedRisk[i]) < 1e-5);

                    //Assert.IsTrue(Math.Abs(turningPoint.Return
                    //    - expectedReturn[i]) < 1e-5);
                }
            }
            #endregion

            // TODO: random test, w/ target volatility or target return

            /*
             *  var covMat =[[0.0146, 0.0187, 0.0145],
             *                          [0.0187, 0.0854, 0.0104],
             *                          [0.0145, 0.0104, 0.0289]];
             *  var returns = [0.062, 0.146, 0.128];
             */
        }
Пример #4
0
        public void Test_PriceAndGreeks()
        {
            List <TestVector> testVectors = new List <TestVector>
            {
                new TestVector
                {
                    quoteDate      = DateTime.Parse("10/01/2015"),
                    underlyingLast = 1921.42,
                    riskFreeRate   = 0.024, dividendYield = 0.00, //0.018,
                    expiration     = DateTime.Parse("10/16/2015"),
                    strike         = 1845, isPut = false, bid = 85.80, ask = 90.00,
                    // impliedVol = 0.2538, delta = 0.798, gamma = 0.0029, theta = -351.149, vega = 107.226 // from historical data
                    impliedVol = 0.23699109, delta = 0.81315737, gamma = 0.00291045, theta = -337.13293066, vega = 104.57753610
                },
                new TestVector
                {
                    quoteDate      = DateTime.Parse("10/01/2015"),
                    underlyingLast = 1921.42,
                    riskFreeRate   = 0.024, dividendYield = 0.00, //0.018,
                    expiration     = DateTime.Parse("10/16/2015"),
                    strike         = 1980, isPut = false, bid = 6.80, ask = 8.20,
                    // impliedVol = 0.177, delta = 0.2018, gamma = 0.0042, theta = -242.777, vega = 107.183 // from historical data
                    impliedVol = 0.17021597, delta = 0.20473715, gamma = 0.00428357, theta = -238.35915581, vega = 110.54824762
                },
                new TestVector
                {
                    quoteDate      = DateTime.Parse("10/01/2015"),
                    underlyingLast = 1921.42,
                    riskFreeRate   = 0.024, dividendYield = 0.00, //0.018,
                    expiration     = DateTime.Parse("10/16/2015"),
                    strike         = 1845, isPut = true, bid = 9.40, ask = 11.60,
                    // impliedVol = 0.2472, delta = -0.1961, gamma = 0.0029, theta = -330.323, vega = 105.344 // from historical data
                    impliedVol = 0.24491080, delta = -0.19423270, gamma = 0.00288422, theta = -310.13506432, vega = 107.09810115
                },
                new TestVector
                {
                    quoteDate      = DateTime.Parse("10/01/2015"),
                    underlyingLast = 1921.42,
                    riskFreeRate   = 0.024, dividendYield = 0.00, //0.018,
                    expiration     = DateTime.Parse("10/16/2015"),
                    strike         = 1980, isPut = true, bid = 63.20, ask = 67.90,
                    // impliedVol = 0.1734, delta = -0.8032, gamma = 0.0042, theta = -227.891, vega = 105.562 // from historical data
                    impliedVol = 0.18275260, delta = -0.77809756, gamma = 0.00418151, theta = -220.34075530, vega = 115.86234498
                },
                new TestVector
                {
                    quoteDate      = DateTime.Parse("01/04/2016"),
                    underlyingLast = 1993.680054,
                    riskFreeRate   = 0.024, dividendYield = 0.00,
                    expiration     = DateTime.Parse("02/26/2016"),
                    strike         = 300, isPut = false, bid = 1695.00, ask = 1695.00,
                    //impliedVol = 1.9811, delta = 0.9973, gamma = 0.000004, theta = -0.064148, vega = 0.047015 // from historical data
                    impliedVol = 1.72686453, delta = 0.99934408, gamma = 0.00000174, theta = -17.45819022, vega = 1.73456198
                },
            };

            foreach (var testVector in testVectors)
            {
                //--- create data source for underlying
                Dictionary <DataSourceParam, string> underlyingInfos = new Dictionary <DataSourceParam, string>
                {
                    { DataSourceParam.name, "S&P 500 Index" }
                };

                List <Bar> underlyingBars = new List <Bar>
                {
                    new Bar(
                        "SPX", testVector.quoteDate,
                        testVector.underlyingLast, testVector.underlyingLast, testVector.underlyingLast, testVector.underlyingLast, 100, true,
                        default(double), default(double), default(long), default(long), false,
                        default(DateTime), default(double), default(bool))
                };
                DataSource underlyingDataSource = new DataSourceFromBars(underlyingBars, underlyingInfos);

                //--- create data source for option
                Dictionary <DataSourceParam, string> optionInfos = new Dictionary <DataSourceParam, string>
                {
                    { DataSourceParam.name, "S&P 500 Index Options" },
                    { DataSourceParam.optionUnderlying, "SPX" }
                };
                List <Bar> optionBars = new List <Bar>
                {
                    new Bar(
                        "SPX_Option", testVector.quoteDate,
                        default(double), default(double), default(double), default(double), default(long), false,
                        testVector.bid, testVector.ask, 100, 100, true,
                        testVector.expiration, testVector.strike, testVector.isPut)
                };
                DataSource optionDataSource = new DataSourceFromBars(optionBars, optionInfos);

                //--- run test
                TuringTrader.Simulator.SimulatorCore callSim = new TestSimulator(
                    new List <DataSource> {
                    underlyingDataSource, optionDataSource
                },
                    testVector.riskFreeRate, testVector.dividendYield,
                    testVector.impliedVol, testVector.delta, testVector.gamma, testVector.theta, testVector.vega
                    );
            }
        }