程序员的量化交易（34）--QuantConnect_Lean如何定义Indicator指标2

转载需注明出处：http://blog.csdn.net/minimicall，http://cloudtrade.top/

指标（Indicator）由三大关键组件组成：

1. 实现你指标的类

2. 在ACAlgorithm基类中的Helper方法，用于简化对你指标实现的调用。

3. 测试方法用于测试指标的表现。

为了实现一个指标，上述所有组件需要实现。下面的教程会带你浏览这些组件。我们将会使用  AroonOscillator作为案例。我们不会去介绍指标的基本概念。

1. 实现你的指标（Implementing Your Indicator）

你的指标类应该在工程根下的QuantConnect.Indicators项目下实现。它必须是一个单独的类，不能缩写，名如“AroonOscillator.cs”。

第一步

指标必须是下面指标基类的一个派生：

Indicator – 如果你的指标只需要单个值（例如ExponontialMovingAverage），你就可以用Indicator作为基类。

TradeBarIndicator – 如果你的指标需要用到TradeBars，那么你的指标必须是由TradeBarIndicator类扩展而来的。（例如AroonOscillator）。

WindowIndicator<T> - 如果你的指标需要一个rolling window of data（数据的滚动窗口），那么你就要继承这个类。（例如Minimum）。

所有的指标都必须实现下面四个组件，为了在Lean中正常运作。

Constructor – 实现你的构造函数，用于接收和保存必要的指标配置信息。例如Aroon指标需要Aroon Up 和 Aroon Down值。

IsReady – 它是一个Boolean值，用于指示算法是否有了充足的历史价格数据用于算出指标的值。Aroon只有当有了n个周期的样本数据后才能开始计算。

ComputeNextValue()- 用提供的数据，计算和返回下一个指标的值。这里是你实现指标具体算法的地方。

保持可扩展性

Aroon作为案例是非常有代表性的，它有多个属性，Aroon-Up和Aroon-Down。这两个值在计算Aroon的时候都需要用到，但只有delta（up – down）会返回。这个例子中的dela叫做Aroon Percentage(比例)。许多指标会有一个主值（Primary value），多个属性，用于交易决策。

为了处理这些情况-每个属性都应该作为子指标（sub-indicator）。你可以查看下AroonOscillator.cs的源码。Aroon创建了AroonUp，AroonDown指标作为属性。这使得你可以单独的使用这些子指标。

例如下面的代码：

var smaAroonUp = sma.Of( aroon.AroonUp )

就直接用属性（子指标）。

现在我们贴出AroonOscillator的代码：

using QuantConnect.Data.Market;

namespace QuantConnect.Indicators
{
    /// <summary>
    /// The Aroon Oscillator is the difference between AroonUp and AroonDown. The value of this
    /// indicator fluctuats between -100 and +100. An upward trend bias is present when the oscillator
    /// is positive, and a negative trend bias is present when the oscillator is negative. AroonUp/Down
    /// values over 75 identify strong trends in their respective direction.
    /// </summary>
    public class AroonOscillator : TradeBarIndicator
    {
        /// <summary>
        /// Gets the AroonUp indicator
        /// </summary>
        public IndicatorBase<IndicatorDataPoint> AroonUp { get; private set; }

        /// <summary>
        /// Gets the AroonDown indicator
        /// </summary>
        public IndicatorBase<IndicatorDataPoint> AroonDown { get; private set; }

        /// <summary>
        /// Gets a flag indicating when this indicator is ready and fully initialized
        /// </summary>
        public override bool IsReady
        {
            get { return AroonUp.IsReady && AroonDown.IsReady; }
        }

        /// <summary>
        /// Creates a new AroonOscillator from the specified up/down periods.
        /// </summary>
        /// <param name="upPeriod">The lookback period to determine the highest high for the AroonDown</param>
        /// <param name="downPeriod">The lookback period to determine the lowest low for the AroonUp</param>
        public AroonOscillator(int upPeriod, int downPeriod)
            : this(string.Format("AROON({0},{1})", upPeriod, downPeriod), upPeriod, downPeriod)
        {
        }

        /// <summary>
        /// Creates a new AroonOscillator from the specified up/down periods.
        /// </summary>
        /// <param name="name">The name of this indicator</param>
        /// <param name="upPeriod">The lookback period to determine the highest high for the AroonDown</param>
        /// <param name="downPeriod">The lookback period to determine the lowest low for the AroonUp</param>
        public AroonOscillator(string name, int upPeriod, int downPeriod)
            : base(name)
        {
            var max = new Maximum(name + "_Max", upPeriod + 1);
            AroonUp = new FunctionalIndicator<IndicatorDataPoint>(name + "_AroonUp",
                input => ComputeAroonUp(upPeriod, max, input),
                aroonUp => max.IsReady,
                () => max.Reset()
                );

            var min = new Minimum(name + "_Min", downPeriod + 1);
            AroonDown = new FunctionalIndicator<IndicatorDataPoint>(name + "_AroonDown",
                input => ComputeAroonDown(downPeriod, min, input),
                aroonDown => min.IsReady,
                () => min.Reset()
                );
        }

        /// <summary>
        /// Computes the next value of this indicator from the given state
        /// </summary>
        /// <param name="input">The input given to the indicator</param>
        /// <returns>A new value for this indicator</returns>
        protected override decimal ComputeNextValue(TradeBar input)
        {
            AroonUp.Update(input.Time, input.High);
            AroonDown.Update(input.Time, input.Low);

            return AroonUp - AroonDown;
        }

        /// <summary>
        /// AroonUp = 100 * (period - {periods since max})/period
        /// </summary>
        /// <param name="upPeriod">The AroonUp period</param>
        /// <param name="max">A Maximum indicator used to compute periods since max</param>
        /// <param name="input">The next input data</param>
        /// <returns>The AroonUp value</returns>
        private static decimal ComputeAroonUp(int upPeriod, Maximum max, IndicatorDataPoint input)
        {
            max.Update(input);
            return 100m * (upPeriod - max.PeriodsSinceMaximum) / upPeriod;
        }

        /// <summary>
        /// AroonDown = 100 * (period - {periods since min})/period
        /// </summary>
        /// <param name="downPeriod">The AroonDown period</param>
        /// <param name="min">A Minimum indicator used to compute periods since min</param>
        /// <param name="input">The next input data</param>
        /// <returns>The AroonDown value</returns>
        private static decimal ComputeAroonDown(int downPeriod, Minimum min, IndicatorDataPoint input)
        {
            min.Update(input);
            return 100m * (downPeriod - min.PeriodsSinceMinimum) / downPeriod;
        }

        /// <summary>
        /// Resets this indicator and both sub-indicators (AroonUp and AroonDown)
        /// </summary>
        public override void Reset()
        {
            AroonUp.Reset();
            AroonDown.Reset();
            base.Reset();
        }
    }
}

2 在QCAlgorithm中安装Helper方法

在你实现了indicator（指标）之后，i需要将它安装到基类中。指标可以手工的创建和更新，不过我们加你使用helper方法，这样后面使用起来会简单很多。

在Aroon的案例中，实现是在AroonOscillator类，但它的helper方法是在QCAlgorithm中。这个helper方法—AROON—总是是大写的，总是返回一个指标实现类的实例对象。

public AroonOscillator AROON(string symbol, int upPeriod, int downPeriod, Resolution? resolution = null)  {
      var name = CreateIndicatorName(symbol, string.Format("AROON({0},{1})", upPeriod, downPeriod), resolution);
      var aroon = new AroonOscillator(name, upPeriod, downPeriod);
      RegisterIndicator(symbol, aroon, resolution);
      return aroon;
}

在helper方法中，你需要创建你指标的一个唯一的名字，使用你指标实现类的构造函数去构造一个指标实例，将其注册（注册后意味着指标的值会随着symbol（指定证券）的价格数据变动而自动的变动）。

3 创建测试方法

3.1 准备测试数据

将准备好的测试数据放到QuantConnect.Tests\TestData目录下。

3.2 写测试类

在QuantConnect.Tests\Indicators下面。可以拷贝已经有的进行改写。

using System;
using NUnit.Framework;
using QuantConnect.Data.Market;
using QuantConnect.Indicators;

namespace QuantConnect.Tests.Indicators
{
    [TestFixture]
    public class AroonOscillatorTests
    {
        [Test]
        public void ComparesWithExternalData()
        {
            var aroon = new AroonOscillator(14, 14);
            TestHelper.TestIndicator(aroon, "spy_aroon_oscillator.txt", "Aroon Oscillator 14",
                (i, expected) => Assert.AreEqual(expected, (double)aroon.Current.Value, 1e-3));
        }

        [Test]
        public void ResetsProperly()
        {
            var aroon = new AroonOscillator(3, 3);
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time = DateTime.Today,
                Open = 3m,
                High = 7m,
                Low = 2m,
                Close = 5m,
                Volume = 10
            });
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time = DateTime.Today.AddSeconds(1),
                Open = 3m,
                High = 7m,
                Low = 2m,
                Close = 5m,
                Volume = 10
            });
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time = DateTime.Today.AddSeconds(2),
                Open = 3m,
                High = 7m,
                Low = 2m,
                Close = 5m,
                Volume = 10
            });
            Assert.IsFalse(aroon.IsReady);
            aroon.Update(new TradeBar
            {
                Symbol = "SPY",
                Time = DateTime.Today.AddSeconds(3),
                Open = 3m,
                High = 7m,
                Low = 2m,
                Close = 5m,
                Volume = 10
            });
            Assert.IsTrue(aroon.IsReady);

            aroon.Reset();
            TestHelper.AssertIndicatorIsInDefaultState(aroon);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonUp);
            TestHelper.AssertIndicatorIsInDefaultState(aroon.AroonDown);
        }
    }
}
时间： 2024-10-05 19:22:38

程序员的量化交易（34）--QuantConnect_Lean如何定义Indicator指标2的相关文章

程序员的量化交易之路（1）----规划开篇

其实,一直对量化交易有一定的理解和情节.早在中大读研究生的时候实验室师兄,已经去了中国平安核心投资团队,做高频交易研究的国源师兄的影响,就开始对金融世界产生了浓厚的兴趣.看了丁磊编著的<量化投资--策略与技术>和艾琳.奥尔德里奇的<高频交易>,反复的看,但是都入不了味,现在回过头来想,一个连股都不炒的人怎么可能入味呢.对一些金融的基本概念都不懂. 2013年7月出社会工作后,在10月份确立目标.需要炒股,而且需要一个深入的理解金融的世界.所以确定去考一个证券从业考试,选了证券基础和

程序员的量化交易之路(2)----Esper文档学习之技术概览(1)

转载请注明出处:http://blog.csdn.net/minimicall/ 在接下来的20个工作日中,我将坚持翻译或者略翻译Esper的官方文档. 为什么需要学习Esper,因为我们需要理解复合事件处理 Complex Event Processing (CEP).在量化交易系统中,CEP是必不可少的.它负责处理海量的实时事件. 关于CEP更多知识,大家可以翻阅网络相关资料.我这里集中在学习开源的CEP系统,Esper.. 今天开始第一篇:技术概览. 1. CEP和事件序列分析 Esper

程序员的量化交易之路（13）--Cointrader类图（1）

转载须注明出处:http://blog.csdn.net/minimicall?viewmode=contents, htpp://cloudtrader.top 今天开始正式切入到Cointrader的源码分析学习中,其主页为:https://github.com/timolson/cointrader. 它是基于Esper的一个比特币云交易托管平台.和我想做的事情比较相近.而且虽然现在没什么功能,但代码量相对少,对于学习非常好. 下面是它的一个类图.: 后面我们会根据这个类图一步步的剖析整个

程序员的量化交易之路（19）--Cointrader之Bar实体（7）

转载需注明出处:http://blog.csdn.net/minimicall,http://cloudtrader.top 1. 代码 package org.cryptocoinpartners.schema; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; public class Bar extends Event { private long times

程序员的量化交易之路（20）--Cointrader之Assert实体（8）

转载需说明出处:http://blog.csdn.net/minimicall, http://cloudtrade.top 任何可交易的都可以称之为Assert,资产.其类代码如下: package org.cryptocoinpartners.schema; import javax.persistence.Basic; import javax.persistence.Cacheable; import javax.persistence.Entity; import javax.pers

程序员的量化交易之路（24）--Cointrader之RemoteEvent远程事件实体（11）

转载需注明出处:http://blog.csdn.net/minimicall,http://cloudtrader.top/ 在量化交易系统中,有些事件是远端传来的,比如股票的价格数据等.所以,在这一节我们定义了一个远端事件实体. 它是一个基类,并不单独生成数据表.具体代码如下: package org.cryptocoinpartners.schema; import javax.annotation.Nullable; import javax.persistence.Basic; imp

程序员的量化交易之路（38）--Lean之实时事件处理接口IRealTimeHandler和RealTimeEvent6

转载需注明出处:http://blog.csdn.net/minimicall?viewmode=contents,http://cloudtrade.top/ 这节开始我们要开始说明另外一个模块:实时事件处理模块. 这个模块的工作是什么呢.它就是用来设置一些在特定时间需要执行的任务.比如,每天开盘的时候,你可以做一个什么动作,比如每天收盘的时候你也可以做一个动作.当然还有更为广泛的运用. 在Lean中,是开启一个单独的线程来处理这种定时任务的. 实时事件:RealTimeEvent 实时事件处

程序员的量化交易之路（36）--Lean之数据读取SubscriptionDataReader4

转载需注明出处:http://blog.csdn.net/minimicall?viewmode=contents,http://cloudtrade.top 数据读取需要定义一个读者.直接见下面代码: namespace QuantConnect.Lean.Engine.DataFeeds { /******************************************************** * CLASS DEFINITIONS ***********************

程序员的量化交易之路（29）--Cointrader之Tick实体（16）

转载需注明出处:http://blog.csdn.net/minimicall,http://cloudtrade.top Tick:什么是Tick,在交易平台中非常常见,其实就 单笔交易时某只证券的基本数据. 我们通过代码来学习吧: package org.cryptocoinpartners.schema; import javax.annotation.Nullable; import javax.persistence.Entity; import javax.persistence.M