ArrayCopy

Copia un array in un altro.

int  ArrayCopy(
   void&        dst_array[],         // array di destinazione
   const void&  src_array[],         // array sorgente
   int          dst_start=0,         // indice d'inizio dal quale scrivere nell'array di destinazione
   int          src_start=0,         // primo indica di un array sorgente
   int          count=WHOLE_ARRAY    // numero di elementi
   );

Parametri

dst_array[]

[out]  Array di Destinazione

src_array[]

[in]  Array di Origine

dst_start=0

[in]  Indice di partenza dall'array di destinazione. Per impostazione predefinita, indice di partenza è 0.

src_start=0

[in] indice iniziale per l'array d' origine. Per impostazione predefinita, indice di partenza è 0.

count=WHOLE_ARRAY

[in]  Numero di elementi che devono essere copiati. Per default, l'intero array viene copiato (count=WHOLE_ARRAY).

Valore restituito

Restituisce il numero di elementi copiati.

Nota

If count<0 or count>src_size-src_start, all the remaining array part is copied. Gli array vengono copiati da sinistra a destra. Per array series (_*serie), la posizione di partenza è correttamente definita, aggiustata per la copia da sinistra a destra.

Se gli array sono di tipi diversi, durante la copiatura essa cerca di trasformare ogni elemento di un array di origine nel tipo di array di destinazione. Un array di stringhe può essere copiato solo in un'array di stringhe. Array di classi e strutture contenenti oggetti che richiedono l'inizializzazione, non vengono copiati. Un array di strutture può essere copiato solo in un array dello stesso tipo.

For dynamic arrays with indexing as in timeseries, the size of a destination array is automatically increased to the amount of copied data (if the latter exceeds the array size). The destination array size is not decreased automatically.

Esempio:

#property description "L'indicatore evidenzia le candele che sono locali"
#property description "alti e bassi. Intervallo per la ricerca della lunghezza"
#property description "valori estremi devono essere trovati usando i parametri di input "
//--- impostazioni indicatore
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
//---- plot
#property indicator_label1  "Extremums"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrLightSteelBlue,clrRed,clrBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- costanti predefinite
#define INDICATOR_EMPTY_VALUE 0.0
//--- parametri di input
input int InpNum=4; // Lunghezza semi-intervallo
//--- buffers indicatore
double ExtOpen[];
double ExtHigh[];
double ExtLow[];
double ExtClose[];
double ExtColor[];
//--- variabili globali
int    ExtStart=0; // indice della prima candela che non è un estremo
int    ExtCount=0; // numero di non-estremi nell'intervallo
//+--------------------------------------------------------------------------------+
//| Riempimento di candele non estreme                                             |
//+--------------------------------------------------------------------------------+
void FillCandles(const double &open[],const double &high[],
                 const double &low[],const double &close[])
  {
//--- riempimento di candele
   ArrayCopy(ExtOpen,open,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtHigh,high,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtLow,low,ExtStart,ExtStart,ExtCount);
   ArrayCopy(ExtClose,close,ExtStart,ExtStart,ExtCount);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di inizializzazione Indicatore Personalizzato                         |
//+--------------------------------------------------------------------------------+
int OnInit()
  {
//--- mappatura buffers indicatore
   SetIndexBuffer(0,ExtOpen);
   SetIndexBuffer(1,ExtHigh);
   SetIndexBuffer(2,ExtLow);
   SetIndexBuffer(3,ExtClose);
   SetIndexBuffer(4,ExtColor,INDICATOR_COLOR_INDEX);
//--- specificare il valore che non è mostrato
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,INDICATOR_EMPTY_VALUE);
//--- specificare i nomi dei buffer indicatore per la visualizzazione nella finestra dati
   PlotIndexSetString(0,PLOT_LABEL,"Open;High;Low;Close");
//---
   return(INIT_SUCCEEDED);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di iterazione indicatore personalizato                                |
//+--------------------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- imposta l'indicizzazione dritta nelle time series
   ArraySetAsSeries(open,false);
   ArraySetAsSeries(high,false);
   ArraySetAsSeries(low,false);
   ArraySetAsSeries(close,false);
//--- Variabile di inizio calcolo barra
   int start=prev_calculated;
//--- il calcolo non viene effettuato per le prime InpNum*2 barre
   if(start==0)
     {
      start+=InpNum*2;
      ExtStart=0;
      ExtCount=0;
     }
//--- se la barra è appena nata, controlla il prossimo potenziale estremo
   if(rates_total-start==1)
      start--;
//--- l'indice della barra che dev'essere controllato per l'estremo
   int ext;
//--- calcolo loop valore indicatore 
   for(int i=start;i<rates_total-1;i++)
     {
      //--- inizialmente sulla barra i senza disegnarla
      ExtOpen[i]=0;
      ExtHigh[i]=0;
      ExtLow[i]=0;
      ExtClose[i]=0;
      //--- indice dell'estremo per il controllo
      ext=i-InpNum;
      //--- controllo per il massimo locale
      if(IsMax(high,ext))
        {
         //--- evidenzia di una candela estrema
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=1;
         //--- evidenzia altre candele fino all'estremo con un colore neutro
         FillCandles(open,high,low,close);
         //--- cambia i colori della variabile
         ExtStart=ext+1;
         ExtCount=0;
         //--- passa alla prossima iterazione
         continue;
        }
      //--- controlla il minimo locale
      if(IsMin(low,ext))
        {
         //--- evidenzia di una candela estrema
         ExtOpen[ext]=open[ext];
         ExtHigh[ext]=high[ext];
         ExtLow[ext]=low[ext];
         ExtClose[ext]=close[ext];
         ExtColor[ext]=2;
         //--- evidenzia altre candele fino all'estremo con un colore neutro
         FillCandles(open,high,low,close);
         //--- cambia i valori della variabile
         ExtStart=ext+1;
         ExtCount=0;
         //--- passa alla prossima iterazione
         continue;
        }
      //--- incrementa il numero dei non-estremi all'intervallo
      ExtCount++;
     }
//--- restituisce il valore di prev_calculated per la prossima chiamata
   return(rates_total);
  }
//+--------------------------------------------------------------------------------+
//| Controlla se l'auttuale elemento dell'array è un alto locale                   |
//+--------------------------------------------------------------------------------+
bool IsMax(const double &price[],const int ind)
  {
//--- variabile inizio dell' intervallo
   int i=ind-InpNum;
//--- periodo di fine dell'intervallo
   int finish=ind+InpNum+1;
//--- controlla la prima metà dell'intervallo
   for(;i<ind;i++)
     {
      if(price[ind]<=price[i])
         return(false);
     }
//--- controlla la seconda metà dell'intervallo
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]<=price[i])
         return(false);
     }
//--- questo èun estremo
   return(true);
  }
//+--------------------------------------------------------------------------------+
//| Controlla se i correnti elementi dell'array sono bassi locali                  |
//+--------------------------------------------------------------------------------+
bool IsMin(const double &price[],const int ind)
  {
//--- variabile inizio dell' intervallo
   int i=ind-InpNum;
//--- variabile di fine intervallo
   int finish=ind+InpNum+1;
//--- controlla la prima metà dell'intervallo
   for(;i<ind;i++)
     {
      if(price[ind]>=price[i])
         return(false);
     }
//--- controlla la seconda metà dell'intervallo
   for(i=ind+1;i<finish;i++)
     {
      if(price[ind]>=price[i])
         return(false);
     }
//--- questo èun estremo
   return(true);
  }