Motor de decisión Multi-IA para MQL5 (Parte 3): Darle a las IA el contexto correcto — régimen de mercado y noticias
32
0
Introducción
En la Parte 1 construimos el motor: varias IA reciben la misma pregunta y su respuesta se combina por votación. En la Parte 2, el motor aprendió en qué IA confiar (según su tasa de acierto) e incorporó gestión de riesgo. Las dos partes funcionan, pero comparten una limitación que vengo arrastrando desde el principio y que ahora quiero atacar de frente: el contexto que les damos a las IA es pobre.
Hasta aquí, el prompt era básicamente el precio y un par de cierres. Y ese es exactamente el terreno donde un modelo de lenguaje no tiene ninguna ventaja. Adivinar el próximo tick a partir de cuatro números es justo lo que un LLM hace mal: no es una serie temporal calibrada, no "ve" el order flow, y si le pides que prediga el movimiento inmediato, te inventará una respuesta con tono seguro. Le estábamos pidiendo lo que peor hace.
Un LLM sí puede razonar sobre situaciones descritas en palabras. Por ejemplo: «el mercado viene en tendencia fuerte y hay un dato de empleo en veinte minutos». Ese tipo de información se puede sopesar con criterio, y esa es su cancha. En esta parte le damos al motor ese contexto: un lector de régimen de mercado calculado en el código (tendencia, rango, volatilidad) y unas ventanas de noticias de alto impacto configurables, los dos metidos en un prompt más rico. Además le pedimos a la IA que devuelva una señal de riesgo, y agregamos un gating: no operar pegado a una noticia, ni cuando las IA coinciden en que el contexto es peligroso.
Este es un marco educativo, no un sistema rentable. La salida de la IA es orientación, no es consejo financiero. Pruébalo en una cuenta demo.
Por qué el edge del LLM está en el contexto, no en el tick
Vale la pena detenerse en esto porque cambia todo el diseño. Un EA de reglas fijas es ciego al contexto: hace lo mismo en un viernes de NFP que en un martes muerto. La promesa de meter una IA era cubrir ese hueco, pero solo se cumple si le damos algo que un humano experto miraría.
Un trader con experiencia, antes de apretar el gatillo, se pregunta dos cosas que no están en el precio del último tick: ¿en qué régimen estoy? (¿una tendencia que conviene seguir, o un rango donde conviene esperar?) y ¿hay algo en el calendario que pueda darlo vuelta en los próximos minutos?. Esas dos preguntas son verbales, contextuales, y se contestan razonando, exactamente lo que un LLM puede hacer. Predecir el próximo tick, no.
Un ejemplo concreto de la diferencia: preguntarle a un LLM «el EUR/USD está en 1.0850, ¿sube o baja en el próximo minuto?» es pedirle adivinación pura, y va a contestar con un número inventado pero con tono seguro. En cambio, preguntarle «el mercado viene lateral, con poca volatilidad, y en diez minutos sale la decisión de tasas de la Fed, ¿conviene abrir una posición?» es pedirle un juicio que cualquier trader con experiencia daría sin dudar: esperar. Lo segundo es lenguaje y contexto; lo primero es una serie temporal que el modelo no puede ver. Toda la Parte 3 consiste en mover la pregunta de lo primero a lo segundo.
Así que el plan de esta parte es simple: dejamos de pedirle a la IA que adivine el tick y empezamos a pedirle que razone el contexto. Para eso, primero hay que calcular ese contexto y escribírselo.
Los parámetros y el estado nuevos
Sobre los inputs de las Partes 1 y 2, la Parte 3 agrega dos grupos: el del régimen y el de las noticias con su gating.
//--- context: market regime (Part 3) input int InpAdxPeriod = 14; // ADX period (trend strength) input double InpAdxTrendLevel = 25.0; // ADX above this = trending, below = ranging input int InpMaPeriod = 50; // EMA period for trend direction //--- context: news windows + gating (Part 3) input string InpNewsWindows = "13:30-14:00"; // High-impact windows, server time, comma-separated HH:MM-HH:MM input int InpNewsBufferMin = 15; // Treat a window as imminent this many minutes before it input bool InpBlockOnNews = true; // Do not open trades during/near a news window input bool InpBlockOnAiRisk = true; // Do not open trades when the AI majority flags RISK=HIGH
Y el AIResponse estándar —el que todas las IA terminan devolviendo— suma dos campos sobre los de la Parte 2: la bandera de riesgo y una razón corta.
//--- Standardized response (Part 3 adds the risk flag and a short reason) struct AIResponse { ENUM_AI_PROVIDER provider; ENUM_AI_SIGNAL signal; double confidence; bool riskHigh; // the AI judged the context risky (news / regime) string reason; // short free-text justification bool valid; };
Leer el régimen de mercado en el código
El régimen lo calculamos nosotros, con indicadores, y se lo pasamos a la IA ya procesado. Usamos tres lecturas: ADX para la fuerza de la tendencia, el ATR actual contra su propio promedio para la volatilidad, y la pendiente de una media móvil para la dirección.
//+------------------------------------------------------------------+ //| NEW - read the market regime in code, as text for the prompt | //+------------------------------------------------------------------+ string RegimeContext() { double buf[]; //--- trend strength: ADX main line (buffer 0) double adxVal = 0.0; if(CopyBuffer(g_adxHandle, 0, 0, 1, buf) == 1) adxVal = buf[0]; //--- volatility: current ATR vs its own average over recent bars double volRatio = 1.0; ArraySetAsSeries(buf, true); int n = CopyBuffer(g_atrHandle, 0, 0, 50, buf); if(n > 1) { double sum = 0.0; for(int i = 0; i < n; i++) sum += buf[i]; double avg = sum / n; if(avg > 0.0) volRatio = buf[0] / avg; } //--- direction: EMA now vs EMA a few bars ago double maNow = 0.0, maPast = 0.0, m[]; if(CopyBuffer(g_maHandle, 0, 0, 1, m) == 1) maNow = m[0]; if(CopyBuffer(g_maHandle, 0, 5, 1, m) == 1) maPast = m[0]; string vol = (volRatio >= 1.5) ? "high" : (volRatio <= 0.7 ? "low" : "normal"); if(adxVal >= InpAdxTrendLevel) { string dir = (maNow >= maPast) ? "up" : "down"; return(StringFormat("Regime: trending %s, %s volatility (ADX %.0f, ATR %.1fx its average).", dir, vol, adxVal, volRatio)); } return(StringFormat("Regime: ranging, %s volatility (ADX %.0f, ATR %.1fx its average).", vol, adxVal, volRatio)); }
La idea es traducir números en una frase que la IA pueda usar. Si el ADX supera el umbral (InpAdxTrendLevel, 25 por defecto), estamos en tendencia, y la pendiente de la EMA dice si es hacia arriba o hacia abajo; si no, es rango. La volatilidad sale de comparar el ATR de ahora con su promedio reciente: si está 1.5 veces por encima, el mercado está agitado, y eso es un dato que la IA debería tener en cuenta. El resultado es una línea como Regime: trending up, high volatility (ADX 31, ATR 1.8x its average). Un detalle de MQL5: al leer la serie del ATR la ponemos como serie temporal con ArraySetAsSeries, para que el índice 0 sea la barra actual y no la más vieja.
El valor no está en cada indicador por separado, sino en traducirlos a una sola frase legible para la IA. «Trending up, high volatility» le dice mucho más a un modelo de lenguaje que tres números aislados: le da el marco para sopesar si conviene seguir la tendencia o desconfiar de un movimiento sobre-extendido. Y como esto lo calculamos nosotros en el código, es determinista y gratis: no malgastamos una llamada de IA en algo que un indicador resuelve mejor y más barato. La IA recibe el contexto ya procesado y se concentra en lo suyo: el juicio.
Las ventanas de noticias, sin depender del broker
Las noticias son la otra mitad del contexto. MQL5 tiene un calendario económico incorporado, pero su contenido depende del broker: en algunas cuentas viene completo y en otras vacío, así que un EA que dependa de él no es portable. Para esta parte elijo algo más simple y que funciona en cualquier cuenta: ventanas horarias configurables. Defines en qué horarios (del servidor, los que ves en el gráfico) suele haber datos de alto impacto para tu símbolo, y el EA las respeta.
//+------------------------------------------------------------------+ //| NEW - convert "HH:MM" into minutes since midnight (-1 if bad) | //+------------------------------------------------------------------+ int HhMmToMin(string s) { StringTrimLeft(s); StringTrimRight(s); int colon = StringFind(s, ":"); if(colon < 0) return(-1); int h = (int)StringToInteger(StringSubstr(s, 0, colon)); int mm = (int)StringToInteger(StringSubstr(s, colon + 1)); if(h < 0 || h > 23 || mm < 0 || mm > 59) return(-1); return(h * 60 + mm); } //+------------------------------------------------------------------+ //| NEW - news window state: 0 clear, 1 imminent, 2 active | //+------------------------------------------------------------------+ int NewsState(int &minsToStart) { minsToStart = -1; if(StringLen(InpNewsWindows) == 0) return(0); MqlDateTime dt; TimeToStruct(TimeCurrent(), dt); // server time, as shown on the chart int nowMin = dt.hour * 60 + dt.min; string wins[]; int k = StringSplit(InpNewsWindows, ',', wins); int state = 0; for(int i = 0; i < k; i++) { int dash = StringFind(wins[i], "-"); if(dash < 0) continue; int start = HhMmToMin(StringSubstr(wins[i], 0, dash)); int end = HhMmToMin(StringSubstr(wins[i], dash + 1)); if(start < 0 || end < 0) continue; if(nowMin >= start && nowMin <= end) // inside a window: wins outright { minsToStart = 0; return(2); } if(nowMin < start && (start - nowMin) <= InpNewsBufferMin) { state = 1; if(minsToStart < 0 || (start - nowMin) < minsToStart) minsToStart = start - nowMin; } } return(state); }
InpNewsWindows es un texto como "13:30-14:00,15:00-15:30": una o varias ventanas separadas por coma. NewsState devuelve tres estados: 2 si el reloj del servidor está dentro de una ventana, 1 si una ventana arranca dentro de los próximos InpNewsBufferMin minutos (por defecto 15), y 0 si no hay nada cerca. Trabajar en hora del servidor evita el lío de zonas horarias: usas los mismos horarios que ves en el gráfico. Una función pequeña, NewsContext, convierte ese estado en una frase para el prompt:
//+------------------------------------------------------------------+ //| NEW - news context as text for the prompt | //+------------------------------------------------------------------+ string NewsContext() { int m; int st = NewsState(m); if(st == 2) return("News: a scheduled high-impact window is ACTIVE now."); if(st == 1) return(StringFormat("News: a scheduled high-impact window starts in about %d min.", m)); return("News: no scheduled high-impact window in the near term."); }
El prompt enriquecido: precio + régimen + noticias
Ahora juntamos todo. El prompt de la Parte 1 daba precio y dos cierres; el de la Parte 3 agrega el régimen y las noticias, y —esto es lo importante— le cambia la consigna a la IA: que razone sobre el régimen y las noticias, no sobre el próximo tick. Y le pedimos una respuesta más rica: además de la señal y la confianza, una bandera de riesgo y una razón corta.
//+------------------------------------------------------------------+ //| NEW - richer prompt: price + regime + news, reason not the tick | //+------------------------------------------------------------------+ string BuildPrompt(const string symbol) { double bid = SymbolInfoDouble(symbol, SYMBOL_BID); double close1 = iClose(symbol, PERIOD_H1, 1); double close2 = iClose(symbol, PERIOD_H1, 2); string price = StringFormat("Symbol: %s. Price: %.5f. H1 closes: %.5f, %.5f.", symbol, bid, close1, close2); string regime = RegimeContext(); string news = NewsContext(); string instruction = "You are a trading analyst. Reason about the market REGIME and the NEWS context above, " "not about the next tick. If a high-impact event is active or imminent, prefer HOLD and set RISK=HIGH. " "Reply ONLY in this exact format, no extra text: " "SIGNAL=BUY|SELL|HOLD;CONFIDENCE=0-100;RISK=LOW|HIGH;REASON=up to 8 words"; return(StringFormat("%s %s %s %s", price, regime, news, instruction)); }
El cambio de consigna es sutil pero decisivo. Antes la IA contestaba sobre algo que no podía saber; ahora contesta sobre algo que está descrito en palabras y que sí puede sopesar. Le pedimos explícitamente que, si hay un evento activo o inminente, prefiera HOLD y marque RISK=HIGH. El formato de respuesta crece de SIGNAL=…;CONFIDENCE=… a SIGNAL=…;CONFIDENCE=…;RISK=…;REASON=…. Toda la maquinaria de conexión, parseo base y voto de las Partes 1 y 2 sigue igual; solo cambió lo que entra y lo que pedimos que salga.
Parsear la respuesta más rica
Como la respuesta ahora trae dos campos nuevos, el AIResponse estándar suma una bandera de riesgo y la razón, y el parser los extrae con el mismo ExtractTag que ya teníamos.
//+------------------------------------------------------------------+ //| Convert the AI text into an AIResponse (Part 3: + RISK, REASON) | //+------------------------------------------------------------------+ AIResponse ParseAIText(ENUM_AI_PROVIDER provider, const string aiText) { AIResponse r; r.provider = provider; r.valid = false; r.signal = AI_SIGNAL_HOLD; r.confidence = 0.0; r.riskHigh = false; r.reason = ""; string sig = ExtractTag(aiText, "SIGNAL"); string conf = ExtractTag(aiText, "CONFIDENCE"); if(sig == "") return(r); if(sig == "BUY") r.signal = AI_SIGNAL_BUY; else if(sig == "SELL") r.signal = AI_SIGNAL_SELL; else r.signal = AI_SIGNAL_HOLD; r.confidence = (double)StringToInteger(conf); r.riskHigh = (ExtractTag(aiText, "RISK") == "HIGH"); r.reason = ExtractTag(aiText, "REASON"); r.valid = true; return(r); }
Nada nuevo en la técnica: reusamos ExtractTag, que lee el valor entre CLAVE= y el ; siguiente. Lo que importa es que ahora cada voto sabe, además de la dirección y la confianza, si esa IA considera que el contexto es riesgoso. Esa bandera es la que alimenta el segundo filtro.
Gating: no operar contra las noticias
Tener el contexto no sirve de nada si igual operamos en el peor momento. Por eso agregamos dos filtros que pueden vetar una operación, cada uno desde un ángulo distinto.
El primero es en código: si estamos dentro de una ventana de noticias o muy cerca, ni siquiera consultamos a las IA (ahorramos las cuatro llamadas) y no operamos. El segundo es de las IA: si la mayoría de los modelos que contestaron marcaron RISK=HIGH, nos abstenemos aunque la votación diera una dirección. Ese segundo filtro es una función pequeña:
//+------------------------------------------------------------------+ //| NEW - true if half or more of the valid AIs flagged RISK=HIGH | //+------------------------------------------------------------------+ bool AiRiskMajority(const AIResponse &votes[]) { int valid = 0, high = 0; for(int i = 0; i < ArraySize(votes); i++) { if(!votes[i].valid) continue; valid++; if(votes[i].riskHigh) high++; } return(valid > 0 && high * 2 >= valid); }
Los dos filtros se complementan: el de código es una regla dura y barata (sabes que a las 13:30 hay un dato), y el de las IA es flexible (capta lo que no anotaste, porque la IA lo razonó a partir del régimen y el contexto). Tener los dos es más robusto que cualquiera solo.
Juntando todo en el EA
OnTimer ejecuta la secuencia:
- evalúa las predicciones previas (el aprendizaje de la Parte 2),
- aplica el filtro de noticias por código,
- consulta a las IA con el prompt enriquecido,
- vota,
- aplica el filtro de riesgo de las IA,
- solo si pasó los dos filtros, opera con el SL/TP y el lote de la Parte 2.
//+------------------------------------------------------------------+ //| Timer function | //+------------------------------------------------------------------+ void OnTimer() { //--- 1) grade past predictions so the engine keeps learning ResolvePredictions(); if(PositionSelect(_Symbol)) return; //--- 2) news gating in code: don't even ask the AIs during/near a window int minsToStart; int ns = NewsState(minsToStart); if(InpBlockOnNews && ns > 0) { PrintFormat("Skip: scheduled news window %s.", (ns == 2 ? "active" : "imminent (" + (string)minsToStart + " min)")); return; } //--- 3) ask every AI (now with regime + news context) and remember each call AIResponse votes[]; CollectVotes(_Symbol, votes); RecordPredictions(votes); //--- 4) weighted decision (confidence x learned accuracy) AIResponse decision = VoteDecisionWeighted(votes, InpQuorum, InpMinScore); if(!decision.valid || decision.signal == AI_SIGNAL_HOLD) return; //--- 5) news gating by the AIs: skip if the majority judged the context risky if(InpBlockOnAiRisk && AiRiskMajority(votes)) { Print("Skip: AI majority flagged RISK=HIGH (regime/news)."); return; } //--- 6) risk management: enforced SL/TP and confidence-based lot double price = (decision.signal == AI_SIGNAL_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID); double sl, tp; if(!ComputeSLTP(decision.signal, price, sl, tp)) return; double lot = LotByConfidence(decision.confidence, MathAbs(price - sl)); if(decision.signal == AI_SIGNAL_BUY) trade.Buy(lot, _Symbol, 0, sl, tp, "MultiAI P3"); else trade.Sell(lot, _Symbol, 0, sl, tp, "MultiAI P3"); PrintFormat("Decision %s | conf %.1f | lot %.2f | %s | hitrate O%.2f C%.2f G%.2f D%.2f", SignalToStr(decision.signal), decision.confidence, lot, RegimeContext(), g_hitRate[0], g_hitRate[1], g_hitRate[2], g_hitRate[3]); }
Fíjate en el orden de los filtros: primero el de código (paso 2), que es gratis y corta antes de gastar las llamadas; después la consulta y el voto; y por último el de las IA (paso 5). Los handles de ADX y EMA se crean en OnInit junto al de ATR de la Parte 2 y se liberan en OnDeinit, como cualquier indicador.
Un ejemplo: viéndolo decidir
Pongámosle números. El motor despierta en XAUUSD un día tranquilo, sin noticias cerca. El régimen calculado da ADX 31, la EMA con pendiente hacia arriba y el ATR 1.8 veces su promedio. El prompt que sale es algo así (recortado en la parte de la consigna):
Symbol: XAUUSD. Price: 2018.40. H1 closes: 2016.90, 2014.20. Regime: trending up, high volatility (ADX 31, ATR 1.8x its average). News: no scheduled high-impact window in the near term. You are a trading analyst. Reason about the market REGIME and the NEWS context above, not about the next tick. ... SIGNAL=BUY|SELL|HOLD;CONFIDENCE=0-100;RISK=LOW|HIGH;REASON=up to 8 words
Ahora que tienen el régimen adelante, las cuatro IA contestan algo coherente con el contexto:
OpenAI: SIGNAL=BUY;CONFIDENCE=72;RISK=LOW;REASON=strong uptrend, no news Claude: SIGNAL=BUY;CONFIDENCE=68;RISK=LOW;REASON=trend intact, follow it Gemini: SIGNAL=HOLD;CONFIDENCE=40;RISK=LOW;REASON=extended, wait for pullback DeepSeek: SIGNAL=BUY;CONFIDENCE=61;RISK=LOW;REASON=momentum up
El voto ponderado por el acierto aprendido (Parte 2) da COMPRA; ninguna marcó RISK=HIGH, así que la decisión pasa los dos gates y se abre con el SL/TP basado en ATR. Fíjate que Gemini se abstuvo (ve la tendencia sobre-extendida) y eso está bien: el voto no necesita unanimidad, y su HOLD baja un poco la confianza promedio, que a su vez achica el lote.
Ahora cambiemos una sola cosa del escenario: faltan 12 minutos para tu ventana de noticias de las 13:30. El motor, en el paso de código, ni siquiera consulta a las IA: imprime Skip: scheduled news window imminent (12 min) y se queda afuera, ahorrando las cuatro llamadas. Y si desactivas ese gate, las IA igual verían News: a scheduled high-impact window starts in about 12 min en el prompt, marcarían RISK=HIGH, y el segundo gate las frenaría lo mismo. Dos redes, una detrás de la otra.
Ese contraste es toda la idea de la Parte 3: la señal técnica no cambió —misma tendencia, mismo ADX—, lo que cambió fue el contexto, y el motor decidió distinto por eso.
Elegir los parámetros para tu símbolo
Un par de criterios para configurarlo donde lo vayas a usar:
- Ventanas de noticias (InpNewsWindows). Carga los horarios de los datos que mueven tu símbolo, en hora del servidor (la que ves en el gráfico). Para el oro y los pares con dólar, las sospechosas de siempre son la apertura de Nueva York y los grandes números de EE.UU. (empleo, inflación, decisiones de tasas): mira un calendario económico, pasa esas horas a la hora de tu servidor y arma la lista "HH:MM-HH:MM" separada por comas. InpNewsBufferMin (15 por defecto) decide cuánto antes frenas: más alto, más conservador.
- Umbral de tendencia (InpAdxTrendLevel). El 25 es el valor clásico de ADX para decir «hay tendencia». Si tu símbolo es muy ruidoso, súbelo a 30 para exigir tendencias más limpias; si lo quieres más sensible, bájalo a 20. Lo que importa no es el número exacto, sino que la etiqueta que recibe la IA sea coherente con lo que ves en el gráfico.
- Los dos gates (InpBlockOnNews, InpBlockOnAiRisk). Se activan y desactivan por separado. Con los dos en false tienes el comportamiento de la Parte 2 (sin gating de contexto); activándolos de a uno puedes aislar cuánto aporta cada capa antes de confiar en las dos juntas.
Cómo usarlo
- Completa keys.txt y autoriza las cuatro URLs de las API en WebRequest, como en las partes anteriores.
- Adjunta el EA a un gráfico. Antes de arrancar, define tus ventanas de noticias en InpNewsWindows (hora del servidor, formato HH:MM-HH:MM separadas por coma) y revisa el resto de parámetros: InpAdxPeriod, InpAdxTrendLevel, InpMaPeriod, InpNewsBufferMin, InpBlockOnNews, InpBlockOnAiRisk.
- Mira el registro (log) de Asesores Expertos: cuando un filtro veta una operación verás una línea «Skip: …» que dice por qué; cuando opera, imprime la decisión, el lote, el régimen leído y los hit-rates.
- Para ver el efecto del contexto, compáralo con la Parte 2 (sin régimen ni noticias) en el mismo símbolo y horario.
Resultado esperado
(Captura: el log de Asesores Expertos mostrando una decisión con su régimen leído y, en otra línea, un "Skip" por ventana de noticias o por RISK=HIGH de las IA. Tómala con MetaTrader 5 en inglés.)
Limitaciones
- El régimen es una lectura simple (ADX + ATR + pendiente de EMA). Sirve para darle contexto a la IA, no es una clasificación de mercado infalible; en transiciones (de rango a tendencia) puede quedar a mitad de camino.
- Las ventanas de noticias son manuales: tú cargas los horarios. Es portable y predecible, pero no se entera de un evento no programado. Atarlo al calendario económico de MQL5 sería el paso automático, a costa de depender del broker.
- Que la IA razone el contexto no garantiza que acierte: reduce las operaciones tomadas en el peor momento, que ya es valioso, pero no convierte el contexto en rentabilidad.
- Marco educativo y de diagnóstico, no consejo financiero.
Conclusión
Dejamos de pedirle a las IA lo que peor hacen (adivinar el próximo tick) y empezamos a darles lo que sí pueden razonar: el régimen de mercado leído en el código y unas ventanas de noticias que defines tú, todo dentro de un prompt más rico que también devuelve una bandera de riesgo. Sobre esa base, añadimos un gating de dos capas: una regla por horario y un filtro basado en el riesgo indicado por la IA. Así, el motor evita operar cuando el contexto pesa más que la señal. El motor ahora no solo aprende en qué IA confiar y opera con riesgo controlado (Partes 1 y 2): además decide con el contexto adelante.
Queda una pregunta honesta que vengo posponiendo: ¿todo este aparato multi-IA realmente le gana a una sola IA, o nos estamos contando un cuento? En la Parte 4 lo vamos a medir — journal de cada decisión, scorecard por proveedor, y la comparación cara a cara de multi-IA contra single-IA, con el costo en la mano.
Aclaración: marco educativo y de diagnóstico. No es consejo financiero.
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.
Este artículo ha sido escrito por un usuario del sitio web y refleja su punto de vista personal. MetaQuotes Ltd. no se responsabiliza de la exactitud de la información ofrecida, ni de las posibles consecuencias del uso de las soluciones, estrategias o recomendaciones descritas.
Características del Wizard MQL5 que debe conocer (Parte 68): Uso de patrones de TRIX y Williams Percent Range con una red de núcleo coseno
Del básico al intermedio: Colas, listas y árboles (III)
De novato a experto: Desmitificando los niveles ocultos de retroceso de Fibonacci
Simulación de mercado: Position View (X)
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Usted acepta la política del sitio web y las condiciones de uso