Example #1
0
    // STANDARD DEVIATION CHANNELS
    /// <include file='./info.xml' path='indicator/*' />
    ///
    public static IEnumerable <StdDevChannelsResult> GetStdDevChannels <TQuote>(
        this IEnumerable <TQuote> quotes,
        int?lookbackPeriods       = 20,
        double standardDeviations = 2)
        where TQuote : IQuote
    {
        // assume whole quotes when lookback is null
        if (lookbackPeriods is null)
        {
            lookbackPeriods = quotes.Count();
        }

        // check parameter arguments
        ValidateStdDevChannels(lookbackPeriods, standardDeviations);

        // initialize
        List <SlopeResult> slopeResults = GetSlope(quotes, (int)lookbackPeriods).ToList();

        int length = slopeResults.Count;
        List <StdDevChannelsResult> results = slopeResults
                                              .Select(x => new StdDevChannelsResult {
            Date = x.Date
        })
                                              .ToList();

        // roll through quotes in reverse
        for (int w = length - 1; w >= lookbackPeriods - 1; w -= (int)lookbackPeriods)
        {
            SlopeResult s     = slopeResults[w];
            decimal?    width = (decimal?)(standardDeviations * s.StdDev);

            // add regression line (y = mx + b) and channels
            for (int p = w - (int)lookbackPeriods + 1; p <= w; p++)
            {
                if (p >= 0)
                {
                    StdDevChannelsResult d = results[p];
                    d.Centerline   = (decimal?)((s.Slope * (p + 1)) + s.Intercept);
                    d.UpperChannel = d.Centerline + width;
                    d.LowerChannel = d.Centerline - width;

                    d.BreakPoint = p == w - lookbackPeriods + 1;
                }
            }
        }

        return(results);
    }
    public void Removed()
    {
        int    lookbackPeriods    = 20;
        double standardDeviations = 2;

        List <StdDevChannelsResult> results =
            quotes.GetStdDevChannels(lookbackPeriods, standardDeviations)
            .RemoveWarmupPeriods()
            .ToList();

        // assertions
        Assert.AreEqual(500, results.Count);
        StdDevChannelsResult last = results.LastOrDefault();

        Assert.AreEqual(235.8131m, Math.Round((decimal)last.Centerline, 4));
        Assert.AreEqual(257.6536m, Math.Round((decimal)last.UpperChannel, 4));
        Assert.AreEqual(213.9727m, Math.Round((decimal)last.LowerChannel, 4));
        Assert.IsFalse(last.BreakPoint);
    }
    public void FullHistory()
    {
        // null provided for lookback period

        List <StdDevChannelsResult> results =
            quotes.GetStdDevChannels(null, 2)
            .ToList();

        // assertions

        // proper quantities
        // should always be the same number of results as there is quotes
        Assert.AreEqual(502, results.Count);
        Assert.AreEqual(502, results.Where(x => x.Centerline != null).Count());
        Assert.AreEqual(502, results.Where(x => x.UpperChannel != null).Count());
        Assert.AreEqual(502, results.Where(x => x.LowerChannel != null).Count());
        Assert.AreEqual(501, results.Where(x => x.BreakPoint == false).Count());

        // sample value
        StdDevChannelsResult r1 = results[0];

        Assert.AreEqual(219.2605m, Math.Round((decimal)r1.Centerline, 4));
        Assert.AreEqual(258.7104m, Math.Round((decimal)r1.UpperChannel, 4));
        Assert.AreEqual(179.8105m, Math.Round((decimal)r1.LowerChannel, 4));
        Assert.IsTrue(r1.BreakPoint);

        StdDevChannelsResult r2 = results[249];

        Assert.AreEqual(249.3814m, Math.Round((decimal)r2.Centerline, 4));
        Assert.AreEqual(288.8314m, Math.Round((decimal)r2.UpperChannel, 4));
        Assert.AreEqual(209.9315m, Math.Round((decimal)r2.LowerChannel, 4));

        StdDevChannelsResult r3 = results[501];

        Assert.AreEqual(279.8653m, Math.Round((decimal)r3.Centerline, 4));
        Assert.AreEqual(319.3152m, Math.Round((decimal)r3.UpperChannel, 4));
        Assert.AreEqual(240.4153m, Math.Round((decimal)r3.LowerChannel, 4));
    }
    public void Standard()
    {
        int    lookbackPeriods    = 20;
        double standardDeviations = 2;

        List <StdDevChannelsResult> results =
            quotes.GetStdDevChannels(lookbackPeriods, standardDeviations)
            .ToList();

        // assertions

        // proper quantities
        // should always be the same number of results as there is quotes
        Assert.AreEqual(502, results.Count);
        Assert.AreEqual(500, results.Where(x => x.Centerline != null).Count());
        Assert.AreEqual(500, results.Where(x => x.UpperChannel != null).Count());
        Assert.AreEqual(500, results.Where(x => x.LowerChannel != null).Count());

        // sample value
        StdDevChannelsResult r1 = results[1];

        Assert.IsNull(r1.Centerline);
        Assert.IsNull(r1.UpperChannel);
        Assert.IsNull(r1.LowerChannel);
        Assert.IsFalse(r1.BreakPoint);

        StdDevChannelsResult r2 = results[2];

        Assert.AreEqual(213.7993m, Math.Round((decimal)r2.Centerline, 4));
        Assert.AreEqual(215.7098m, Math.Round((decimal)r2.UpperChannel, 4));
        Assert.AreEqual(211.8888m, Math.Round((decimal)r2.LowerChannel, 4));
        Assert.IsTrue(r2.BreakPoint);

        StdDevChannelsResult r3 = results[141];

        Assert.AreEqual(236.1744m, Math.Round((decimal)r3.Centerline, 4));
        Assert.AreEqual(240.4784m, Math.Round((decimal)r3.UpperChannel, 4));
        Assert.AreEqual(231.8704m, Math.Round((decimal)r3.LowerChannel, 4));
        Assert.IsFalse(r3.BreakPoint);

        StdDevChannelsResult r4 = results[142];

        Assert.AreEqual(236.3269m, Math.Round((decimal)r4.Centerline, 4));
        Assert.AreEqual(239.5585m, Math.Round((decimal)r4.UpperChannel, 4));
        Assert.AreEqual(233.0953m, Math.Round((decimal)r4.LowerChannel, 4));
        Assert.IsTrue(r4.BreakPoint);

        StdDevChannelsResult r5 = results[249];

        Assert.AreEqual(259.6044m, Math.Round((decimal)r5.Centerline, 4));
        Assert.AreEqual(267.5754m, Math.Round((decimal)r5.UpperChannel, 4));
        Assert.AreEqual(251.6333m, Math.Round((decimal)r5.LowerChannel, 4));
        Assert.IsFalse(r5.BreakPoint);

        StdDevChannelsResult r6 = results[482];

        Assert.AreEqual(267.9069m, Math.Round((decimal)r6.Centerline, 4));
        Assert.AreEqual(289.7473m, Math.Round((decimal)r6.UpperChannel, 4));
        Assert.AreEqual(246.0664m, Math.Round((decimal)r6.LowerChannel, 4));
        Assert.IsTrue(r6.BreakPoint);

        StdDevChannelsResult r7 = results[501];

        Assert.AreEqual(235.8131m, Math.Round((decimal)r7.Centerline, 4));
        Assert.AreEqual(257.6536m, Math.Round((decimal)r7.UpperChannel, 4));
        Assert.AreEqual(213.9727m, Math.Round((decimal)r7.LowerChannel, 4));
        Assert.IsFalse(r7.BreakPoint);
    }