Tema: Ayuda con la lógica

Hola a todos,

Ya casi he terminado mi método de creación del EA de Little Big Man, pero estoy atascado en un punto de lógica.

He adjuntado mi código a continuación porque puedes ver, y esto es todo sobre la función Martingale ().

Todo el propósito de este EA es obtener ganancias modestas, cuando las pequeñas ganancias se queden estancadas (rezagados), luego saldré de estas a 200 (o 'X') pips del precio de entrada.

Tengo mi configuración lógica por defecto, ya que cada 200 pips, el comercio se cerrará, luego se abrirá un nuevo comercio en su ubicación 1,5 veces multiplicado.

Por lo tanto, he calculado una ganancia de BE para ese comercio perdido. Pero:

1) El cálculo no está funcionando correctamente, ya que estoy recuperando solo 15.50 después de la reducción de 20.00 en el primer nivel;

2. No puedo recuperar si los niveles han pasado. L2 se ingresa a 200 pips y podría ser .02 lotes, L3 se ingresa a 400 pips y podría ser .03 lotes, L4 se ingresa a 600 pips y puede ser .05 lotes, etc. No se acercará ni siquiera a la recuperación.

¿Alguien por favor me puede ayudar con cómo realizar esto? Gracias.

Aquí está la versión corta de lo que he hecho hasta ahora:

NewMultiplierTakeProfit = ((OrderOpenPrice () * OrderLots ()) (Ask * NewLotSize))((OrderLots () NewLotSize));/Calcule el nuevo beneficio

Código insertado/ --------------------------------------------- --------------------- /| REAV_EA. Mq4 |/| Copyright © 2010, Kenny Hubbard |/| http://www.compu-forex.com |/ ----------------------------------------------- ------------------- #property copyright © 2010, Kenny Hubbard # enlace de propiedad http://www.compu-forex.com #define NO_RESULT -10 extern int MagicNumber = 100; extern doble Eq_StopLoss = 10000; Doble riesgo externo = 0.01; externo doble Trail_From = 8; externo doble Trail_Max = 50.0; extern doble Trail_Percent = 20; extern double Grid_Size = 13; extern int MinimumReEntry = 200; Multiplicador externo doble = 1.5; extern int MinimumProfit = 1; int D_Factor = 1, LotDigits = 1, Slippage = 3, Retries = 10; Double Anchor, Pip, Grid_Min = 0, Grid_Max = 0, Grid_Ord_OpenPrice # 91; # 93; # 91; two # 93 ;, Auto_Grid, NewMultiplierTakeProfit = 0, NewLotSize = 0; string Order_Cmt = Little Big Man EA;/ ----------------------------------------------- ------------------- /| servicio de inicialización pro |/ ----------------------------------------------- ------------------- int init () Pip = Etapa;/- si (Dígitos == 3/ ------------------------------------- ----------------------------- /| pro función de desinicialización |/ ---------- -------------------------------------------------- ------ int deinit ()/-/- return (0);/ ----------------------- ------------------------------------------- /| función de inicio experta |/ ---------------------------------------------- -------------------- int start () int result = NO_RESULT;/- if (! OrdersTotal ()) Print (Haciendo un primer comercio); OrderSend (Symbol (), 4, Get_Lots (Risk), NormalizeDouble (Ask Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Blue); OrderSend (Symbol (), 5, Get_Lots (Risk), NormalizeDouble (Bid-Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Blue); Update_Grid (Grid_Min, Grid_Max); resultado Check_For_Trade (Grid_Min, Grid_Max); if (result! = NO_RESU LT) Do_Trade (resultado); Trail_Stop (); Martingale (); dual BuyLevel = (Bid - (MinimumReEntry * Pip)); dual SellLevel = (Ask (MinimumReEntry * Pip)); Comentario (Nivel de compra :, (Nivel de compra), \ n, Nivel de cotización:, (Nivel de venta), \ n, Oferta:, Oferta, \ n, Pregunta:, Preguntar, \ n, Reingreso mínimo :, MinimumReEntry, \ n/Point :, NormalizeDouble (MinimumReEntry * Point, 10), \ n,/Pip :, NormalizeDouble (MinimumReEntry * Pip, 10));/- return (0);/ ----------------------------------------------- ------------------- void Martingale ()/Función para eliminar las órdenes actuales de rezagados para (int xo = 0; xo lt; OrdersTotal (); xo ) if (OrderSelect (xo, SELECT_BY_POS)) RefreshRates (); if (OrderType () == 0) if (OrderOpenPrice () gt; = (Bid (MinimumReEntry * Pip))) NewLotSize = Multiplicador * OrderLots (); NewMultiplierTakeProfit = ((OrderOpenPrice () * OrderLots ()) (Ask * NewLotSize))((OrderLots () NewLotSize));/Calcule el nuevo beneficio si (OrderClose (OrderTicket (), OrderLots (), Ask, 99, rojo)) OrderSend (Symbol (), 0, NormalizeDouble (NewLotSize, LotDigits), Ask, Slippage, 0, NormalizeDouble ((NewMultiplierTakeProfit (MinimumProfit * Pip)), 10), Multiplied Order, MagicNumber, 0, Blue); if (OrderType () == 1) if (OrderOpenPrice () lt; = (Ask - (MinimumReEntry * Pip))) NewLotSize = Multiplicador * OrderLots (); NewMultiplierTakeProfit = ((OrderOpenPrice () * OrderLots ()) (Bid * NewLotSize))(OrderLots () NewLotSize);/Calcule new take profit if (OrderClose (OrderTicket (), OrderLots (), Ask, 99, Rojo)) OrderSend (Symbol (), 1, NormalizeDouble (NewLotSize, LotDigits), Bid, Slippage, 0, NormalizeDouble ((NewMultiplierTakeProfit- (MinimumProfit * Pip)), 10), Multiplied Order, MagicNumber, 0, Blue);/ ----------------------------------------------- ------------------- void Update_Grid (double Min, double Max) int Order_Cnt = 0, Grid_Num = 0; para (int I = 0; ilt; OrdersTotal (); I ) if (OrderSelect (I, SELECT_BY_POS)) if (OrderType () gt; 3) Order_Cnt ; else Print (Error al seleccionar Orden = GetLastError ()); ArrayResize (Grid_Ord_OpenPrice, Order_Cnt); ArrayInitialize (Grid_Ord_OpenPrice, 0.0); para (I = 0; ilt; OrdersTotal (); I ) if (OrderSelect (I, SELECT_BY_POS)) if (OrderType () gt; 3) Grid_Ord_OpenPrice # 91; Grid_Num # 93; # 91; 0 # 93; = OrderOpenPrice (); Grid_Num ; else Print (Error al seleccionar Orden = GetLastError ()); ArraySort (Grid_Ord_OpenPrice); Min = Grid_Ord_OpenPrice # 91; 0 # 93; # 91; 0 # 93 ;; Max = Grid_Ord_OpenPrice # 91; Order_Cnt-1 # 93; # 91; 0 # 93 ;;/ ----------------------------------------------- ------------------- int Check_For_Trade (doble Min, double Max) si (Ask gt; = Max Auto_Grid) devuelve (OP_BUYSTOP); if (Bid lt; = Min - Auto_Grid) return (OP_SELLSTOP); return (NO_RESULT);/ ----------------------------------------------- ------------------- void Do_Trade (int Buy_or_Sell) caso de cambio (Buy_or_Sell) OP_BUYSTOP: int ticket = OrderSend (Symbol (), OP_BUYSTOP, NormalizeDouble (Get_Lots (Risk) , LotDigits), NormalizeDouble (Ask Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Green);Delete_Opposite_Trade (5); ticket = OrderSend (Symbol (), OP_SELLSTOP, NormalizeDouble (Get_Lots (Risk), LotDigits), NormalizeDouble (Bid - 2 * Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Red); descanso; caso OP_SELLSTOP: ticket = OrderSend (Symbol (), OP_SELLSTOP, NormalizeDouble (Get_Lots (Risk), LotDigits), NormalizeDouble (Bid - Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Red); Delete_Opposite_Trade (4); ticket = OrderSend (Symbol (), OP_BUYSTOP, NormalizeDouble (Get_Lots (Risk), LotDigits), NormalizeDouble (Ask 2 * Auto_Grid, Digits), Slippage, 0,0, Order_Cmt, MagicNumber, 0, Green); descanso; por defecto: Alert (Se desconoce el tipo de orden); descanso; regreso;/ ----------------------------------------------- ------------------- void Delete_Opposite_Trade (int Del_B_S) para (int I = 0; ilt; OrdersTotal (); I ) OrderSelect (I, SELECT_BY_POS); if (OrderMagicNumber () == MagicNumber) if (OrderType () == Del_B_S) OrderDelete (OrderTicket ());/ ----------------------------------------------- ------------------- doble Get_Lots (doble lRisk) doble Lots = AccountEquity () * lRisk100/1000; if (MarketInfo (Symbol (), MODE_MINLOT) gt; Lotes) Lotes = MarketInfo (Symbol (), MODE_MINLOT); if (MarketInfo (Symbol (), MODE_MAXLOT) lt; Lotes) Lotes = MarketInfo (Symbol (), MODE_MAXLOT); retorno (Lotes);/ ----------------------------------------------- ------------------- bool Trail_Stop () {bool mod, lresult = false; doble My_Profit, My_Trail, My_SL, lTrail_Max, lTrail_From, Stop_Level;/- para (int I = 0; I lt; OrdersTotal (); I ) {if (OrderSelect (I, SELECT_BY_POS, MODE_TRADES)) {if (OrderMagicNumber () == MagicNumber) {RefreshRates ();/****************************** HARDCODED PARA AHORA HASTA MEJOR SOLUCIÓN, A.01 LOTES, POR LA CUENTA DE 10K ¡FUNCIONA! ************************* if (OrderLots () lt; 0.02) lTrail_Max = Trail_Max * Pip; lTrail_From = Trail_From * Pip; Stop_Level = MarketInfo (OrderSymbol (), MODE_STOPLEVEL) * Pip; Caso de cambio (OrderType ()) OP_BUY: My_Profit = Bid ​​- OrderOpenPrice (); My_Trail = MathMin (My_Profit * Trail_Percent100, lTrail_Max); My_SL = NormalizeDouble (OrderClosePrice () - My_Trail, Digits); lresult = true; if (My_Profit gt; lTrail_From) if (OrderClosePrice () - My_SL gt; Stop_Level) if (OrderStopLoss () lt; My_SL Split; case OP_SELL: My_Pp.P.P.P. ); My_SL = NormalizeDouble (Ask My_Trail, Digits); lresult = true; if (My_Profit gt; lTrail_From) if (My_SL - OrderClosePrice () gt; Stop_Level) break (! (! Mod GetLastError () gt; 1) Print ( Error al ingresar al final del rastreo - Error GetLastError ());}} else Imprimir (Error sel orden de detección); }/- return (lresult); }

Iniciado por ;

Hola Gil, no estoy seguro de si eso ayuda, pero pruébalo todo. Un par de cosas que quizás conozca: - Tenga cuidado de usar OrdersTotal () directamente en un bucle que involucre cambiar la cantidad de órdenes, ya que esto puede llevar al caos en su vida en algún momento. Hace para un error que puede ser muy difícil de descubrir. La razón de esto es si tienes un bucle que cuenta desde ...

Kenny, muchas gracias. Millones de veces más. Sí, pensé que mi lógica era similar a la tuya, aunque no del todo correcta. Supongo que en el caso de que simplemente lo expliques, entonces tiene sentido, pero ponerlo en el código no siempre parece simple.
Sé lo que dices sobre los pedidos totales, etc. Tiene sentido. Han pasado 10 años desde que programé CUALQUIER COSA, ¡por lo tanto, las telarañas están desapareciendo!
¡No podría hacer esto sin ti chico! Permitidme que me haga una idea de esto y cuadrarlo. Aloha! PD Es posible que tenga otra pregunta para usted en el caso de que tenga tiempo para hacerlo. No estoy seguro de que lo esté haciendo bien, aunque he encontrado un par de maneras. ¿Cómo prepararía la cuadrícula en lógica básica para verificar pedidos dentro de 15 pips, y luego continuar con la cuadrícula a 15 pips? Pondré mi propio código y veré lo que piensas, pero de la forma en que lo hiciste, tengo la sensación de que haré más problemas que cualquier otra cosa, ¡pero lo intentaré! No hay daño, no hay falta!

Iniciado por ;

PD Es posible que tenga otra pregunta para usted en el caso de que tenga tiempo para hacerlo. He producido un par de formas, pero no estoy seguro de que lo esté haciendo correctamente. ¿Cómo prepararía la lógica básica de la cuadrícula para verificar pedidos dentro de 15 pips y luego alejar la cuadrícula 15 pips?

Hola Gil, estoy seguro de que encontrarás que no hay una manera correcta de hacer estas cosas ... si uno de los medios por los cuales has producido funciona debes correr con esto. Siempre tiene la opción de volver a visitar un cliente habitual más adelante y con frecuencia encontrará formas de mejorar, pero mi primera regla es hacer lo que funcione. De todos modos, personalmente cargaría los OrderOpenPrices en una matriz y simplemente inspeccionaría cada uno comparándolos con el precio actual. Una razón para este enfoque es que en el caso de que marque la función Update_Grid, el orden se cargará en la matriz, de manera que la regularización simplemente se expandirá. Ahora veo lo que está haciendo con el TakeProfit ... Simplemente estaba echando un vistazo a la pérdida de la última operación. Se cumple su método. No puedo pensar en la fórmula de la mano ... voy a tener que ir a pensar en esto. Si desea hacerlo simple, use una variable que agregue las pérdidas en los rezagados y luego la convierta en un número de pips TP dependiendo del volumen de recuperación actual. El principal problema es saber exactamente en qué se basan las reducciones de $$ en el último tamaño de lote. Usted querría almacenar el desarrollo o calcularlo. Es fácil de entender que 15 lotes se dividen en 1 2 4 8, pero es otra cosa para calcularlo.

Iniciado por ;

Coloco en la sección init () el siguiente código: MinimumReEntry * = Pip; MinimumProfit * = Pip;

Usted ha declarado como enteros, así que cámbielo al doble. Puede o no abordar el problema, pero comience con los errores obvios.

Iniciado por ;

Sé lo que dices sobre órdenes completas, etc. Tiene sentido.

A riesgo de azotar a un caballo muerto, simplemente necesito señalar un error de mi parte. La forma en que lo hice con todos los pedidos de bucle en cuenta regresiva, está bien usar OrdersTotal () porque está asignando el valor al comienzo del ciclo en lugar de usarlo como un estado. Si cuenta a partir de 0, debe asignar una variable intermedia para mantener la cuenta de orden estática. Creo que esa es la razón por la que siempre afirman que es una buena práctica confiar en los bucles de sus pedidos en lugar de hacerlo. Teniendo en cuenta que se puede eliminar la variable Total_Orders, ya que es una pérdida de tiempo y de tarjeta de memoria. Otro error que he creado (no relevante para esta discusión) .... Las variables Grid_Min y Grid_Max deben anunciarse en la función Inicio () no en la división global.

Iniciado por ;

Tendré que ir a pensar en esto. Si desea que sea sencillo, use una variable que aumente las pérdidas de sus rezagados y la convierta en una cantidad de pips TP según la cantidad de recuperación actual. El problema es comprender en qué se basan las reducciones en el nuevo tamaño de lote. Calcúlelo, o necesitaría almacenar la progresión. Es fácil ver que 15 lotes se dividen en 1 2 4.

Kenny, esto será probablemente sobre mis pensamientos matemáticos. Sin embargo, ¿qué piensa acerca de algo como: Void CalculatePreviousLosses (NewLotSize) Recorra NewLotSizeMultiplier hasta que llegue a StartingLotSize (Get_Lots work), contando cada vez que realiza un bucle, multiplique cada uno por MinimumReEntry para recibir sus pérdidas totales en un variable entonces: Rendimiento (TotalNumberOfPipsLost); Lo intentaré, pero no estoy seguro de que mi programación sea la adecuada.

Iniciado por ;

De todos modos, cargaría los OrderOpenPrices en una matriz y simplemente inspeccionaría cada uno comparándolos con el precio actual. Una razón para esta eegia es que en el caso de que evalúes la función Update_Grid, el orden ya está cargado en la matriz, así que simplemente expandiría esa rutina.

Sí, así es como me lo imaginé también. No estoy acostumbrado, así que necesitaré probar y cometer errores. Debe ser divertido.

Gil, sí, parece que estás en la pista ideal. Puede que le resulte más fácil obtener la fórmula correcta en algo como MS Excel primero. Tan pronto como tenga la formulación correcta, la ejecución debe ser lo suficientemente simple. No me preocuparía mucho por los arreglos. La mayoría del material ya está allí ... simplemente necesita determinar cómo leer la matriz. Ah, y una cosa más ... el bucle OrdersTotal () nuevamente ... debe comenzar en OrdersTotal () -1. El pasado 9, necesitaba una dosis de tonto. Solo grita si tienes alguna pregunta.

Hola Gil, se ve bien. Parece que tienes un don para ello. Es muy probable que haya un pequeño error en algún lugar ... Sugiero que echen un vistazo a la rutina CalculatePreviousLosses y utilicen el comando Publicar para escribir las variables en la pestaña Expertos para su revisión. Eso puede medirse y ver exactamente lo que la computadora está viendo. También es probable que el código sea correcto al 100% y la discrepancia se produce al utilizar la comisión y el canje, pero su discrepancia parece ser algo grande para esto.

Iniciado por ;

Hola Gil, suena genial. Parece que tienes un don para ello. Probablemente haya un pequeño error en algún lugar ... Sugeriría echar un vistazo a la rutina CalculatePreviousLosses y usar el comando Imprimir para escribir las variables en la pestaña Pros para revisarlas. Esto puede medirse y ver qué está visitando actualmente la computadora. También es probable que el código sea 100% correcto y que la discrepancia venga con la comisión y el canje, pero su discrepancia parece un poco grande para esto.

Knack ... hmmm ... No lo sé ... pero estoy pasando mucho tiempo.
Gracias. Haré la impresión y veré, todavía no he hecho eso. Gracias por guiarme. Creo que son precisos sobre iteraciones más pequeñas, pero cuando se llega a decir Nivel 4 y más, comienza a ser un poco desproporcionado, pero posiblemente podría ser un intercambio ... Estoy cerca.

Kenny, si eres tan amable como para guiarme sobre la lógica del manejo del dinero junto con la martingala. A modo de ejemplo, el regular de MM lo tiene, aumenta con más capital (lo cual es bueno), pero luego dibujará un lugar demasiado grande, por lo tanto, inserté un 0 en él. Ahora es .01 = 10,000, que Está más en línea con lo que quiero. Pero cuando configuré la parada de monitoreo, codifiqué el código para indicar si hay menos de .02 lotes y luego realizar un seguimiento. ¿Pero eso no hace que MM funcione tan bien ...? Entonces ... mis ideas, por favor, apúntenme la mejor dirección en la que creen. - Agregue un filtro de comentarios a las órdenes, luego filtre TS por ese filtro. Realmente ya tengo este comentario de Orden Multiplicada para las órdenes de martingal, por lo tanto, si es una buena práctica de codificación, ¿solo podría filtrar eso, pero no estoy seguro? - Ponga algo de lógica que se exportará junto con la rutina getLots que define el tamaño del lote inicial. Pero si hay lotes .02 más antiguos para ataques de martingala e igualdad de 20K y el lote inicial es .02, habrá cierta confusión. . - ¿Alguna otra idea ...? Gracias de nuevo y espero no ocupar demasiado tiempo.

Iniciado por ;

Pero si hay lotes .02 antiguos para martingale y equidad 20K y el lote inicial es .02, habría cierta confusión. .

Ser capaz de prever problemas de esta manera es lo que entendí por destreza. Buen lugar. Sin embargo, no me preocuparía ... llega un momento en el que tienes que elegir entre la perfección y la practicidad. En casos como este, el caso es un ciclo que se cierra con una pequeña reducción en lugar de una pequeña ganancia. Las matrices no han cambiado en 10 décadas, por lo que debe ser bueno para ir. Solo una sugerencia, debe agregar otro elemento porque el sistema actual solo almacena el precio. Hay 2 formas ... o bien declare una nueva matriz de dimensión única como: - int Grid_Ord_Ticket [] o podrá ampliar la matriz actual (de hecho, me di cuenta de que no necesitaba usar una matriz de 2 dimensiones) en primer lugar), por lo que podría utilizar el siguiente nivel del Grid_Ord_OpenPrice [] [2] Estoy seguro de que, a partir de la experiencia anterior, sabrá que solo gasta el 10% de codificación y el 90% de depuración. Debido a que no hay depurador, mQL4 es la peor pesadilla a este respecto. MQL4 a menudo te permitirá hacer algo mal pero no te dirá ... un buen ejemplo fue cuando declaraste esos dobles como enteros. Un buen entorno de ejecucióndepurador le dirá que está tratando de asignar un número de punto flotante a un factor entero ... no MQL4, simplemente redondeará el número y continuará, lo que le dará una salida inconsistente. Las mejores herramientas serán el comando Imprimir que uso para analizar variables y también a veces simplemente como un marcador de programa, así que sé que una función se está ejecutando. También puede utilizar Comentario () y luego realizar una prueba retrospectiva visual, pero creo que la impresión es más sencilla. Recuerde eliminarlos ya que la impresión es el elemento más grande que afecta la tasa de ejecución (junto con la salida de pantalla).

Iniciado por ;

Ser capaz de prever problemas de esta manera es precisamente lo que quise decir con destreza. Excelente lugar. Sin embargo, no me preocuparía ... llega un momento en el que tiene que elegir entre la viabilidad y la perfección. En casos como este, el caso es un ciclo que se cierra con una pequeña pérdida en lugar de una pequeña ganancia. Los arreglos no han cambiado en 10 años, por lo que debería estar listo. Solo una sugerencia, tendría que traer otro elemento ya que el sistema solo almacena el precio. Solo hay dos formas ... anunciar una nueva matriz de dimensión única ...

Como decimos en Hawai (donde solía vivir), ¡Da kine brah!
¡Le daría una oportunidad!