'inputs' - arrays are passed by reference only	ai.mq5	278	32
'operator[]' - constant cannot be modified	ai.mq5	206	25
'operator[]' - constant cannot be modified	ai.mq5	216	21


code:

//+------------------------------------------------------------------+
//|             Expert Advisor for Predicting Close Prices.mq5       |
//|                             Author: Ваше имя                     |
//+------------------------------------------------------------------+
#property copyright "Ваше имя"
#property link      "ваш_email@mail.com"
#property version   "1.0"
#property strict

//--- Параметры эксперта
input int      HistoryDepth      = 1000;     // Глубина истории для обучения
input int      PredictionShift   = 1;        // На сколько баров вперед предсказывать
input int      HiddenNeurons     = 10;       // Количество нейронов в скрытом слое
input double   LearningRate      = 0.01;     // Скорость обучения
input int      TrainingCycles    = 100;      // Количество циклов обучения
input double   LotSize           = 0.1;      // Размер лота для сделок
input double   StopLoss          = 500;      // Стоп-лосс в пунктах
input double   TakeProfit        = 500;      // Тейк-профит в пунктах
input int      MagicNumber       = 123456;   // Меджик номер для позиций
input bool     UseNormalization  = true;     // Использовать нормализацию данных
input bool     ShowDebugInfo     = true;     // Показывать отладочную информацию

#include <Trade\Trade.mqh>
#include <Math\Alglib\alglib.mqh>

//--- Объекты
CTrade             trade;
CMultilayerPerceptronShell neuralNetwork;

//--- Глобальные переменные
double CloseBuffer[];
double OpenBuffer[];
double HighBuffer[];
double LowBuffer[];

int inputsCount = 4; // Количество входных параметров (Open, High, Low, Close)
CMatrixDouble trainingData(0, 0);

//--- Нормализация данных
double inputMin[4];
double inputMax[4];
double outputMin;
double outputMax;

//+------------------------------------------------------------------+
//| Функция инициализации эксперта                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    //--- Загрузка данных
    if (!LoadHistoricalData())
    {
        Print("Ошибка загрузки исторических данных.");
        return(INIT_FAILED);
    }

    //--- Подготовка обучающей выборки
    PrepareTrainingData();

    //--- Создание и обучение нейронной сети
    CreateNeuralNetwork();

    //--- Обучение нейронной сети
    TrainNeuralNetwork();

    return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Функция деинициализации эксперта                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
    // Освобождение ресурсов при необходимости
}

//+------------------------------------------------------------------+
//| Функция, вызываемая при новом тике                               |
//+------------------------------------------------------------------+
void OnTick()
{
    static datetime lastTime = 0;

    //--- Проверяем появление нового бара
    if (lastTime == iTime(_Symbol, PERIOD_CURRENT, 0))
        return;

    lastTime = iTime(_Symbol, PERIOD_CURRENT, 0);

    //--- Получаем текущие данные
    double inputs[4];
    inputs[0] = iOpen(_Symbol, PERIOD_CURRENT, 0);
    inputs[1] = iHigh(_Symbol, PERIOD_CURRENT, 0);
    inputs[2] = iLow(_Symbol, PERIOD_CURRENT, 0);
    inputs[3] = iClose(_Symbol, PERIOD_CURRENT, 0);

    //--- Нормализация входных данных
    if (UseNormalization)
        NormalizeInputData(inputs);

    //--- Получаем прогноз цены закрытия
    double outputs[];
    ArrayResize(outputs, 1);
    CAlglib::MLPProcess(neuralNetwork, inputs, outputs);

    double predictedClose = outputs[0];

    //--- Денормализация результата
    if (UseNormalization)
        predictedClose = DenormalizeValue(predictedClose, outputMin, outputMax);

    if (ShowDebugInfo)
        Print("Предсказанное значение Close: ", predictedClose);

    //--- Действия на основе прогноза
    TradeBasedOnPrediction(predictedClose);
}

//+------------------------------------------------------------------+
//| Функция загрузки исторических данных                             |
//+------------------------------------------------------------------+
bool LoadHistoricalData()
{
    ArraySetAsSeries(CloseBuffer, true);
    ArraySetAsSeries(OpenBuffer, true);
    ArraySetAsSeries(HighBuffer, true);
    ArraySetAsSeries(LowBuffer, true);

    int totalBars = HistoryDepth + PredictionShift;

    if (CopyClose(_Symbol, PERIOD_CURRENT, 0, totalBars, CloseBuffer) < totalBars ||
        CopyOpen(_Symbol, PERIOD_CURRENT, 0, totalBars, OpenBuffer) < totalBars ||
        CopyHigh(_Symbol, PERIOD_CURRENT, 0, totalBars, HighBuffer) < totalBars ||
        CopyLow(_Symbol, PERIOD_CURRENT, 0, totalBars, LowBuffer) < totalBars)
    {
        Print("Не удалось загрузить исторические данные. Доступно баров: Close=", ArraySize(CloseBuffer), " Open=", ArraySize(OpenBuffer));
        return(false);
    }

    return(true);
}

//+------------------------------------------------------------------+
//| Функция подготовки обучающей выборки                             |
//+------------------------------------------------------------------+
void PrepareTrainingData()
{
    int samples = HistoryDepth - PredictionShift;
    trainingData.Resize(samples, inputsCount + 1); // Входы + целевое значение

    //--- Инициализация минимальных и максимальных значений для нормализации
    for (int i = 0; i < inputsCount; i++)
    {
        inputMin[i] = OpenBuffer[PredictionShift]; // Начальное значение
        inputMax[i] = OpenBuffer[PredictionShift];
    }
    outputMin = CloseBuffer[0];
    outputMax = CloseBuffer[0];

    //--- Нахождение мин/макс для нормализации
    for (int i = 0; i < samples; i++)
    {
        //--- Входные данные
        int idx = i + PredictionShift;
        double inputs[4];
        inputs[0] = OpenBuffer[idx];
        inputs[1] = HighBuffer[idx];
        inputs[2] = LowBuffer[idx];
        inputs[3] = CloseBuffer[idx];

        //--- Обновление мин/макс значений
        for (int j = 0; j < inputsCount; j++)
        {
            if (inputs[j] < inputMin[j]) inputMin[j] = inputs[j];
            if (inputs[j] > inputMax[j]) inputMax[j] = inputs[j];
        }

        //--- Целевое значение (цена закрытия следующего бара)
        double target = CloseBuffer[i];

        if (target < outputMin) outputMin = target;
        if (target > outputMax) outputMax = target;
    }

    //--- Заполнение обучающей выборки
    for (int i = 0; i < samples; i++)
    {
        int idx = i + PredictionShift;

        //--- Входные данные
        double inputs[4];
        inputs[0] = OpenBuffer[idx];
        inputs[1] = HighBuffer[idx];
        inputs[2] = LowBuffer[idx];
        inputs[3] = CloseBuffer[idx];

        //--- Нормализация входов
        if (UseNormalization)
        {
            for (int j = 0; j < inputsCount; j++)
                inputs[j] = NormalizeValue(inputs[j], inputMin[j], inputMax[j]);
        }

        //--- Запись входных данных в обучающую выборку
        for (int j = 0; j < inputsCount; j++)
            trainingData[i][j] = inputs[j];

        //--- Целевое значение (цена закрытия следующего бара)
        double target = CloseBuffer[i];

        //--- Нормализация выходов
        if (UseNormalization)
            target = NormalizeValue(target, outputMin, outputMax);

        //--- Запись целевого значения
        trainingData[i][inputsCount] = target;
    }

    if (ShowDebugInfo)
        Print("Обучающая выборка подготовлена.");
}

//+------------------------------------------------------------------+
//| Функция создания нейронной сети                                  |
//+------------------------------------------------------------------+
void CreateNeuralNetwork()
{
    //--- Создаем нейронную сеть с одним скрытым слоем
    CAlglib::MLPCreate1(inputsCount, HiddenNeurons, 1, neuralNetwork);

    if (ShowDebugInfo)
        Print("Нейронная сеть создана.");
}

//+------------------------------------------------------------------+
//| Функция обучения нейронной сети                                  |
//+------------------------------------------------------------------+
void TrainNeuralNetwork()
{
    int info;
    CMLPReportShell rep;

    //--- Обучение с помощью метода L-BFGS
    CAlglib::MLPTrainLBFGS(neuralNetwork, trainingData, trainingData.Rows(), LearningRate, TrainingCycles, 0.01, 0, info, rep);

    if (info != 2 && info != 6)
    {
        Print("Ошибка обучения нейронной сети: код ", info);
    }
    else
    {
        if (ShowDebugInfo)
            Print("Обучение завершено успешно.");
    }
}

//+------------------------------------------------------------------+
//| Функция нормализации значения                                    |
//+------------------------------------------------------------------+
double NormalizeValue(double value, double min, double max)
{
    if (max - min == 0)
        return 0.0;
    return (value - min) / (max - min);
}

//+------------------------------------------------------------------+
//| Функция денормализации значения                                  |
//+------------------------------------------------------------------+
double DenormalizeValue(double value, double min, double max)
{
    return value * (max - min) + min;
}

//+------------------------------------------------------------------+
//| Функция нормализации входных данных                              |
//+------------------------------------------------------------------+
void NormalizeInputData(double inputs[])
{
    for (int i = 0; i < inputsCount; i++)
    {
        inputs[i] = NormalizeValue(inputs[i], inputMin[i], inputMax[i]);
    }
}

//+------------------------------------------------------------------+
//| Функция для открытия сделок на основе прогноза                   |
//+------------------------------------------------------------------+
void TradeBasedOnPrediction(double predictedClose)
{
    double currentClose = iClose(_Symbol, PERIOD_CURRENT, 0);

    //--- Проверка наличия открытых позиций
    if (PositionsTotal() > 0)
        return;

    //--- Расчет разницы между прогнозируемым и текущим Close
    double difference = predictedClose - currentClose;

    if (difference > 0)
    {
        //--- Прогноз роста цены, открываем BUY
        TradeOpenPosition(ORDER_TYPE_BUY);
    }
    else if (difference < 0)
    {
        //--- Прогноз снижения цены, открываем SELL
        TradeOpenPosition(ORDER_TYPE_SELL);
    }
    //--- Если разница близка к нулю, не открываем позицию
}

//+------------------------------------------------------------------+
//| Функция открытия позиции                                         |
//+------------------------------------------------------------------+
void TradeOpenPosition(ENUM_ORDER_TYPE orderType)
{
    trade.SetDeviationInPoints(10);
    trade.SetExpertMagicNumber(MagicNumber);
    trade.SetTypeFilling(ORDER_FILLING_FOK); // Устанавливаем тип исполнения

    double price = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
    double sl = (orderType == ORDER_TYPE_BUY) ? price - StopLoss * _Point : price + StopLoss * _Point;
    double tp = (orderType == ORDER_TYPE_BUY) ? price + TakeProfit * _Point : price - TakeProfit * _Point;

    bool result;

    if (orderType == ORDER_TYPE_BUY)
        result = trade.Buy(LotSize, _Symbol, price, sl, tp, NULL);
    else
        result = trade.Sell(LotSize, _Symbol, price, sl, tp, NULL);

    if (!result)
    {
        Print("Ошибка открытия позиции: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
    }
    else
    {
        if (ShowDebugInfo)
            Print("Открыта позиция: ", ((orderType == ORDER_TYPE_BUY) ? "BUY" : "SELL"));
    }
}