Пример #1
0
        public void Convergence()
        {
            foreach (int qty in convergeQuantities)
            {
                IEnumerable <Quote>     h = History.GetHistoryLong(128 + qty);
                IEnumerable <AdxResult> r = Indicator.GetAdx(h);

                AdxResult l = r.LastOrDefault();
                Console.WriteLine("ADX on {0:d} with {1,4} periods: {2:N8}",
                                  l.Date, h.Count(), l.Adx);
            }
        }
Пример #2
0
    public void Adx()
    {
        foreach (int qty in QuotesQuantities)
        {
            IEnumerable <Quote>     quotes = TestData.GetLongish(qty);
            IEnumerable <AdxResult> r      = quotes.GetAdx(14);

            AdxResult l = r.LastOrDefault();
            Console.WriteLine(
                "ADX(14) on {0:d} with {1,4} historical quotes: {2:N8}",
                l.Date, quotes.Count(), l.Adx);
        }
    }
Пример #3
0
    public void Removed()
    {
        IEnumerable <AdxResult> r = quotes.GetAdx(14)
                                    .RemoveWarmupPeriods();

        // assertions
        Assert.AreEqual(502 - ((2 * 14) + 100), r.Count());

        AdxResult last = r.LastOrDefault();

        Assert.AreEqual(17.7565, Math.Round((double)last.Pdi, 4));
        Assert.AreEqual(31.1510, Math.Round((double)last.Mdi, 4));
        Assert.AreEqual(34.2987, Math.Round((double)last.Adx, 4));
    }
Пример #4
0
    public void Standard()
    {
        int lookbackPeriods      = 14;
        List <AdxResult> results = quotes.GetAdx(lookbackPeriods).ToList();

        // assertions

        // proper quantities
        // should always be the same number of results as there is quotes
        Assert.AreEqual(502, results.Count);
        Assert.AreEqual(475, results.Where(x => x.Adx != null).Count());
        Assert.AreEqual(462, results.Where(x => x.Adxr != null).Count());

        // sample values
        AdxResult r19 = results[19];

        Assert.AreEqual(21.0361, Math.Round((double)r19.Pdi, 4));
        Assert.AreEqual(25.0124, Math.Round((double)r19.Mdi, 4));
        Assert.AreEqual(null, r19.Adx);

        AdxResult r29 = results[29];

        Assert.AreEqual(37.9719, Math.Round((double)r29.Pdi, 4));
        Assert.AreEqual(14.1658, Math.Round((double)r29.Mdi, 4));
        Assert.AreEqual(19.7949, Math.Round((double)r29.Adx, 4));

        AdxResult r39 = results[39];

        Assert.IsNull(r29.Adxr);

        AdxResult r40 = results[40];

        Assert.AreEqual(29.1062, Math.Round((double)r40.Adxr, 4));

        AdxResult r248 = results[248];

        Assert.AreEqual(32.3167, Math.Round((double)r248.Pdi, 4));
        Assert.AreEqual(18.2471, Math.Round((double)r248.Mdi, 4));
        Assert.AreEqual(30.5903, Math.Round((double)r248.Adx, 4));
        Assert.AreEqual(29.1252, Math.Round((double)r248.Adxr, 4));

        AdxResult r501 = results[501];

        Assert.AreEqual(17.7565, Math.Round((double)r501.Pdi, 4));
        Assert.AreEqual(31.1510, Math.Round((double)r501.Mdi, 4));
        Assert.AreEqual(34.2987, Math.Round((double)r501.Adx, 4));
    }
        public void GetAdxTest()
        {
            int lookbackPeriod = 14;
            IEnumerable <AdxResult> results = Indicator.GetAdx(history, lookbackPeriod);

            // assertions

            // proper quantities
            // should always be the same number of results as there is history
            Assert.AreEqual(502, results.Count());
            Assert.AreEqual(502 - 2 * lookbackPeriod + 1, results.Where(x => x.Adx != null).Count());

            // sample value
            AdxResult r = results.Where(x => x.Index == 502).FirstOrDefault();

            Assert.AreEqual(17.7565m, Math.Round((decimal)r.Pdi, 4));
            Assert.AreEqual(31.1510m, Math.Round((decimal)r.Mdi, 4));
            Assert.AreEqual(34.2987m, Math.Round((decimal)r.Adx, 4));
        }
Пример #6
0
        public void GetAdxTest()
        {
            int lookbackPeriod = 14;
            IEnumerable <AdxResult> results = Indicator.GetAdx(history, lookbackPeriod);

            // assertions

            // proper quantities
            // should always be the same number of results as there is history
            Assert.AreEqual(502, results.Count());
            Assert.AreEqual(502 - 2 * lookbackPeriod + 1, results.Where(x => x.Adx != null).Count());

            // sample value
            AdxResult r = results.Where(x => x.Date == DateTime.ParseExact("12/31/2018", "MM/dd/yyyy", null)).FirstOrDefault();

            Assert.AreEqual((decimal)17.7565, Math.Round((decimal)r.Pdi, 4));
            Assert.AreEqual((decimal)31.1510, Math.Round((decimal)r.Mdi, 4));
            Assert.AreEqual((decimal)34.2987, Math.Round((decimal)r.Adx, 4));
        }
Пример #7
0
        public void Standard()
        {
            int lookbackPeriod       = 14;
            List <AdxResult> results = Indicator.GetAdx(history, lookbackPeriod).ToList();

            // assertions

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

            // sample values
            AdxResult r1 = results[19];

            Assert.AreEqual(21.0361m, Math.Round((decimal)r1.Pdi, 4));
            Assert.AreEqual(25.0124m, Math.Round((decimal)r1.Mdi, 4));
            Assert.AreEqual(null, r1.Adx);

            AdxResult r2 = results[29];

            Assert.AreEqual(37.9719m, Math.Round((decimal)r2.Pdi, 4));
            Assert.AreEqual(14.1658m, Math.Round((decimal)r2.Mdi, 4));
            Assert.AreEqual(19.7949m, Math.Round((decimal)r2.Adx, 4));

            AdxResult r3 = results[248];

            Assert.AreEqual(32.3167m, Math.Round((decimal)r3.Pdi, 4));
            Assert.AreEqual(18.2471m, Math.Round((decimal)r3.Mdi, 4));
            Assert.AreEqual(30.5903m, Math.Round((decimal)r3.Adx, 4));

            AdxResult r4 = results[501];

            Assert.AreEqual(17.7565m, Math.Round((decimal)r4.Pdi, 4));
            Assert.AreEqual(31.1510m, Math.Round((decimal)r4.Mdi, 4));
            Assert.AreEqual(34.2987m, Math.Round((decimal)r4.Adx, 4));
        }
Пример #8
0
        public void GetAdxTest()
        {
            int lookbackPeriod = 14;
            IEnumerable <AdxResult> results = Indicator.GetAdx(history, lookbackPeriod);

            // assertions

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

            // sample values
            AdxResult r1 = results.Where(x => x.Index == 502).FirstOrDefault();

            Assert.AreEqual(17.7565m, Math.Round((decimal)r1.Pdi, 4));
            Assert.AreEqual(31.1510m, Math.Round((decimal)r1.Mdi, 4));
            Assert.AreEqual(34.2987m, Math.Round((decimal)r1.Adx, 4));

            AdxResult r2 = results.Where(x => x.Index == 249).FirstOrDefault();

            Assert.AreEqual(32.3167m, Math.Round((decimal)r2.Pdi, 4));
            Assert.AreEqual(18.2471m, Math.Round((decimal)r2.Mdi, 4));
            Assert.AreEqual(30.5903m, Math.Round((decimal)r2.Adx, 4));

            AdxResult r3 = results.Where(x => x.Index == 20).FirstOrDefault();

            Assert.AreEqual(21.0361m, Math.Round((decimal)r3.Pdi, 4));
            Assert.AreEqual(25.0124m, Math.Round((decimal)r3.Mdi, 4));
            Assert.AreEqual(null, r3.Adx);

            AdxResult r4 = results.Where(x => x.Index == 30).FirstOrDefault();

            Assert.AreEqual(37.9719m, Math.Round((decimal)r4.Pdi, 4));
            Assert.AreEqual(14.1658m, Math.Round((decimal)r4.Mdi, 4));
            Assert.AreEqual(19.7949m, Math.Round((decimal)r4.Adx, 4));
        }