Backtesting de fuentes de datos personalizadas

La API de fuentes de datos personalizadas para backtesting proporciona tipos que permiten a los desarrolladores introducir datos de precios personalizados en los motores de backtesting, optimización y Market Replay en cTrader. Estas funcionalidades de la API permiten nuevos y potentes flujos de trabajo utilizando formatos de datos offline, de terceros, sintéticos o experimentales.

Las interfaces y tipos principales incluyen:

BacktestingDataSources.Add(name, options) para registrar una nueva fuente personalizada.
BacktestingDataSourceOptions para configurar el tipo de datos soportado, el rango de tiempo de los datos y la lógica de obtención.
BacktestingDataRequest es emitido por el motor cuando se necesitan datos durante una prueba.
BacktestingTickData y BacktestingBarsData encapsulan los datos devueltos por el plugin.

El motor de backtesting interactúa con los datos proporcionados a través de estos componentes:

Tipos de datos – elija entre tick (bid/ask), precios de apertura m1, barras OHLCV completas, etc.
Proveedores de datos – implemente devoluciones de llamada para suministrar datos bajo demanda.
Gestión de rangos de tiempo – defina qué períodos son compatibles.
Períodos personalizados – combine con TimeFrameManager.Custom para simular nuevos tipos de barras o resoluciones.
Símbolos personalizados – ejecute simulaciones en instrumentos sintéticos.

Consejo

Use la API para hacer backtesting de sus estrategias en feeds de terceros, como datos de tick de brokers, y aplique conjuntos de datos offline en un entorno controlado. Reproduzca, optimice y pruebe estrategias bajo estrés con datos que reflejen verdaderamente las condiciones de operación en vivo, y hágalo todo dentro de la familiar interfaz de usuario de cTrader.

La API de fuentes de datos personalizadas para backtesting permite lo siguiente:

Característica u operación	Ejemplos
Integración de datos alternativos	Hacer backtesting usando feeds de tick institucionales. Ejecutar Market Replay en datos específicos del broker. Importar barras de AlphaVantage o Nasdaq Data Link (Quandl).
Backtesting basado en eventos	Simular el impacto de informes de noticias, como IPC o NFP. Inyectar ráfagas de volatilidad durante períodos conocidos.
Pruebas de barras alternativas	Hacer backtesting en lógica de barras Renko, Heikin Ashi o personalizadas.
Experimentación con períodos	Probar estrategias en períodos poco comunes, como m25, m40, h10, etc.
Pruebas de robustez de estrategias	Inyectar ruido aleatorio en los precios. Ejecutar simulaciones de Monte Carlo.
Superposiciones de curva de capital o riesgo	Hacer backtesting usando curvas históricas de saldo de estrategias.

Flujo de trabajo básico

Ejemplo de plugin

Cuando está habilitado, este plugin muestra un componente con botones en el Panel de símbolo activo que le permite agregar y gestionar fuentes de datos personalizadas, incluidas las de períodos personalizados.

Cualquier dato personalizado agregado se vuelve disponible como una opción de datos en la ventana de Market Replay y Backtesting, mientras que cualquier período personalizado agregado aparece en la interfaz de usuario regular de Período.

Market ReplayBacktesting

Código del plugin

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Net;
using System.Reflection;
using cAlgo.API;
using cAlgo.API.Collections;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System.Linq;

namespace cAlgo.Plugins
{
    [Plugin(AccessRights = AccessRights.FullAccess)]
    public class CustomDataSourceCSVTest : Plugin
    {
        private BacktestingDataSource _dataSource;
        private TextBox _symbolNameTextBox;
        private ComboBox _timeFrameCombobox;
        private string _selectedFilePath;

        private readonly Dictionary<DataId, Data> _addedData = new();
        private readonly Dictionary<DataId, Dictionary<DateOnly, List<BacktestingTick>>> _cachedTickData = new();
        private readonly Dictionary<DataId, List<BacktestingBar>> _cachedBarData = new();

        private StackPanel _panel;
        private Button _selectFileButton;

        private CustomTimeFrame _customTimeFrame;

        protected override void OnStart()
        {
            // System.Diagnostics.Debugger.Launch();

            LoadFromLocalStorage();

            var options = new BacktestingDataSourceOptions(BacktestingDataSourceDataType.Tick | BacktestingDataSourceDataType.M1OpenPrices | BacktestingDataSourceDataType.OpenPrices, OnMinMaxTimeRequested, OnDataRequested);

            _dataSource = Backtesting.DataSources.Add("CSV", options);

            var aspBlock = Asp.SymbolTab.AddBlock("Custom Data Source CSV Test");

            aspBlock.Child = GetAddDataPanel();
            aspBlock.Height = 400;
        }

        private Panel GetAddDataPanel()
        {
            _panel = new StackPanel() {Orientation = Orientation.Vertical, Margin = 3};

            _symbolNameTextBox = new TextBox() {Text = "Enter Symbol Name", Margin = 3};

            _panel.AddChild(_symbolNameTextBox);

            _timeFrameCombobox = new ComboBox() {Margin = 3, Padding = 2};

            foreach (var timeFrame in GetTimeFrames())
            {
                _timeFrameCombobox.AddItem(timeFrame.Name);
            }

            _timeFrameCombobox.SelectedItem = TimeFrame.Minute.Name;

            _panel.AddChild(_timeFrameCombobox);

            _selectFileButton = new Button() {Text = "Select File", Margin = 3};

            _selectFileButton.Click += OnSelectFileButtonClicked;

            _panel.AddChild(_selectFileButton);

            var addButton = new Button() {Text = "Add Data", Margin = 3};

            addButton.Click += OnAddClick;

            _panel.AddChild(addButton);

            var showDataButton = new Button() {Text = "Show Data", Margin = 3};

            showDataButton.Click += OnShowDataClick;

            _panel.AddChild(showDataButton);

            var removeAllDataButton = new Button() {Text = "Remove All Data", Margin = 3};

            removeAllDataButton.Click += OnRemoveAllDataClick;

            _panel.AddChild(removeAllDataButton);

            var clearCacheButton = new Button() {Text = "Clear Cache", Margin = 3};

            clearCacheButton.Click += OnClearCacheClick;

            _panel.AddChild(clearCacheButton);

            var addCustomTimeFrameButton = new Button() {Text = "Add Custom Time Frame", Margin = 3};

            addCustomTimeFrameButton.Click += OnAddCustomTimeFrameClick;

            _panel.AddChild(addCustomTimeFrameButton);

            var removeCustomTimeFrameButton = new Button() {Text = "Remove Custom Time Frame", Margin = 3};

            removeCustomTimeFrameButton.Click += OnRemoveCustomTimeFrameClick;

            _panel.AddChild(removeCustomTimeFrameButton);

            return _panel;
        }

        private void OnRemoveCustomTimeFrameClick(ButtonClickEventArgs obj)
        {
            if (TimeFrameManager.Custom.Remove(_customTimeFrame))
            {
                Print($"Custom time frame removed.");
                return;
            }

            Print($"Removing custom time frame failed.");
        }

        private void OnAddCustomTimeFrameClick(ButtonClickEventArgs obj)
        {
            _customTimeFrame = TimeFrameManager.Custom.Add("Custom Data Source Test (H1)");

            _customTimeFrame.BarsNeeded = args => 
            {
                Print($"Custom time frame bars needed for symbol '{args.CustomBars.Symbol.Name}'.");

                var bars = MarketData.GetBars(TimeFrame.Hour, args.CustomBars.Symbol.Name);

                Print($"Appending custom time frame bars '{bars.Count}' for symbol '{args.CustomBars.Symbol.Name}'.");

                args.CustomBars.AppendBars(bars.Select(b => new CustomBar(b.OpenTime, b.Open, b.High, b.Low, b.Close, b.TickVolume)));
            };

            Print("Custom time frame added.");
        }

        private void OnClearCacheClick(ButtonClickEventArgs obj)
        {
            if (_dataSource.ClearCache())
            {
                Print($"Data source '{_dataSource.Name}' cached data cleared.");
                return;
            }

            Print($"Data source '{_dataSource.Name}' cached data clear failed.");
        }

        private void OnRemoveAllDataClick(ButtonClickEventArgs obj)
        {
            foreach (var (_, data) in _addedData)
            {
                File.Delete(data.FilePath);
            }

            LocalStorage.Remove("Data", LocalStorageScope.Type);
            LocalStorage.Flush(LocalStorageScope.Type);

            _addedData.Clear();

            Print("All added data has been removed.");
        }

        private void OnAddClick(ButtonClickEventArgs obj)
        {
            if (_symbolNameTextBox.Text.Length == 0 || Symbols.GetSymbol(_symbolNameTextBox.Text) is not { } symbol)
            {
                Print($"Invalid or empty symbol name: {_symbolNameTextBox.Text}");
                return;
            }

            if (string.IsNullOrWhiteSpace(_timeFrameCombobox.SelectedItem) || !TimeFrame.TryParse(_timeFrameCombobox.SelectedItem, out var selectedTimeFrame))
            {
                Print($"Invalid time frame: {_timeFrameCombobox.SelectedItem}");
                return;
            }

            if (string.IsNullOrWhiteSpace(_selectedFilePath))
            {
                Print($"Invalid file path: {_selectedFilePath}");
                return;
            }

            var dataType = selectedTimeFrame == TimeFrame.Tick 
                ? BacktestingDataSourceDataType.Tick 
                : selectedTimeFrame == TimeFrame.Minute 
                    ? BacktestingDataSourceDataType.M1OpenPrices 
                    : BacktestingDataSourceDataType.OpenPrices;

            var dataId = new DataId(symbol.Name, selectedTimeFrame.Name, dataType);

            _panel.IsEnabled = false;

            BeginInvokeOnMainThread(() =>
            {
                try
                {
                    var minMaxTime = GetMinMaxTime(_selectedFilePath);
                    var data = new Data(_selectedFilePath, minMaxTime);

                    _addedData[dataId] = data;

                    SaveToLocalStorage(dataId, data);

                    Print($"Data for symbol {symbol} and time frame {selectedTimeFrame} is added: {_selectedFilePath}, Min/Max Time: {minMaxTime}");
                }
                finally
                {
                    _panel.IsEnabled = true;
                }
            });
        }

        private void SaveToLocalStorage(DataId dataId, Data data)
        {
            var existingData = LocalStorage.GetObject<List<(DataId DataId, Data Data)>>("Data", LocalStorageScope.Type) 
                               ?? new List<(DataId DataId, Data Data)>();

            existingData.Add((dataId, data));

            LocalStorage.SetObject("Data", existingData, LocalStorageScope.Type);
            LocalStorage.Flush(LocalStorageScope.Type);
        }


        private void OnShowDataClick(ButtonClickEventArgs obj)
        {
            var existingData =
                LocalStorage.GetObject<List<(DataId DataId, Data Data)>>("Data", LocalStorageScope.Type);

            if (existingData is null)
                return;

            Print("Showing data");

            foreach (var (dataId, data) in existingData)
            {
                Print($"Data '{dataId}' with '{data}'");
            }
        }

        private void LoadFromLocalStorage()
        {
            var existingData =
                LocalStorage.GetObject<List<(DataId DataId, Data Data)>>("Data", LocalStorageScope.Type);

            if (existingData is null)
                return;

            foreach (var (dataId, data) in existingData)
            {
                _addedData[dataId] = data with {MinMaxTime = data.MinMaxTime with
                {
                    MinTime = DateTime.SpecifyKind(data.MinMaxTime.MinTime, DateTimeKind.Utc),
                    MaxTime = DateTime.SpecifyKind(data.MinMaxTime.MaxTime, DateTimeKind.Utc)
                }};

                Print($"Added data '{dataId}' from local storage");
            }
        }

        private void OnSelectFileButtonClicked(ButtonClickEventArgs obj)
        {
            var openFileDialog = new OpenFileDialog();

            _panel.IsEnabled = false;
            _selectFileButton.Text = "Please wait...";

            BeginInvokeOnMainThread(() =>
            {
                try
                {
                    var result = openFileDialog.ShowDialog();

                    if (result != FileDialogResult.OK)
                        return;

                    _selectedFilePath = openFileDialog.FileName;
                }
                finally
                {
                    _selectFileButton.Text = "Select File";
                    _panel.IsEnabled = true;
                }
            });
        }

        private IEnumerable<TimeFrame> GetTimeFrames()
        {
            var timeFrameFields = typeof(TimeFrame).GetFields(BindingFlags.Static | BindingFlags.Public);

            foreach (var timeFrameField in timeFrameFields)
            {
                if (timeFrameField.GetValue(null) is not TimeFrame timeFrame)
                    continue;

                yield return timeFrame;
            }
        }

        private void OnDataRequested(BacktestingDataRequest request)
        {
            request.StatusChanged += request_StatusChanged;

            Print($"Data Request from {request.StartTime} to {request.EndTime}");

            var dataId = GetDataId(request.PriceDataSourceId, request.DataType);

            if (!_addedData.TryGetValue(dataId, out var data))
            {
                request.Fail($"Data not found for '{dataId}'.");

                return;
            }

            switch (request.DataType)
            {
                case BacktestingDataSourceDataType.Tick:
                    var ticks = GetRequestTicks(dataId, data, request);
                    Print($"Sending ticks.");

                    request.Complete(ticks);
                    break;
                default:
                    var bars = GetRequestBars(dataId, data, request);
                    Print($"Sending bars.");

                    request.Complete(bars);
                    break;
            }
        }

        private BacktestingData GetRequestTicks(DataId dataId, Data data, BacktestingDataRequest request)
        {
            if (!_cachedTickData.TryGetValue(dataId, out var tickData))
            {
                tickData = CacheTickData(dataId, data);

                _cachedTickData[dataId] = tickData;
            }

            var requestData = new List<BacktestingTick>();

            for (var i = DateOnly.FromDateTime(request.StartTime); i <= DateOnly.FromDateTime(request.EndTime); i = i.AddDays(1))
            {
                if (!tickData.TryGetValue(i, out var ticks))
                    continue;

                requestData.AddRange(ticks);
            }

            return new BacktestingTickData(requestData);
        }

        private BacktestingData GetRequestBars(DataId dataId, Data data, BacktestingDataRequest request)
        {
            if (!_cachedBarData.TryGetValue(dataId, out var barsData))
            {
                barsData = CacheBarData(dataId, data);

                _cachedBarData[dataId] = barsData;
            }

            return new BacktestingBarsData(barsData.Where(b => b.Time >= request.StartTime && b.Time <= request.EndTime).ToArray());
        }

        private List<BacktestingBar> CacheBarData(DataId dataId, Data data)
        {
            var result = new List<BacktestingBar>();

            using var fileStream = File.OpenRead(data.FilePath);
            using var streamReader = new StreamReader(fileStream);

            while (streamReader.ReadLine() is {} line)
            {
                var lineSplit = line.Split(',');

                if (lineSplit.Length != 6)
                {
                    throw new InvalidOperationException($"Invalid data format for '{dataId}'.");
                }

                result.Add(new BacktestingBar(DateTime.Parse(lineSplit[0]).ToUniversalTime(), double.Parse(lineSplit[1]), double.Parse(lineSplit[2]), double.Parse(lineSplit[3]), double.Parse(lineSplit[4]), long.Parse(lineSplit[5])));
            }

            return result;
        }

        private Dictionary<DateOnly, List<BacktestingTick>> CacheTickData(DataId dataId, Data data)
        {
            var result = new Dictionary<DateOnly, List<BacktestingTick>>();

            using var fileStream = File.OpenRead(data.FilePath);
            using var streamReader = new StreamReader(fileStream);

            while (streamReader.ReadLine() is {} line)
            {
                var lineSplit = line.Split(',');

                if (lineSplit.Length != 3)
                {
                    throw new InvalidOperationException($"Invalid data format for '{dataId}'.");
                }

                var time = DateTime.Parse(lineSplit[0]).ToUniversalTime();
                var date = DateOnly.FromDateTime(time);

                if (!result.TryGetValue(date, out var dateTicks))
                {
                    dateTicks = new List<BacktestingTick>();

                    result.Add(date, dateTicks);
                }

                dateTicks.Add(new BacktestingTick(time, double.Parse(lineSplit[1]), double.Parse(lineSplit[2])));
            }

            return result;
        }

        private void request_StatusChanged(BacktestingDataRequestStatusChangedEventArgs args)
        {
            Print($"Request '{args.DataRequest.PriceDataSourceId}' status changed: {args.DataRequest.Status}");
        }

        private BacktestingMinMaxTime OnMinMaxTimeRequested(BacktestingDataSourceMinMaxTimeArgs args)
        {
            Print($"Min/Max time requested, {args.PriceDataSourceId}, {args.DataType}");

            var dataId = GetDataId(args.PriceDataSourceId, args.DataType);

            Print($"Min/Max time request DataId: {dataId}");

            if (!_addedData.TryGetValue(dataId, out var data))
            {
                throw new InvalidOperationException("No data");
                //return default;    
            }

            Print($"Min/Max time sent, {data.MinMaxTime}");

            return data.MinMaxTime;
        }

        private DataId GetDataId(PriceDataSourceId priceDataSourceId, BacktestingDataSourceDataType dateType)
        {
            return new DataId(priceDataSourceId.Symbol.Name, dateType switch
            {
                BacktestingDataSourceDataType.Tick => TimeFrame.Tick.Name,
                BacktestingDataSourceDataType.M1OpenPrices => TimeFrame.Minute.Name,
                BacktestingDataSourceDataType.OpenPrices when _customTimeFrame != null && priceDataSourceId.TimeFrame == _customTimeFrame.TimeFrame => TimeFrame.Hour.Name,
                _ => priceDataSourceId.TimeFrame.Name
            }, dateType);
        }

        private BacktestingMinMaxTime GetMinMaxTime(string filePath)
        {
            using var fileStream = File.OpenRead(filePath);
            using var streamReader = new StreamReader(fileStream);

            string firstLine = null;
            string lastLine = null;

            while (streamReader.ReadLine() is {} line)
            {
                if (firstLine == null)
                    firstLine = line;

                lastLine = line;
            }

            Print($"First Line: {firstLine}");
            Print($"Last Line: {lastLine}");

            return new(
                !string.IsNullOrWhiteSpace(firstLine) ? DateTime.Parse(firstLine.Split(',')[0]).ToUniversalTime() : default,
                !string.IsNullOrWhiteSpace(lastLine) ? DateTime.Parse(lastLine.Split(',')[0]).ToUniversalTime() : default);
        }

        private readonly record struct DataId(string SymbolName, string TimeFrameName, BacktestingDataSourceDataType DataType);
        private readonly record struct Data(string FilePath, BacktestingMinMaxTime MinMaxTime);
    }
}

Operaciones

Registrar una fuente de datos

Sintaxis básica:

var options = new BacktestingDataSourceOptions(
    SupportedDataTypes: BacktestingDataSourceDataType.Tick | BacktestingDataSourceDataType.OpenPrices,
    MinMaxTimeHandler: args => new BacktestingMinMaxTime(DateTime.Parse("2023-01-01"), DateTime.Parse("2024-01-01")),
    DataRequestHandler: request => 
    {
        var data = LoadFromCsv(request); // your logic
        request.Complete(data);
    }
);

var dataSource = Backtesting.DataSources.Add("MyCSVData", options);

Dentro del plugin:

protected override void OnStart()
{

    LoadFromLocalStorage();

    var options = new BacktestingDataSourceOptions(
        BacktestingDataSourceDataType.Tick 
        | BacktestingDataSourceDataType.M1OpenPrices 
        | BacktestingDataSourceDataType.OpenPrices, 
        OnMinMaxTimeRequested, 
        OnDataRequested
    );

    _dataSource = Backtesting.DataSources.Add("CSV", options);

    var aspBlock = Asp.SymbolTab.AddBlock("Custom Data Source CSV Test");

    aspBlock.Child = GetAddDataPanel();
    aspBlock.Height = 400;
}

Servir datos bajo petición

Cada BacktestingDataRequest contiene:

.StartTime, .EndTime – el período solicitado
.PriceDataSourceId – la combinación de símbolo/período
.DateType – tick, m1 o OHLCV
.Complete(data) – llame a esto una vez que los datos estén listos
.Fail("reason") – llame a esto si la solicitud no puede cumplirse

Ejemplo de manejador:

void OnDataRequested(BacktestingDataRequest request)
{
    var bars = LoadBarsFromCsv("mydata.csv", request.StartTime, request.EndTime);
    request.Complete(new BacktestingBarsData(bars));
}

Dentro del plugin:

private void OnDataRequested(BacktestingDataRequest request)
{
    request.StatusChanged += request_StatusChanged;

    Print($"Data Request from {request.StartTime} to {request.EndTime}");

    var dataId = GetDataId(request.PriceDataSourceId, request.DataType);

    if (!_addedData.TryGetValue(dataId, out var data))
    {
        request.Fail($"Data not found for '{dataId}'.");
        return;
    }

    switch (request.DataType)
    {
        case BacktestingDataSourceDataType.Tick:
            var ticks = GetRequestTicks(dataId, data, request);
            Print($"Sending ticks.");
            request.Complete(ticks);
            break;

        default:
            var bars = GetRequestBars(dataId, data, request);
            Print($"Sending bars.");
            request.Complete(bars);
            break;
    }
}

Manejar la disponibilidad del rango de tiempo

Esto le dice al motor qué período está disponible para el backtesting y evita errores fuera de límites.

Sintaxis básica:

BacktestingMinMaxTime MinMax(DateTime min, DateTime max)
    => new BacktestingMinMaxTime(min, max);

Dentro del plugin:

private BacktestingMinMaxTime OnMinMaxTimeRequested(BacktestingDataSourceMinMaxTimeArgs args)
{
    Print($"Min/Max time requested, {args.PriceDataSourceId}, {args.DataType}");

    var dataId = GetDataId(args.PriceDataSourceId, args.DataType);

    Print($"Min/Max time request DataId: {dataId}");

    if (!_addedData.TryGetValue(dataId, out var data))
    {
        throw new InvalidOperationException("No data");
    }

    Print($"Min/Max time sent, {data.MinMaxTime}");

    return data.MinMaxTime;
}

Combinar con períodos personalizados (opcional)

Puede vincular una fuente de datos a períodos personalizados.

Sintaxis básica:

var customTf = TimeFrameManager.Custom.Add("My 45min");

customTf.BarsNeeded = args =>
{
    var baseBars = LoadBarsFromCsv("source.csv");
    var grouped = AggregateBarsTo45min(baseBars);
    args.CustomBars.AppendBars(grouped);
};

Dentro del plugin:

private void OnAddCustomTimeFrameClick(ButtonClickEventArgs obj)
{
    _customTimeFrame = TimeFrameManager.Custom.Add("Custom Data Source Test (h1)");

    _customTimeFrame.BarsNeeded = args => 
    {
        Print($"Custom time frame bars needed for symbol '{args.CustomBars.Symbol.Name}'.");

        var bars = MarketData.GetBars(TimeFrame.Hour, args.CustomBars.Symbol.Name);

        Print($"Appending custom time frame bars '{bars.Count}' for symbol '{args.CustomBars.Symbol.Name}'.");

        args.CustomBars.AppendBars(bars.Select(b => new CustomBar(
            b.OpenTime,
            b.Open,
            b.High,
            b.Low,
            b.Close,
            b.TickVolume
        )));
    };

    Print("Custom time frame added.");
}

Consejos

Purgar los resultados antiguos al actualizar datos usando BacktestingDataSource.ClearCache().
Persistir las referencias de fuente usando LocalStorage para recargar al reiniciar.
Usar PluginPanel, TextBox y FileDialog para construir selectores de datos visuales para mayor comodidad.

Ideas prácticas

Agregar barras en períodos personalizados

Puede crear resoluciones de gráfico personalizadas, como barras de 45 minutos, agregando datos m1 existentes. Este enfoque le permite hacer backtesting de su estrategia en intervalos no estándar, y puede descubrir patrones de precios que no aparecen en períodos comunes como m30 o h1.

_customTimeFrame = TimeFrameManager.Custom.Add("Custom 45-min");

_customTimeFrame.BarsNeeded = args =>
{
    var m1Bars = MarketData.GetBars(TimeFrame.Minute, args.CustomBars.Symbol.Name);
    var groupedBars = m1Bars
        .GroupBy(bar => bar.OpenTime.Ticks / TimeSpan.FromMinutes(45).Ticks)
        .Select(group => new CustomBar(
            group.First().OpenTime,
            group.First().Open,
            group.Max(b => b.High),
            group.Min(b => b.Low),
            group.Last().Close,
            group.Sum(b => b.TickVolume)
        ));

    args.CustomBars.AppendBars(groupedBars);
};

Operar índices sintéticos construidos a partir de múltiples símbolos

Considere hacer backtesting de estrategias en índices personalizados promediando o combinando datos de precios de varios símbolos. Por ejemplo, puede crear un índice sintético de riesgo utilizando EURUSD, GBPUSD y AUDUSD, y luego hacer backtesting como con cualquier otro símbolo.

var base1 = Symbols.GetSymbol("EURUSD");
var base2 = Symbols.GetSymbol("GBPUSD");
var base3 = Symbols.GetSymbol("AUDUSD");

var syntheticSymbol = CustomSymbols.Add("SyntheticRiskOn", Account.Asset, Assets.GetAsset("USD"));
syntheticSymbol.BarsNeeded = args =>
{
    MarketData.GetBarsAsync(TimeFrame.Minute, base1.Name, bars1 =>
    {
        MarketData.GetBarsAsync(TimeFrame.Minute, base2.Name, bars2 =>
        {
            MarketData.GetBarsAsync(TimeFrame.Minute, base3.Name, bars3 =>
            {
                var bars = bars1.Zip(bars2, (b1, b2) => (b1, b2))
                                .Zip(bars3, (pair, b3) =>
                                {
                                    var (b1, b2) = pair;
                                    return new CustomBar(
                                        b1.OpenTime,
                                        (b1.Open + b2.Open + b3.Open) / 3,
                                        (b1.High + b2.High + b3.High) / 3,
                                        (b1.Low + b2.Low + b3.Low) / 3,
                                        (b1.Close + b2.Close + b3.Close) / 3,
                                        (b1.TickVolume + b2.TickVolume + b3.TickVolume)
                                    );
                                });

                args.CustomBars.AppendBars(bars);
            });
        });
    });
};

Si obtiene resultados positivos en el backtesting, puede proceder a operar el símbolo personalizado.

Ejecutar simulaciones de Monte Carlo con ruido de precios

Inyecte una ligera aleatoriedad en los datos de precios históricos para simular imperfecciones del mundo real como deslizamiento o picos de precios. Repetir backtests con diferentes patrones de ruido le ayuda a descubrir estrategias frágiles y validar la robustez bajo incertidumbre.

Random rand = new Random();
foreach (var bar in bars)
{
    var noise = 1 + rand.NextDouble() * 0.001 - 0.0005;
    modifiedBars.Add(new BacktestingBar(
        bar.Time,
        bar.Open * noise,
        bar.High * noise,
        bar.Low * noise,
        bar.Close * noise,
        bar.Volume
    ));
}