DocumentaçãoSeções
Referência MQL5Funções para ArrayArrayToFP8 

ArrayToFP8

Realiza a cópia de um array do tipo float ou double para um array do tipo uchar com o formato especificado.

bool   ArrayToFP8(
   const uchar&         dst_array[],        // para onde copiamos
   const float&         src_array[],        // de onde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Sobrecarga para o tipo double

bool   ArrayToFP8(
   const uchar&         dst_array[],        // para onde copiamos
   const double&        src_array[],        // de onde copiamos
   ENUM_FLOAT16_FORMAT  fmt                 // formato
   );

Parâmetros

dst_array[]

[out]  Array receptor do tipo uchar.

src_array[]

[in]  Array receptor do tipo float ou double.

fmt

[in] Formato de cópia do enum ENUM_FLOAT8_FORMAT.

 

Valor retornado

Retorna true se for bem-sucedido, caso contrário, false.

Observação

Todos os tipos de formato FP8 são definidos no enum ENUM_FLOAT8_FORMAT e são usados no MQL5 exclusivamente para trabalhar com modelos ONNX.

A função é utilizada para a conversão de parâmetros de entrada do tipo float ou double para um dos tipos FP8. Posteriormente, esses parâmetros de entrada são usados na função OnnxRun.

O formato FP8 (número de ponto flutuante de 8 bits) é um dos tipos de dados usados para representar números de ponto flutuante. No FP8, cada número é representado por 8 bits de dados, que geralmente são divididos em três componentes: sinal, expoente e mantissa. Este formato oferece um compromisso entre precisão e eficiência de armazenamento de dados, tornando-o atraente para uso em aplicativos onde a economia de memória e recursos computacionais é necessária.

Graças à representação compacta de números, FP8 permite reduzir os requisitos de memória e acelerar os cálculos. Além disso, FP8 pode ser útil para a implementação de operações de baixo nível, como cálculos aritméticos e processamento de sinais.

Exemplo: função do artigo Trabalhando com modelos ONNX nos formatos 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);
  }

Veja também

ArrayFromFP8, ArrayCopy