Пример #1
0
        public void Convergence()
        {
            foreach (int qty in convergeQuantities)
            {
                IEnumerable <Quote>      h = HistoryTestData.GetLong(50 + qty);
                IEnumerable <MamaResult> r = Indicator.GetMama(h);

                MamaResult l = r.LastOrDefault();
                Console.WriteLine("MAMA on {0:d} with {1,4} periods: {2:N8}",
                                  l.Date, h.Count(), l.Mama);
            }
        }
Пример #2
0
        public void GetMamaConvergence()
        {
            foreach (int qty in convergeQuantities.Where(q => q >= 50))
            {
                IEnumerable <Quote>      h = History.GetHistoryLong(qty);
                IEnumerable <MamaResult> r = Indicator.GetMama(h);

                MamaResult l = r.LastOrDefault();
                Console.WriteLine("MAMA on {0:d} with {1,4} periods of history: {2:N8}",
                                  l.Date, h.Count(), l.Mama);
            }
        }
Пример #3
0
    public void Mama()
    {
        foreach (int qty in QuotesQuantities)
        {
            IEnumerable <Quote>      quotes = TestData.GetLongish(qty);
            IEnumerable <MamaResult> r      = quotes.GetMama();

            MamaResult l = r.LastOrDefault();
            Console.WriteLine(
                "MAMA on {0:d} with {1,4} periods: {2:N8}",
                l.Date, quotes.Count(), l.Mama);
        }
    }
Пример #4
0
        public void Standard()
        {
            decimal fastLimit = 0.5m;
            decimal slowLimit = 0.05m;

            List <MamaResult> results = history.GetMama(fastLimit, slowLimit)
                                        .ToList();

            // assertions

            // proper quantities
            // should always be the same number of results as there is history
            Assert.AreEqual(502, results.Count);
            Assert.AreEqual(497, results.Where(x => x.Mama != null).Count());

            // sample values
            MamaResult r1 = results[4];

            Assert.AreEqual(null, r1.Mama);
            Assert.AreEqual(null, r1.Fama);

            MamaResult r2 = results[5];

            Assert.AreEqual(213.73m, r2.Mama);
            Assert.AreEqual(213.73m, r2.Fama);

            MamaResult r3 = results[6];

            Assert.AreEqual(213.7850m, Math.Round((decimal)r3.Mama, 4));
            Assert.AreEqual(213.7438m, Math.Round((decimal)r3.Fama, 4));

            MamaResult r4 = results[25];

            Assert.AreEqual(215.9524m, Math.Round((decimal)r4.Mama, 4));
            Assert.AreEqual(215.1407m, Math.Round((decimal)r4.Fama, 4));

            MamaResult r5 = results[149];

            Assert.AreEqual(235.6593m, Math.Round((decimal)r5.Mama, 4));
            Assert.AreEqual(234.3660m, Math.Round((decimal)r5.Fama, 4));

            MamaResult r6 = results[249];

            Assert.AreEqual(256.8026m, Math.Round((decimal)r6.Mama, 4));
            Assert.AreEqual(254.0605m, Math.Round((decimal)r6.Fama, 4));

            MamaResult r7 = results[501];

            Assert.AreEqual(244.1092m, Math.Round((decimal)r7.Mama, 4));
            Assert.AreEqual(252.6139m, Math.Round((decimal)r7.Fama, 4));
        }
Пример #5
0
    public void Removed()
    {
        double fastLimit = 0.5;
        double slowLimit = 0.05;

        List <MamaResult> results = quotes.GetMama(fastLimit, slowLimit)
                                    .RemoveWarmupPeriods()
                                    .ToList();

        // assertions
        Assert.AreEqual(502 - 50, results.Count);

        MamaResult last = results.LastOrDefault();

        Assert.AreEqual(244.1092m, Math.Round((decimal)last.Mama, 4));
        Assert.AreEqual(252.6139m, Math.Round((decimal)last.Fama, 4));
    }