DocumentazioneSezioni
MQL5 RiferimentoFunzioni di ArrayArrayFromFP8 

ArrayFromFP8

Copia un array di tipo uchar in un array di tipo float o double con il formato specificato.

bool   ArrayFromFP8(
   const float&         dst_array[],        // copy to
   const uchar&         src_array[],        // copy from
   ENUM_FLOAT8_FORMAT   fmt                 // format
   );

Overloading (sovraccarico) per il tipo double

bool   ArrayFromFP8(
   const double&        dst_array[],        // copy to
   const uchar&         src_array[],        // copy from
   ENUM_FLOAT8_FORMAT   fmt                 // format
   );

Parametri

dst_array[]

[out] Array ricevitore di tipo float o double.

src_array[]

[in] Array sorgente di tipo uchar.

fmt

[in] Copia del formato dall'enumerazione ENUM_FLOAT8_FORMAT.

 

Valore Restituito

Restituisce true in caso di esito positivo altrimenti false.

Note

Tutti i tipi di formati FP8 sono definiti nell'enumerazione ENUM_FLOAT8_FORMAT e sono utilizzati in MQL5 solo per operazioni con modelli ONNX.

Se i parametri di output ottenuti dall'esecuzione della funzione OnnxRun sono di tipo FP8 dall'enumerazione ENUM_FLOAT8_FORMAT, è possibile utilizzare questa funzione per convertire il risultato in un array float o double.

FP8 (8-bit floating point) è uno dei tipi di dati utilizzati per rappresentare i numeri in virgola mobile. In FP8, ogni numero è rappresentato da 8 bit di dati, tipicamente divisi in tre componenti: segno, esponente e mantissa. Questo formato offre un equilibrio tra precisione ed efficienza di archiviazione, rendendolo attraente per le applicazioni che richiedono memoria ed efficienza computazionale.

Con l'impiego della rappresentazione numerica compatta, FP8 riduce i requisiti di memoria e accelera i calcoli. Inoltre, FP8 può essere utile per l'implementazione di operazioni di basso livello come i calcoli aritmetici e l'elaborazione del segnale.

Esempio: funzione dall'articolo Lavorare con i modelli ONNX nei formati float16 e float8

//+------------------------------------------------------------------+
//| RunCastFloat8Float                                               |
//+------------------------------------------------------------------+
bool RunCastFloat8ToFloat(long model_handle,const ENUM_FLOAT8_FORMAT fmt)
  {
   PrintFormat("TEST: %s(%s)",__FUNCTION__,EnumToString(fmt));
//---
   float test_data[15]   = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
   uchar data_float8[15] = {};
   if(!ArrayToFP8(data_float8,test_data,fmt))
     {
      Print("error in ArrayToFP8. error code=",GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   U<uchar> input_float8_values[3*5];
   U<float> output_float_values[3*5];
   float    test_data_float[];
//--- convert float8 to float
   if(!ArrayFromFP8(test_data_float,data_float8,fmt))
     {
      Print("error in ArrayFromFP8. error code=",GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   for(uint i=0; i<data_float8.Size(); i++)
     {
      input_float8_values[i].value=data_float8[i];
      PrintFormat("%d input value =%f  Hex float8 = %s  ushort value=%d",i,test_data_float[i],ArrayToHexString(input_float8_values[i].uc),input_float8_values[i].value);
     }
   Print("ONNX input array: ",ArrayToString(input_float8_values));
//--- execute model (convert float8 to float using ONNX)
   if(!OnnxRun(model_handle,ONNX_NO_CONVERSION,input_float8_values,output_float_values))
     {
      PrintFormat("error in OnnxRun. error code=%d",GetLastError());
      OnnxRelease(model_handle);
      return(false);
     }
   Print("ONNX output array: ",ArrayToString(output_float_values));
//--- calculate error (compare ONNX and ArrayFromFP8 results)
   double sum_error=0.0;
   for(uint i=0; i<test_data.Size(); i++)
     {
      double delta=test_data_float[i]-(double)output_float_values[i].value;
      sum_error+=MathAbs(delta);
      PrintFormat("%d output float %f = %s difference=%f",i,output_float_values[i].value,ArrayToHexString(output_float_values[i].uc),delta);
     }
//---
   PrintFormat("%s(%s): sum_error=%f\n",__FUNCTION__,EnumToString(fmt),sum_error);
   return(true);
  }

Vedere anche

ArrayToFP8, ArrayCopy