ScalerByLeo/Src/Scaler/Std/StdScalar.mqh

//+------------------------------------------------------------------+
//|                                                    StdScalar.mqh |
//|                                  Copyright 2026, Niquel Mendoza. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Niquel Mendoza."
#property link      "https://www.mql5.com"
#property strict


#ifndef SCALERBYLEO_SRC_SCALER_STD_STDSCALAR_MQH
#define SCALERBYLEO_SRC_SCALER_STD_STDSCALAR_MQH

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
#include "StdBase.mqh"

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
namespace TSN
{
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
template<typename TFlt>
class StandardizationScaler : public StandardizationScalerBase<TFlt>
 {
public:
                     StandardizationScaler(void) { m_type = SCALERBYLEO_SCALER_TYPE_STANDART; }
                    ~StandardizationScaler(void) {}

  //---
  __forceinline bool FitTransform(const matrix<TFlt> &X, matrix<TFlt> &out);
  bool               Transform(const matrix<TFlt> &X, matrix<TFlt> &out);
  bool               InverseTransform(const matrix<TFlt> &X_scaled, matrix<TFlt> &out);
 };

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
template<typename TFlt>
__forceinline bool StandardizationScaler::FitTransform(const matrix<TFlt> &X, matrix<TFlt> &out)
 {
//---
  if(!Fit(X))
    return false;
  if(!Transform(X, out))
    return false;

//---
  return true;
 }

//+------------------------------------------------------------------+
//| Transform                                                        |
//+------------------------------------------------------------------+
template<typename TFlt>
bool StandardizationScaler::Transform(const matrix<TFlt> &X, matrix<TFlt> &out)
 {
//---
  if(!m_loaded_scaler)
   {
    m_last_err = SCALERBYLEO_ERR_NOT_TRAINED;
    return false;
   }

//--- chekeo de rows
  const ulong rows = X.Rows();
  if(rows == 0)
   {
    m_last_err = SCALERBYLEO_ERR_EMPTY_INPUT;
    return false;
   }

//--- chekeo de cols
  const ulong total_cols = X.Cols();
  const ulong fs = m_mean.Size();
  if(m_i_start + fs > total_cols)
   {
    m_last_err = SCALERBYLEO_ERR_SIZE_MISMATCH;
    return false;
   }

//---
// En caso nos obligen a reoncutr y no coinciden entonces
  if(m_reconstruir && fs != total_cols)
   {
    out = X; // copia optimizada (ya probado, conpensa el overwrite)
    // modificamos inplace
    for(ulong c = 0; c < fs; c++)
      for(ulong r = 0; r < rows; r++)
        out[r][m_i_start + c] = TFlt((double(X[r][m_i_start + c]) - m_mean[c]) * m_std_inv[c]);
   }
  else
   {
    // De lo contrario exacto asi que inplace
    out.Resize(rows, fs);
    for(ulong c = 0; c < fs; c++)
      for(ulong r = 0; r < rows; r++)
        out[r][c] = TFlt((double(X[r][m_i_start + c]) - m_mean[c]) * m_std_inv[c]);
   }

//---
  return true;
 }

//+------------------------------------------------------------------+
//| InverseTransform                                                 |
//+------------------------------------------------------------------+
template<typename TFlt>
bool StandardizationScaler::InverseTransform(const matrix<TFlt> &X_scaled, matrix<TFlt> &out)
 {
//---
  if(!m_loaded_scaler)
   {
    m_last_err = SCALERBYLEO_ERR_NOT_TRAINED;
    return false;
   }

//--- chekeo de rows
  const ulong rows = X_scaled.Rows();
  if(rows == 0)
   {
    m_last_err = SCALERBYLEO_ERR_EMPTY_INPUT;
    return false;
   }

//--- chekeo de cols
  const ulong total_cols = X_scaled.Cols();
  const ulong fs = m_mean.Size();
  if(m_i_start + fs > total_cols)
   {
    m_last_err = SCALERBYLEO_ERR_SIZE_MISMATCH;
    return false;
   }

//---
// En caso nos obligen a reoncutr y no coinciden entonces
  if(m_reconstruir && fs != total_cols)
   {
    out = X_scaled; // copia optimizada (ya probado, conpensa el overwrite)
    // modificamos inplace
    for(ulong c = 0; c < fs; c++)
      for(ulong r = 0; r < rows; r++)
        out[r][m_i_start + c] = TFlt((double(X_scaled[r][m_i_start + c]) * m_std[c]) + m_mean[c]);
   }
  else
   {
    // De lo contrario exacto asi que inplace
    out.Resize(rows, fs);
    for(ulong c = 0; c < fs; c++)
      for(ulong r = 0; r < rows; r++)
        out[r][c] = TFlt((double(X_scaled[r][m_i_start + c]) * m_std[c]) + m_mean[c]);
   }

//---
  return true;
 }
}
//+------------------------------------------------------------------+
#endif // SCALERBYLEO_SRC_SCALER_STD_STDSCALAR_MQH