コード例 #1
0
        public void bestShouldBeBuyAndHoldOnLoss()
        {
            MockTimeSeries    series       = new MockTimeSeries(6.0M, 3.0M, 6.0M, 6.0M);
            TimeSeriesManager manager      = new TimeSeriesManager(series);
            IStrategy         bestStrategy = new TotalProfitCriterion().ChooseBest(manager, strategies);

            Assert.AreEqual(buyAndHoldStrategy, bestStrategy);
        }
コード例 #2
0
        public void bestShouldBeAlwaysOperateOnProfit()
        {
            MockTimeSeries    series       = new MockTimeSeries(6.0M, 9.0M, 6.0M, 6.0M);
            TimeSeriesManager manager      = new TimeSeriesManager(series);
            IStrategy         bestStrategy = new TotalProfitCriterion().ChooseBest(manager, strategies);

            Assert.AreEqual(alwaysStrategy, bestStrategy);
        }
コード例 #3
0
        public void setUp()
        {
            ITimeSeries mockSeries = new MockTimeSeries(
                29.49M, 28.30M, 27.74M, 27.65M, 27.60M, 28.70M, 28.60M,
                28.19M, 27.40M, 27.20M, 27.28M, 27.00M, 27.59M, 26.20M,
                25.75M, 24.75M, 23.33M, 24.45M, 24.25M, 25.02M, 23.60M,
                24.20M, 24.28M, 25.70M, 25.46M, 25.10M, 25.00M, 25.00M,
                25.85M);

            seriesManager = new TimeSeriesManager(mockSeries);
            closePrice    = new ClosePriceIndicator(mockSeries);
        }
コード例 #4
0
 private void ButtonLoad_Click(object sender, EventArgs e)
 {
     if (TSP == null)
     {
         TSP = new TimeSeriesManager(Fiat, Frequency,
                                     useKraken: false, useInternet: true,
                                     view: this);
         CryptoPresenter = new Presenter(this, TSP);
     }
     CryptoPresenter.Update(Fiat, Frequency, useLowerFrequencies: false);
     Loaded = true;
 }
コード例 #5
0
        /**
         * @param manager the time series manager
         * @param strategies a list of strategies
         * @return the best strategy (among the provided ones) according to the criterion
         */
        public IStrategy ChooseBest(TimeSeriesManager manager, List <IStrategy> strategies)
        {
            IStrategy bestStrategy       = strategies[0];
            decimal   bestCriterionValue = Calculate(manager.TimeSeries, manager.Run(bestStrategy));

            for (int i = 1; i < strategies.Count; i++)
            {
                IStrategy currentStrategy       = strategies[i];
                decimal   currentCriterionValue = Calculate(manager.TimeSeries, manager.Run(currentStrategy));

                if (BetterThan(currentCriterionValue, bestCriterionValue))
                {
                    bestStrategy       = currentStrategy;
                    bestCriterionValue = currentCriterionValue;
                }
            }
            return(bestStrategy);
        }
コード例 #6
0
        public void setUp()
        {
            seriesForRun = new MockTimeSeries(
                new decimal[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 },
                new DateTime[] {
                DateTime.Parse("2013-01-01T00:00:00-05:00"),
                DateTime.Parse("2013-08-01T00:00:00-05:00"),
                DateTime.Parse("2013-10-01T00:00:00-05:00"),
                DateTime.Parse("2013-12-01T00:00:00-05:00"),
                DateTime.Parse("2014-02-01T00:00:00-05:00"),
                DateTime.Parse("2015-01-01T00:00:00-05:00"),
                DateTime.Parse("2015-08-01T00:00:00-05:00"),
                DateTime.Parse("2015-10-01T00:00:00-05:00"),
                DateTime.Parse("2015-12-01T00:00:00-05:00")
            });
            manager = new TimeSeriesManager(seriesForRun);

            strategy = new BaseStrategy(new FixedRule(0, 2, 3, 6), new FixedRule(1, 4, 7, 8));
            strategy.SetUnstablePeriod(2); // Strategy would need a real test class
        }