matriz estática ? - página 2

Nuevo comentario
 
Ok, al menos estaba casi en el camino correcto pero como no sabía lo del EMPTY_VALUE y como usarlo estaba pensando en intentar hacer un bucle hacia atrás para detectar el cambio de valor ya que la resistencia y el valor del soporte se mantiene igual hasta los indicadores anteriores.

De todos modos, gracias tendré que leer un poco más sobre esto, me estoy acercando pero todavía está un poco nublado :)

Parece que me está costando mucho aprender las cosas. Creo que tengo que leer más códigos de otras personas y tratar de entenderlos para obtener mejores ideas de diseño.

Gracias por la respuesta.
 
RaptorUK:
Hay 2 buffers (arrays) que contienen los valores de los precios de los Fractales... val1 & val2. Si quieres encontrar los valores anteriores de los fractales simplemente haces un bucle, incrementando un valor de desplazamiento, y compruebas los valores del buffer hasta que encuentres los que no son EMPTY_VALUE ( https://docs.mql4.com/customind/SetIndexEmptyValue )
Ok, sólo pensando en voz alta aquí:

Así que puedo hacer un bucle de vuelta v1[i] y v2[i] con algo de código 1++,

No entiendo val1>0 ¿no es siempre mayor que 0 excepto para High[0] ?

Y por qué val1 sólo marca el fractal alto y no todos los altos[i] AHHH creo que lo veo porque la sentencia if le dice que sólo haga los altos[i]

Así que ok déjame pensar un poco más.

val1 son los fractales, sin embargo v1[i] son solo los altos del fractal ok creo que tengo esta parte resuelta.

Entonces podría hacer un bucle de v1[i] 1++ de alguna manera (tendré que resolver esa parte) hasta el punto anterior a EMPTY_VALUE y este sería el fractal High[i] anterior.

¿Me estoy acercando?
 
Agent86:
Ok, sólo pensando en voz alta aquí:

val1 son los fractales, sin embargo v1[i] son solo los altos del fractal ok creo que tengo esta parte resuelta.

Entonces podría hacer un bucle de v1[i] 1++ de alguna manera (tendré que resolver esa parte) hasta el punto anterior al VALOR_VACÍO y éste sería el fractal anterior de los altos[i].

¿Me estoy acercando?
Correcto... :-)
 
RaptorUK:
Correcto... :-)
¡Uf! Estaba preocupado

Gracias
 
Tengo algo mal, puedo poner 0 en para EMPTY_VALUE y se imprime 0 continuamente así que eso no es correcto bueno tal vez eso es correcto pero no mi efecto deseado.

De todas formas:

//+------------------------------------------------------------------+
//|                                                  Agent86_5min.mq4 |
//|                                                    Unfinished POS |
//|                                    
//+------------------------------------------------------------------+
#property copyright "Unfinished POS by Agent86"


//---- input parameters
extern double    TakeProfit=20.0;
extern double    Lots=0.1;
extern double    StopLoss=15.0;
extern int MagicNumber=123486;

double v1[];
double v2[];
double val1;
double val2;

//++++ These are adjusted for 5 digit brokers.

int     pips2points;    // slippage  3 pips    3=points    30=points
double  pips2dbl;       // Stoploss 15 pips    0.0015      0.00150
int     Digits.pips;    // DoubleToStr(dbl/pips2dbl, Digits.pips)

    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
   if (Digits == 5 || Digits == 3)
   {    // Adjust for five (5) digit brokers.
      pips2dbl    = Point*10; pips2points = 10;   Digits.pips = 1;
   } 
   else 
    {    
      pips2dbl    = Point;    pips2points =  1;   Digits.pips = 0; 
    }
    // OrderSend(... Slippage.Pips * pips2points, Bid - StopLossPips * pips2dbl
     
   
    
//---- 

//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
   
    
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
  
  
   double   faster = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1), //MODE_MAIN
            slower = iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1); //MODE_SIGNAL
            
   int i=Bars;         
   
   while(i>=0)
     {
      val1=iFractals(NULL, 0, MODE_UPPER,i);
      if (val1 > 0) v1[i]=High[i];
      else          v1[i]=v1[i+1];

      val2=iFractals(NULL, 0, MODE_LOWER,i);
      if (val2 > 0) v2[i]=Low[i];
      else          v2[i]=v2[i+1];
      
      i--;
     }
   
    for(val1=High[i]; v1[i] == EMPTY_VALUE ;i++)
      {
      Print (v1[i]);
      } 
  
//----
            
                       
            

           

//---- 

 
                    
        

                
   return(0);
  }    

//+------------------------------------------------------------------+
Pensé que el bucle for me llevaría a una sola señal y me imprimiría el nivel de la señal, pero no obtengo nada o 0

Después de unos días pensando en esto y probando muchas cosas, y aún así traté de hacer estos cambios en la versión del indicador también añadiendo un 3er buffer e intentar señalar con el precio en los gráficos pero eso ha sido un no ir también.


Bueno, espera tomo esto de nuevo la versión corta EA no tengo el búfer EMPTY_VALUE por lo que probablemente no va a funcionar de todos modos, y por lo que la idea era probar la EA para que pudiera ver las funciones de impresión para ver los resultados, pero la versión del indicador que tendría que esperar por lo que tengo que publicar de nuevo en que como resulta.

De todos modos aquí está la versión del indicador, pero no me siento seguro acerca de esto porque no estoy exactamente seguro de si debo tratar de bucle dentro de la declaración mientras o crear un nuevo bucle y volver a crear val1 = .... también.

//+------------------------------------------------------------------+
//|                Support and Resistance                            |
//|                Copyright © 2004/5     Barry Stander              |
//|                http://www.4Africa.net/4meta/                     |
//+------------------------------------------------------------------+

#property copyright "Support and Resistance             Barry_Stander_4@yahoo.com"
#property link      "http://www.4Africa.net/4meta/"
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 White

//---- buffers
double v1[];
double v2[];
double v3[];
double val1;
double val2;
double val3;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
  {
//----
   IndicatorBuffers(2);

   SetIndexArrow(0, 159);
   SetIndexStyle(0,DRAW_ARROW,STYLE_DOT,1,Red);
   SetIndexBuffer(0, v1);
   SetIndexLabel(0,"Resistance");
   SetIndexEmptyValue(0,0.0);

   SetIndexArrow(1, 159);
   SetIndexStyle(1,DRAW_ARROW,STYLE_DOT,1,Blue);
   SetIndexBuffer(1, v2);
   SetIndexLabel(1,"Support");
   SetIndexEmptyValue(1,0.0);
   
   SetIndexArrow(2, 225);
   SetIndexStyle(2,DRAW_ARROW,STYLE_DOT,1,White);
   SetIndexBuffer(2, v3);
   SetIndexLabel(2,"High A");
   SetIndexEmptyValue(2,0.0); 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   
   
   int i=Bars;
//----
   while(i>=0)
     {
      val1=iFractals(NULL, 0, MODE_UPPER,i);
      if (val1 > 0) v1[i]=High[i];
      else          v1[i]=v1[i+1];

      val2=iFractals(NULL, 0, MODE_LOWER,i);
      if (val2 > 0) v2[i]=Low[i];
      else          v2[i]=v2[i+1];
      
      i--;      
       
      }
      
     
     for(val1=High[i]; v1[i] == 0 ;i++)  // or v1[i] == EMPTY_VALUE
      {
      Print (v1[i]);
      }
       
     
     
     
//----
   return(0);
  }
//+------------------------------------------------------------------+
Bueno, he desechado el intento de crear el 3er buffer / señal por ahora y sólo quiero ver si puedo imprimir el resultado de la señal anterior

EMPTY_VALUE la forma en que puse en el código inicializa el indicador, pero eso es todo nada de impresión
 

¿Puedes explicar cómo funciona este bucle for?

for(val1=High[i]; v1[i] == 0 ;i++)

 
RaptorUK:

¿Puedes explicar cómo funciona este bucle for?

for(val1=High[i]; v1[i] == 0 ;i++)

Supongo que estaba pensando que como la sentencia while y v1[i] almacena los máximos e i -- cuenta hacia abajo desde Bares más altos entonces simplemente contaría de nuevo hacia arriba mientras v1[i] == VALOR_VACÍO

Pensé que esto incrementaría i++ 1 nivel hasta el máximo anterior, bueno en realidad supongo que iría más allá de eso hasta el siguiente EMPTY_VALUE

Así que necesito hacer esto de la manera opuesta v1[i] = High[i]; i++

Entonces esto no debería llevarme al High anterior, pero no estoy seguro de cómo inicializarlo correctamente.

Seguiré trabajando en ello.
 
Lo estoy cambiando por un if( Sólo quiero ver que se imprima algo en este punto para poder ver al menos lo que está haciendo el indicador.

Todo lo que obtengo es 0's así que en realidad NO hay valores cuando = Print (v1[i]);
Lo cual es extraño porque ¿cómo tengo el indicador incluso trabajando en este punto entonces?

Oh bien, voy a seguir en él.
 
Agent86:
Lo estoy cambiando a un if( Solo quiero ver cualquier cosa impresa en este punto para poder ver al menos lo que está haciendo el indicador.

Todo lo que obtengo es 0's así que en realidad NO hay valores cuando = Print (v1[i]);
Lo cual es extraño porque ¿cómo tengo el indicador incluso trabajando en este punto entonces?

Oh bien, voy a seguir en él.


Tal vez sólo está viendo los valores de v1[0] # imprimir i al mismo tiempo .

Print ("v1[", i, "]= ", v1[i]);
  
2011.09.17 11:56:15     2011.01.03 09:24  Agent86_5min EURUSD,M5: v1[-1]= 0
hmm interesante
no lo publiqué todo pero todas las líneas leen lo mismo = 0

pensé que todavía debería ver un valor real para v1[0] ?

¿cómo puede ser siempre 0 cuando el indicador debe ser if(>0) ?

Puede que me esté metiendo en otra área en la que soy ignorante.

Pensé que podría imprimir para tratar de entender qué y por qué todos mis intentos están fallando; y para que pueda incrementar i++ de alguna manera para llegar al siguiente fractal y luego de alguna manera averiguar cómo utilizar esta información para algo.


Puedo imprimir High[i] o v1[i] y siempre es 0

Imprimiendo High[0] o High[1] también 0

Aunque entiendo lo que has puesto y la impresión del valor de i que parece estar atascado debido al bucle i-- que siempre lo lleva a 0, pero aun así debería imprimir un valor para i, al menos eso pensaba.

Y entiendo que imprima [-1] porque i=Bars. Entiendo esto, pero =0 ?




123456
Nuevo comentario
Razón de la queja: