wehub-resource-sync
216 lines
8.6 KiB
C#
216 lines
8.6 KiB
C#
/*
|
|
* QUANTCONNECT.COM - Democratizing Finance, Empowering Individuals.
|
|
* Lean Algorithmic Trading Engine v2.0. Copyright 2014 QuantConnect Corporation.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
using System;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using QuantConnect.Data;
|
|
using QuantConnect.Orders;
|
|
using QuantConnect.Interfaces;
|
|
using QuantConnect.Securities.Future;
|
|
|
|
namespace QuantConnect.Algorithm.CSharp
|
|
{
|
|
/// <summary>
|
|
/// Regression algorithm asserting that a hour/daily market order which was resting before the bar it fills on
|
|
/// opened (it predates the bar) fills at that bar's <b>open</b> - the price when trading resumed, like a
|
|
/// <see cref="OrderType.MarketOnOpen"/> - while a market order placed during the bar still fills at the
|
|
/// current/close price.
|
|
///
|
|
/// It buys a daily future contract on the bar that delivers it (the buy fills at that bar's close), then submits
|
|
/// a liquidation while the market is closed (on the overnight pulse, with no fresh bar). That liquidation rests
|
|
/// and fills on a later bar at the bar open, not its close.
|
|
/// </summary>
|
|
public class RestingMarketOrderFillsAtBarOpenRegressionAlgorithm : QCAlgorithm, IRegressionAlgorithmDefinition
|
|
{
|
|
private Future _future;
|
|
private Symbol _contract;
|
|
private bool _bought;
|
|
private OrderTicket _liquidate;
|
|
private DateTime _liquidateSubmitUtc;
|
|
private bool _buyAsserted;
|
|
private bool _restingAsserted;
|
|
|
|
public override void Initialize()
|
|
{
|
|
SetStartDate(2013, 10, 8);
|
|
SetEndDate(2013, 12, 31);
|
|
SetCash(1000000);
|
|
|
|
// Tight stale window so the resting order does not fill on the stale previous bar.
|
|
Settings.StalePriceTimeSpan = TimeSpan.FromMinutes(1);
|
|
|
|
_future = AddFuture("ES", Resolution.Daily);
|
|
_future.SetFilter(0, 182);
|
|
}
|
|
|
|
public override void OnData(Slice slice)
|
|
{
|
|
if (_contract == null)
|
|
{
|
|
foreach (var chain in slice.FutureChains)
|
|
{
|
|
var contract = chain.Value.OrderBy(x => x.Expiry).FirstOrDefault(x => x.Expiry > Time.Date.AddDays(90));
|
|
if (contract != null)
|
|
{
|
|
_contract = contract.Symbol;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Buy on the bar that delivers data: this order is placed during the bar so it fills at the current/close price.
|
|
if (_contract != null && !_bought && slice.Bars.ContainsKey(_contract))
|
|
{
|
|
MarketOrder(_contract, 1);
|
|
_bought = true;
|
|
return;
|
|
}
|
|
|
|
// Submit the liquidation while the market is closed (overnight pulse, no fresh bar in the slice). It predates
|
|
// the bar it will eventually fill on, so it must fill at that bar's open, not its close.
|
|
if (_bought && _liquidate == null && Portfolio[_contract].Invested && Time.TimeOfDay == TimeSpan.Zero)
|
|
{
|
|
_liquidate = MarketOrder(_contract, -1, asynchronous: true);
|
|
_liquidateSubmitUtc = UtcTime;
|
|
|
|
if (_liquidate.Status.IsFill())
|
|
{
|
|
throw new RegressionTestException($"The resting liquidation must not fill immediately on the stale bar at {Time}");
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void OnOrderEvent(OrderEvent orderEvent)
|
|
{
|
|
if (orderEvent.Status != OrderStatus.Filled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var open = Securities[_contract].Open;
|
|
var close = Securities[_contract].Close;
|
|
var fill = orderEvent.FillPrice;
|
|
|
|
if (open == close)
|
|
{
|
|
throw new RegressionTestException($"Test data is not meaningful: bar open equals close ({open}) at {Time}");
|
|
}
|
|
|
|
if (_liquidate != null && orderEvent.OrderId == _liquidate.OrderId)
|
|
{
|
|
// Resting order: it was submitted before this bar opened, so it must fill at the bar open (closer to the
|
|
// open than the close), and only after a later bar arrived.
|
|
if (Math.Abs(fill - open) >= Math.Abs(fill - close))
|
|
{
|
|
throw new RegressionTestException(
|
|
$"Expected the resting order to fill at the bar open {open} (not the close {close}) but filled at {fill}");
|
|
}
|
|
|
|
if (orderEvent.UtcTime <= _liquidateSubmitUtc)
|
|
{
|
|
throw new RegressionTestException(
|
|
$"Expected the resting order to fill on a later bar than its submission {_liquidateSubmitUtc} but filled at {orderEvent.UtcTime}");
|
|
}
|
|
|
|
_restingAsserted = true;
|
|
}
|
|
else
|
|
{
|
|
// Buy placed during the bar: it fills at the current/close price, not the open.
|
|
if (Math.Abs(fill - close) >= Math.Abs(fill - open))
|
|
{
|
|
throw new RegressionTestException(
|
|
$"Expected the in-bar buy to fill at the bar close {close} (not the open {open}) but filled at {fill}");
|
|
}
|
|
|
|
_buyAsserted = true;
|
|
}
|
|
}
|
|
|
|
public override void OnEndOfAlgorithm()
|
|
{
|
|
if (!_buyAsserted)
|
|
{
|
|
throw new RegressionTestException("The in-bar buy was never filled/asserted");
|
|
}
|
|
|
|
if (!_restingAsserted)
|
|
{
|
|
throw new RegressionTestException("The resting market order was never filled at the bar open/asserted");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// This is used by the regression test system to indicate if the open source Lean repository has the required data to run this algorithm.
|
|
/// </summary>
|
|
public bool CanRunLocally { get; } = true;
|
|
|
|
/// <summary>
|
|
/// This is used by the regression test system to indicate which languages this algorithm is written in.
|
|
/// </summary>
|
|
public List<Language> Languages { get; } = new() { Language.CSharp };
|
|
|
|
/// <summary>
|
|
/// Data Points count of all timeslices of algorithm
|
|
/// </summary>
|
|
public long DataPoints => 1244;
|
|
|
|
/// <summary>
|
|
/// Data Points count of the algorithm history
|
|
/// </summary>
|
|
public int AlgorithmHistoryDataPoints => 0;
|
|
|
|
/// <summary>
|
|
/// Final status of the algorithm
|
|
/// </summary>
|
|
public AlgorithmStatus AlgorithmStatus => AlgorithmStatus.Completed;
|
|
|
|
/// <summary>
|
|
/// This is used by the regression test system to indicate what the expected statistics are from running the algorithm
|
|
/// </summary>
|
|
public Dictionary<string, string> ExpectedStatistics => new Dictionary<string, string>
|
|
{
|
|
{"Total Orders", "2"},
|
|
{"Average Win", "0.66%"},
|
|
{"Average Loss", "0%"},
|
|
{"Compounding Annual Return", "2.861%"},
|
|
{"Drawdown", "0.200%"},
|
|
{"Expectancy", "0"},
|
|
{"Start Equity", "1000000"},
|
|
{"End Equity", "1006570.7"},
|
|
{"Net Profit", "0.657%"},
|
|
{"Sharpe Ratio", "1.931"},
|
|
{"Sortino Ratio", "2.91"},
|
|
{"Probabilistic Sharpe Ratio", "70.540%"},
|
|
{"Loss Rate", "0%"},
|
|
{"Win Rate", "100%"},
|
|
{"Profit-Loss Ratio", "0"},
|
|
{"Alpha", "-0.016"},
|
|
{"Beta", "0.068"},
|
|
{"Annual Standard Deviation", "0.006"},
|
|
{"Annual Variance", "0"},
|
|
{"Information Ratio", "-5.117"},
|
|
{"Tracking Error", "0.078"},
|
|
{"Treynor Ratio", "0.182"},
|
|
{"Total Fees", "$4.30"},
|
|
{"Estimated Strategy Capacity", "$4700000000.00"},
|
|
{"Lowest Capacity Asset", "ES VP274HSU1AF5"},
|
|
{"Portfolio Turnover", "0.20%"},
|
|
{"Drawdown Recovery", "12"},
|
|
{"OrderListHash", "6a53aee5b55140888033e93db779c2e9"}
|
|
};
|
|
}
|
|
}
|