Question about casting and function signature of MathMin/MathMax - page 2

New comment

Dominik Egert 2023.05.04 21:06 #11

Fernando Carreiro #: Yes, it is ...

Ohh no, it's to late already...

Of course it was redirected at my function.... My bad.

amrali 2023.05.05 04:21 #12

I think it is called type promotion in C/C++. See https://www.mql5.com/en/docs/basis/function/functionoverload

Your best bet is to capture the type of return value at runtime using typename(MathMax(1ull, 2.f))

This will print the return value and its type:

        template <typename T>
        T msg_retval(T retval)
        {
            printf("%s %-8s = %s }", dbginfo, "["+typename(T)+"]", (string)retval);
            return retval;
        }

msg_retval(MathMax(1ull, 2.f));

Any questions from newcomers ObjectDelete() function not working Function Calls: specifying 'Returning'

Dominik Egert 2023.05.05 06:38 #13

amrali #:
I think it is called type promotion in C/C++. See https://www.mql5.com/en/docs/basis/function/functionoverload

Your best bet is to capture the type of return value at runtime using typename(MathMax(1ull, 2.f))

This will print the return value and its type:

msg_retval(MathMax(1ull, 2.f));

Ok. So it I would want to write a function with two parameters and a return value which gives same or comparable compiler errors as MathMax/MathMin, then how would I need to write this in MQL.

The idea is to be as compatible as possible to the original function, so that if someone uses my replacement, they would get some notification from the computer that something is not appropriate in their use case.

Background is the project "lib_debug", as it replaces the MQL functions for call intercepting.

So, if someone uses this library and they write code, it should yield as similar results as it would without using the libraries substitution functions ...

For consistence.

And as it seems, these two functions give me headache on how to ensure correct usage.

A template with 2 types is insufficient, because it has only one return type.

need some help in [ARCHIVE]Any rookie question, so Libraries: MQL Plus Enhanced

amrali 2023.05.05 07:03 #14

Now, I understood the problem:

But, I do not know how to solve yet

//template <typename T1, typename T2> char     max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> short    max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> int      max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> long     max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> uchar    max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> ushort   max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> uint     max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> ulong    max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
//template <typename T1, typename T2> float    max(T1 value1, T2 value2)  { return MathMax(value1, value2); }
template <typename T1, typename T2> double   max(T1 value1, T2 value2)  { return MathMax(value1, value2); }

//#define MathMax(x,y) (max(x,y))   // uncomment line to intercept MathMax() function

template <typename T>
T msg_retval(T retval)
  {
   printf("%-8s = %s }", "["+typename(T)+"]", (string)retval);
   return retval;
  }

void OnStart()
  {
   msg_retval(MathMax(1ull, 2.f));
   msg_retval(MathMax(1ull, 2ull));
  }

Dominik Egert 2023.05.05 08:52 #15

amrali #:

Now, I understood the problem:

But, I do not know how to solve yet

I did following test and come up to the conclusion the functions MathMin and MathMax do not follow the casting rules as documented.

This can be seen by compiling this example code and running it as proof. - I added all relevant infos alread.

// Type name helper
template <typename T>
void func_type_id(T p_in)
{ printf("%s", typename(T)); }



//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{


    char        _char       = NULL;
    short       _short      = NULL;
    int         _int        = NULL;
    long        _long       = NULL;
    float       _float      = NULL;
    double      _double     = NULL;
    char        c_char      = NULL;
    short       c_short     = NULL;
    int         c_int       = NULL;
    long        c_long      = NULL;
    float       c_float     = NULL;
    double      c_double    = NULL;



    func_type_id(MathMax(_char       ,      _char       ), __LINE__);      c_char       = _char     ;           c_char      = _char     ;   // return value type:   char
    func_type_id(MathMax(_short      ,      _char       ), __LINE__);      c_short      = _short    ;           c_short     = _char     ;   // return value type:   short
    func_type_id(MathMax(_int        ,      _char       ), __LINE__);      c_int        = _int      ;           c_int       = _char     ;   // return value type:   int
    func_type_id(MathMax(_long       ,      _char       ), __LINE__);      c_long       = _long     ;           c_long      = _char     ;   // return value type:   long
    func_type_id(MathMax(_float      ,      _char       ), __LINE__);      c_float      = _float    ;           c_float     = _char     ;   // return value type:   float
    func_type_id(MathMax(_double     ,      _char       ), __LINE__);      c_double     = _double   ;           c_double    = _char     ;   // return value type:   double

    func_type_id(MathMax(_char       ,      _short      ), __LINE__);      c_short      = _char     ;           c_short     = _short    ;   // return value type:   short
    func_type_id(MathMax(_short      ,      _short      ), __LINE__);      c_short      = _short    ;           c_short     = _short    ;   // return value type:   short
    func_type_id(MathMax(_int        ,      _short      ), __LINE__);      c_int        = _int      ;           c_int       = _short    ;   // return value type:   int
    func_type_id(MathMax(_long       ,      _short      ), __LINE__);      c_long       = _long     ;           c_long      = _short    ;   // return value type:   long
    func_type_id(MathMax(_float      ,      _short      ), __LINE__);      c_float      = _float    ;           c_float     = _short    ;   // return value type:   float
    func_type_id(MathMax(_double     ,      _short      ), __LINE__);      c_double     = _double   ;           c_double    = _short    ;   // return value type:   double

    func_type_id(MathMax(_char       ,      _int        ), __LINE__);      c_int        = _char     ;           c_int       = _int      ;   // return value type:   int
    func_type_id(MathMax(_short      ,      _int        ), __LINE__);      c_int        = _short    ;           c_int       = _int      ;   // return value type:   int
    func_type_id(MathMax(_int        ,      _int        ), __LINE__);      c_int        = _int      ;           c_int       = _int      ;   // return value type:   int
    func_type_id(MathMax(_long       ,      _int        ), __LINE__);      c_long       = _long     ;           c_long      = _int      ;   // return value type:   long
    func_type_id(MathMax(_float      ,      _int        ), __LINE__);      c_float      = _float    ;           c_float     = _int      ;   // return value type:   float       WARNING: (cast from int to float)
    func_type_id(MathMax(_double     ,      _int        ), __LINE__);      c_double     = _double   ;           c_double    = _int      ;   // return value type:   double

    func_type_id(MathMax(_char       ,      _long       ), __LINE__);      c_long       = _char     ;           c_long      = _long     ;   // return value type:   long
    func_type_id(MathMax(_short      ,      _long       ), __LINE__);      c_long       = _short    ;           c_long      = _long     ;   // return value type:   long
    func_type_id(MathMax(_int        ,      _long       ), __LINE__);      c_long       = _int      ;           c_long      = _long     ;   // return value type:   long
    func_type_id(MathMax(_long       ,      _long       ), __LINE__);      c_long       = _long     ;           c_long      = _long     ;   // return value type:   long
    func_type_id(MathMax(_float      ,      _long       ), __LINE__);      c_float      = _float    ;           c_float     = _long     ;   // return value type:   float       WARNING: (cast from long to float)
    func_type_id(MathMax(_double     ,      _long       ), __LINE__);      c_double     = _double   ;           c_double    = _long     ;   // return value type:   double      WARNING: (cast from long to double)

    func_type_id(MathMax(_char       ,      _float      ), __LINE__);      c_float      = _char     ;           c_float     = _float    ;   // return value type:   float
    func_type_id(MathMax(_short      ,      _float      ), __LINE__);      c_float      = _short    ;           c_float     = _float    ;   // return value type:   float
    func_type_id(MathMax(_int        ,      _float      ), __LINE__);      c_float      = _int      ;           c_float     = _float    ;   // return value type:   float       WARNING: (cast from int to float)
    func_type_id(MathMax(_long       ,      _float      ), __LINE__);      c_float      = _long     ;           c_float     = _float    ;   // return value type:   float       WARNING: (cast from long to float)
    func_type_id(MathMax(_float      ,      _float      ), __LINE__);      c_float      = _float    ;           c_float     = _float    ;   // return value type:   float
    func_type_id(MathMax(_double     ,      _float      ), __LINE__);      c_double     = _double   ;           c_double    = _float    ;   // return value type:   double

    func_type_id(MathMax(_char       ,      _double     ), __LINE__);      c_double     = _char     ;           c_double    = _double   ;   // return value type:   double
    func_type_id(MathMax(_short      ,      _double     ), __LINE__);      c_double     = _short    ;           c_double    = _double   ;   // return value type:   double
    func_type_id(MathMax(_int        ,      _double     ), __LINE__);      c_double     = _int      ;           c_double    = _double   ;   // return value type:   double
    func_type_id(MathMax(_long       ,      _double     ), __LINE__);      c_double     = _long     ;           c_double    = _double   ;   // return value type:   double      WARNING: (cast from long to double)
    func_type_id(MathMax(_float      ,      _double     ), __LINE__);      c_double     = _float    ;           c_double    = _double   ;   // return value type:   double
    func_type_id(MathMax(_double     ,      _double     ), __LINE__);      c_double     = _double   ;           c_double    = _double   ;   // return value type:   double



    func_type_id(MathMax(_char      ,       _char       ), __LINE__);       // return value type:   char
    func_type_id(MathMax(_char      ,       _short      ), __LINE__);       // return value type:   short
    func_type_id(MathMax(_char      ,       _int        ), __LINE__);       // return value type:   int
    func_type_id(MathMax(_char      ,       _long       ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_char      ,       _float      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_char      ,       _double     ), __LINE__);       // return value type:   double

    func_type_id(MathMax(_short     ,       _char       ), __LINE__);       // return value type:   short
    func_type_id(MathMax(_short     ,       _short      ), __LINE__);       // return value type:   short
    func_type_id(MathMax(_short     ,       _int        ), __LINE__);       // return value type:   int
    func_type_id(MathMax(_short     ,       _long       ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_short     ,       _float      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_short     ,       _double     ), __LINE__);       // return value type:   double

    func_type_id(MathMax(_int       ,       _char       ), __LINE__);       // return value type:   int
    func_type_id(MathMax(_int       ,       _short      ), __LINE__);       // return value type:   int
    func_type_id(MathMax(_int       ,       _int        ), __LINE__);       // return value type:   int
    func_type_id(MathMax(_int       ,       _long       ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_int       ,       _float      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_int       ,       _double     ), __LINE__);       // return value type:   double

    func_type_id(MathMax(_long      ,       _char       ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_long      ,       _short      ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_long      ,       _int        ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_long      ,       _long       ), __LINE__);       // return value type:   long
    func_type_id(MathMax(_long      ,       _float      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_long      ,       _double     ), __LINE__);       // return value type:   double

    func_type_id(MathMax(_float     ,       _char       ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_float     ,       _short      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_float     ,       _int        ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_float     ,       _long       ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_float     ,       _float      ), __LINE__);       // return value type:   float
    func_type_id(MathMax(_float     ,       _double     ), __LINE__);       // return value type:   double

    func_type_id(MathMax(_double    ,       _char       ), __LINE__);       // return value type:   double
    func_type_id(MathMax(_double    ,       _short      ), __LINE__);       // return value type:   double
    func_type_id(MathMax(_double    ,       _int        ), __LINE__);       // return value type:   double
    func_type_id(MathMax(_double    ,       _long       ), __LINE__);       // return value type:   double
    func_type_id(MathMax(_double    ,       _float      ), __LINE__);       // return value type:   double
    func_type_id(MathMax(_double    ,       _double     ), __LINE__);       // return value type:   double





    return(INIT_FAILED);
}

At least I can now write a function signature giving the same compiler results as MathMax/MathMin....

Positive to Negative Questions on OOP in MathMax/MathMin giving (maybe) wrong

Dominik Egert 2023.05.05 09:24 #16

In conclusion, these should be the valid MathMax/MathMin function signature in use by the MQL-API at the moment:

EDIT: I had to update for completnes, also including string and unsigned types now....

uchar     _MathMax(char      value1,         uchar       value2) { return(MathMax(value1, value2)); };
short     _MathMax(short     value1,         uchar       value2) { return(MathMax(value1, value2)); };
int       _MathMax(int       value1,         uchar       value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         uchar       value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         uchar       value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         uchar       value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(char      value1,         ushort      value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(short     value1,         ushort      value2) { return(MathMax(value1, value2)); };
int       _MathMax(int       value1,         ushort      value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         ushort      value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         ushort      value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         ushort      value2) { return(MathMax(value1, value2)); };
uint      _MathMax(char      value1,         uint        value2) { return(MathMax(value1, value2)); };
uint      _MathMax(short     value1,         uint        value2) { return(MathMax(value1, value2)); };
uint      _MathMax(int       value1,         uint        value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         uint        value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         uint        value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         uint        value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(char      value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(short     value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(int       value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(long      value1,         ulong       value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         ulong       value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         ulong       value2) { return(MathMax(value1, value2)); };
uchar     _MathMax(uchar     value1,         char        value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(ushort    value1,         char        value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         char        value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         char        value2) { return(MathMax(value1, value2)); };
short     _MathMax(uchar     value1,         short       value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(ushort    value1,         short       value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         short       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         short       value2) { return(MathMax(value1, value2)); };
int       _MathMax(uchar     value1,         int         value2) { return(MathMax(value1, value2)); };
int       _MathMax(ushort    value1,         int         value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         int         value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         int         value2) { return(MathMax(value1, value2)); };
long      _MathMax(uchar     value1,         long        value2) { return(MathMax(value1, value2)); };
long      _MathMax(ushort    value1,         long        value2) { return(MathMax(value1, value2)); };
long      _MathMax(uint      value1,         long        value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         long        value2) { return(MathMax(value1, value2)); };
float     _MathMax(uchar     value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(ushort    value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(uint      value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(ulong     value1,         float       value2) { return(MathMax(value1, value2)); };
double    _MathMax(uchar     value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(ushort    value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(uint      value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(ulong     value1,         double      value2) { return(MathMax(value1, value2)); };
uchar     _MathMax(uchar     value1,         uchar       value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(ushort    value1,         uchar       value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         uchar       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         uchar       value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(uchar     value1,         ushort      value2) { return(MathMax(value1, value2)); };
ushort    _MathMax(ushort    value1,         ushort      value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         ushort      value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         ushort      value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uchar     value1,         uint        value2) { return(MathMax(value1, value2)); };
uint      _MathMax(ushort    value1,         uint        value2) { return(MathMax(value1, value2)); };
uint      _MathMax(uint      value1,         uint        value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         uint        value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(uchar     value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ushort    value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(uint      value1,         ulong       value2) { return(MathMax(value1, value2)); };
ulong     _MathMax(ulong     value1,         ulong       value2) { return(MathMax(value1, value2)); };
char      _MathMax(char      value1,         char        value2) { return(MathMax(value1, value2)); };
short     _MathMax(short     value1,         char        value2) { return(MathMax(value1, value2)); };
int       _MathMax(int       value1,         char        value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         char        value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         char        value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         char        value2) { return(MathMax(value1, value2)); };
short     _MathMax(char      value1,         short       value2) { return(MathMax(value1, value2)); };
short     _MathMax(short     value1,         short       value2) { return(MathMax(value1, value2)); };
int       _MathMax(int       value1,         short       value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         short       value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         short       value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         short       value2) { return(MathMax(value1, value2)); };
int       _MathMax(char      value1,         int         value2) { return(MathMax(value1, value2)); };
int       _MathMax(short     value1,         int         value2) { return(MathMax(value1, value2)); };
int       _MathMax(int       value1,         int         value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         int         value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         int         value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         int         value2) { return(MathMax(value1, value2)); };
long      _MathMax(char      value1,         long        value2) { return(MathMax(value1, value2)); };
long      _MathMax(short     value1,         long        value2) { return(MathMax(value1, value2)); };
long      _MathMax(int       value1,         long        value2) { return(MathMax(value1, value2)); };
long      _MathMax(long      value1,         long        value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         long        value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         long        value2) { return(MathMax(value1, value2)); };
float     _MathMax(char      value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(short     value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(int       value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(long      value1,         float       value2) { return(MathMax(value1, value2)); };
float     _MathMax(float     value1,         float       value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         float       value2) { return(MathMax(value1, value2)); };
double    _MathMax(char      value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(short     value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(int       value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(long      value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(float     value1,         double      value2) { return(MathMax(value1, value2)); };
double    _MathMax(double    value1,         double      value2) { return(MathMax(value1, value2)); };
string    _MathMax(string    value1,         string      value2) { return(MathMax(value1, value2)); };

unsigned right shift mql5 documentation errors, defaults Any questions from newcomers

amrali 2023.05.05 10:27 #17

100 overloads for intercepting MathMix() and alike for MathMin().

Interesting!

No relation to the typecast graph.

Dominik Egert 2023.05.05 10:33 #18

amrali #:

100 overload for intercepting MathMix() and alike for MathMin().

Interesting!

No relation to the typecast graph.

Well... - Think about MathPow... it supports also matrix* and vector* but not their combination, MathPow(matrix, vector) isnt valid.... - so a template wont do the job.

I would say a more lax relation to typecasting, 5 situations will gracefully loose data by applying MathMin/MathMax...

Machine learning in trading: Matrices and vectors in Any questions from a

Dominik Egert 2023.05.05 11:18 #19

Here is the result for MathPow, and MathMod, they behave the same, code-wise....

Interestingly there is one set thats not considered valid, but why? Accounts for both functions

float MathXXX(float, uint)


double      _MathPow(char     base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         uchar           exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         ushort          exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         uint            exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         uint            exponent)          { return(MathPow(base, exponent)); };            // This is not accepted to be valid, but why???
double      _MathPow(double   base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         ulong           exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         double          exponent)          { return(MathPow(base, exponent)); };

Dominik Egert 2023.05.05 11:18 #20

Because of limitations by the forum... here the second half

double      _MathPow(uchar    base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         uchar           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         ushort          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         uint            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uchar    base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ushort   base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(uint     base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(ulong    base,         ulong           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         char            exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         char            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         short           exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         short           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         int             exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         int             exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         long            exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         long            exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         float           exponent)          { return(MathPow(base, exponent)); };
float       _MathPow(float    base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         float           exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(char     base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(short    base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(int      base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(long     base,         double          exponent)          { return(MathPow(base, exponent)); };
double      _MathPow(double   base,         double          exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         uchar           exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         ushort          exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         uint            exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         ulong           exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         char            exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         short           exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         int             exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         long            exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         float           exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         double          exponent)          { return(MathPow(base, exponent)); };
matrix      _MathPow(matrix&  base,         matrix&         exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         uchar           exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         ushort          exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         uint            exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         ulong           exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         char            exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         short           exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         int             exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         long            exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         float           exponent)          { return(MathPow(base, exponent)); };
matrixf     _MathPow(matrixf& base,         matrixf&        exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         uchar           exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         ushort          exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         uint            exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         ulong           exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         char            exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         short           exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         int             exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         long            exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         float           exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         double          exponent)          { return(MathPow(base, exponent)); };
vector      _MathPow(vector&  base,         vector&         exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         uchar           exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         ushort          exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         uint            exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         ulong           exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         char            exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         short           exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         int             exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         long            exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         float           exponent)          { return(MathPow(base, exponent)); };
vectorf     _MathPow(vectorf& base,         vectorf&        exponent)          { return(MathPow(base, exponent)); };

1 2 3

New comment