Consolidate Python ignore rules into root gitignore
This commit is contained in:
Hiroaki86
@@ -0,0 +1,411 @@
|
||||
//+------------------------------------------------------------------+
|
||||
//| bitconvert.mqh |
|
||||
//| Copyright 2003-2022 Sergey Bochkanov (ALGLIB project) |
|
||||
//| Copyright 2012-2026, MetaQuotes Ltd. |
|
||||
//| www.mql5.com |
|
||||
//+------------------------------------------------------------------+
|
||||
//| Implementation of ALGLIB library in MetaQuotes Language 5 |
|
||||
//| |
|
||||
//| The features of the library include: |
|
||||
//| - Linear algebra (direct algorithms, EVD, SVD) |
|
||||
//| - Solving systems of linear and non-linear equations |
|
||||
//| - Interpolation |
|
||||
//| - Optimization |
|
||||
//| - FFT (Fast Fourier Transform) |
|
||||
//| - Numerical integration |
|
||||
//| - Linear and nonlinear least-squares fitting |
|
||||
//| - Ordinary differential equations |
|
||||
//| - Computation of special functions |
|
||||
//| - Descriptive statistics and hypothesis testing |
|
||||
//| - Data analysis - classification, regression |
|
||||
//| - Implementing linear algebra algorithms, interpolation, etc. |
|
||||
//| in high-precision arithmetic (using MPFR) |
|
||||
//| |
|
||||
//| This file is free software; you can redistribute it and/or |
|
||||
//| modify it under the terms of the GNU General Public License as |
|
||||
//| published by the Free Software Foundation (www.fsf.org); either |
|
||||
//| version 2 of the License, or (at your option) any later version. |
|
||||
//| |
|
||||
//| This program is distributed in the hope that it will be useful, |
|
||||
//| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
//| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
//| GNU General Public License for more details. |
|
||||
//+------------------------------------------------------------------+
|
||||
#include "arrayresize.mqh"
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting numbers into an array of bits and vice versa |
|
||||
//+------------------------------------------------------------------+
|
||||
class BitConverter
|
||||
{
|
||||
public:
|
||||
static void GetBytes(const int d,uchar &bytes[]);
|
||||
static void GetBytes(const double d,uchar &bytes[]);
|
||||
static int ToInt32(uchar &bytes[]);
|
||||
static double ToDouble(uchar &bytes[]);
|
||||
static bool IsLittleEndian(void);
|
||||
};
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting integer to a byte array |
|
||||
//+------------------------------------------------------------------+
|
||||
void BitConverter::GetBytes(const int d,uchar &bytes[])
|
||||
{
|
||||
//--- create variables
|
||||
int x;
|
||||
int q;
|
||||
int r;
|
||||
int i;
|
||||
int div;
|
||||
//--- allocation
|
||||
ArrayResize(bytes,4);
|
||||
for(i=0; i<4; i++)
|
||||
{
|
||||
//--- check
|
||||
if(d>=0)
|
||||
bytes[i]=0;
|
||||
else
|
||||
bytes[i]=255;
|
||||
}
|
||||
//--- initialization
|
||||
q=-1;
|
||||
r=-1;
|
||||
i=3;
|
||||
div=256*256*256;
|
||||
//--- check
|
||||
if(d<0)
|
||||
x=~d;
|
||||
else
|
||||
x=d;
|
||||
//--- converting number
|
||||
while(i!=-1)
|
||||
{
|
||||
//--- quotient
|
||||
q=x/div;
|
||||
//--- remainder of division
|
||||
r=x%div;
|
||||
//--- get byte
|
||||
if(d>=0)
|
||||
bytes[i]+=(uchar)q;
|
||||
else
|
||||
bytes[i]-=(uchar)q;
|
||||
//--- the next iteration is reduced divisor
|
||||
x=r;
|
||||
div=div/256;
|
||||
i--;
|
||||
}
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting double to a byte array |
|
||||
//+------------------------------------------------------------------+
|
||||
void BitConverter::GetBytes(const double d,uchar &bytes[])
|
||||
{
|
||||
//--- module
|
||||
double abs_d=MathAbs(d);
|
||||
//--- number without its fractional
|
||||
double floor_d=MathFloor(abs_d);
|
||||
//--- fractional part
|
||||
double fractional_d=abs_d-floor_d;
|
||||
//--- variable will store the degree
|
||||
int power;
|
||||
//--- exponent shift
|
||||
double exp_shift;
|
||||
//--- create variables
|
||||
int k;
|
||||
int j;
|
||||
uchar u;
|
||||
double step;
|
||||
double f;
|
||||
//--- abs_d as bits
|
||||
bool abs_d_to_bitArray[];
|
||||
//--- d as bits in format IEEE 754
|
||||
bool d_to_bitArray[];
|
||||
//--- allocation
|
||||
ArrayResizeAL(d_to_bitArray,64);
|
||||
ArrayResizeAL(bytes,8);
|
||||
//--- initialization
|
||||
power=0;
|
||||
//--- for integer part
|
||||
while(1)
|
||||
{
|
||||
//--- if the number is less than or equal floor_d, we increase the degree
|
||||
//--- if 2^power > floor_d, then maximal number < floor_d - it 2^(power-1)
|
||||
if(floor_d>=MathPow(2,power))
|
||||
power++;
|
||||
else
|
||||
break;
|
||||
}
|
||||
//--- get power-1
|
||||
power--;
|
||||
//--- if power=-1, then floor_d=0
|
||||
//--- find a negative power for the fractional part
|
||||
if(power==-1)
|
||||
{
|
||||
power=0;
|
||||
while(1)
|
||||
{
|
||||
//--- the same principle as above
|
||||
if(fractional_d<MathPow(2,power))
|
||||
power--;
|
||||
else
|
||||
break;
|
||||
}
|
||||
}
|
||||
//--- convert decimal to binary
|
||||
j=0;
|
||||
step=power;
|
||||
while(abs_d!=0.0)
|
||||
{
|
||||
f=MathPow(2,step);
|
||||
//--- check
|
||||
if(f>abs_d)
|
||||
{
|
||||
//--- if abs_d < f - this bit is zero
|
||||
ArrayResize(abs_d_to_bitArray,j+1);
|
||||
abs_d_to_bitArray[j]=0;
|
||||
j++;
|
||||
step-=1;
|
||||
}
|
||||
else
|
||||
{
|
||||
//--- if abs_d >= f, then this bit is equal one
|
||||
//--- reduction abs_d
|
||||
abs_d-=f;
|
||||
ArrayResize(abs_d_to_bitArray,j+1);
|
||||
abs_d_to_bitArray[j]=1;
|
||||
j++;
|
||||
step-=1;
|
||||
}
|
||||
}
|
||||
//--- according to IEEE 754,
|
||||
//--- zero bit determines sign of the number, 0 -> '+', 1 -> '-'.
|
||||
if(d>=0)
|
||||
d_to_bitArray[0]=0;
|
||||
else
|
||||
d_to_bitArray[0]=1;
|
||||
//--- offset input
|
||||
exp_shift=1023+power;
|
||||
//--- bits from the first and 11 are reserved for the shifted exponential
|
||||
j=1;
|
||||
for(int i=10; i>=0; i--)
|
||||
{
|
||||
if(MathPow(2,i)>exp_shift)
|
||||
d_to_bitArray[j]=0;
|
||||
else
|
||||
{
|
||||
d_to_bitArray[j]=1;
|
||||
//--- reduction
|
||||
exp_shift-=MathPow(2,i);
|
||||
}
|
||||
j++;
|
||||
}
|
||||
//--- Get the length of the array of the binary representation of abs_d
|
||||
k=ArraySize(abs_d_to_bitArray);
|
||||
j=1;
|
||||
//--- Bits from 12 to 63 are filled with binary representation of abs_b
|
||||
//--- the first element abs_d_to_bitArray is always 1
|
||||
for(int i=12; i<64; i++)
|
||||
{
|
||||
if(j<k)
|
||||
{
|
||||
d_to_bitArray[i]=abs_d_to_bitArray[i-11];
|
||||
j++;
|
||||
}
|
||||
else
|
||||
d_to_bitArray[i]=0;
|
||||
}
|
||||
//--- reverse
|
||||
ArrayReverse(d_to_bitArray);
|
||||
//--- converting bit array to byte array
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
u=0;
|
||||
//--- get byte
|
||||
for(int t=0; t<8; t++)
|
||||
u+=(uchar)(d_to_bitArray[i*8+t]*MathPow(2,t));
|
||||
//--- save byte
|
||||
bytes[i]=u;
|
||||
}
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting byte array to a integer |
|
||||
//+------------------------------------------------------------------+
|
||||
int BitConverter::ToInt32(uchar &bytes[])
|
||||
{
|
||||
//--- get size
|
||||
int size=ArraySize(bytes);
|
||||
//--- create variables
|
||||
int d=0;
|
||||
int mul=256*256*256;
|
||||
//--- get number
|
||||
for(int i=size-1; i>=0; i--)
|
||||
{
|
||||
d+=bytes[i]*mul;
|
||||
mul=mul/256;
|
||||
}
|
||||
//--- return result
|
||||
return(d);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Converting byte array to a double |
|
||||
//+------------------------------------------------------------------+
|
||||
double BitConverter::ToDouble(uchar &bytes[])
|
||||
{
|
||||
//--- create variables
|
||||
int s;
|
||||
//--- exponent shift
|
||||
int e=0;
|
||||
//--- mantissa
|
||||
double m=0;
|
||||
//--- array of bits in IEEE 754
|
||||
bool bits[];
|
||||
ArrayResize(bits,64);
|
||||
//--- get array of bits from array of bytes
|
||||
for(int i=0; i<8; i++)
|
||||
{
|
||||
for(int j=7; j>=0; j--)
|
||||
{
|
||||
//--- if 2 in power >, bits[i*8+j]=0, else bits[i*8+j]=0
|
||||
if(MathPow(2,j)>bytes[i])
|
||||
bits[i*8+j]=0;
|
||||
else
|
||||
{
|
||||
bits[i*8+j]=1;
|
||||
//--- reduction
|
||||
bytes[i]-=(uchar)MathPow(2,j);
|
||||
}
|
||||
}
|
||||
}
|
||||
//--- search bits with 1
|
||||
bool allzero=true;
|
||||
for(int i=0; i<64; i++)
|
||||
if(bits[i]==1)
|
||||
allzero=false;
|
||||
//--- if all bits are 0, then number is 0
|
||||
if(allzero==true)
|
||||
return(0.0);
|
||||
//--- reverse array
|
||||
ArrayReverse(bits);
|
||||
//--- s-the first bit, determines sign of the number
|
||||
s=bits[0];
|
||||
//--- calculation exponent shift
|
||||
for(int i=10; i>=0; i--)
|
||||
e+=(int)(bits[11-i]*MathPow(2,i));
|
||||
//--- get mantissa
|
||||
for(int i=0; i<52; i++)
|
||||
m+=bits[12+i]*MathPow(2,-1-i);
|
||||
//--- return result
|
||||
return(MathPow(-1,s)*MathPow(2,e-1023)*(1+m));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Byte ordering (forward, backward) |
|
||||
//+------------------------------------------------------------------+
|
||||
bool BitConverter::IsLittleEndian(void)
|
||||
{
|
||||
//--- forward
|
||||
return(true);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Get string from char array |
|
||||
//+------------------------------------------------------------------+
|
||||
string GetSelectionString(char &buf[],int startIndex,int lenght)
|
||||
{
|
||||
return(CharArrayToString(buf,startIndex,lenght));
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Get sign of number |
|
||||
//+------------------------------------------------------------------+
|
||||
double MathSign(const double x)
|
||||
{
|
||||
//--- if x>0
|
||||
if(x>0)
|
||||
return(1);
|
||||
//--- if ?==0
|
||||
if(x==0)
|
||||
return(0);
|
||||
//--- ?<0
|
||||
return(-1);
|
||||
}
|
||||
|
||||
//+------------------------------------------------------------------+
|
||||
//| Structure stores a variable of type double |
|
||||
//+------------------------------------------------------------------+
|
||||
union UDoubleValue
|
||||
{
|
||||
double value;
|
||||
long bits;
|
||||
|
||||
UDoubleValue(double dbl): value(dbl) { }
|
||||
UDoubleValue(long bit_value): bits(bit_value) { }
|
||||
};
|
||||
//+------------------------------------------------------------------+
|
||||
//| Work with infinity and NaN |
|
||||
//+------------------------------------------------------------------+
|
||||
class CInfOrNaN
|
||||
{
|
||||
public:
|
||||
//--- checks
|
||||
static bool IsPositiveInfinity(const double x);
|
||||
static bool IsNegativeInfinity(const double x);
|
||||
static bool IsInfinity(const double x);
|
||||
static bool IsNaN(const double x);
|
||||
//--- generation values
|
||||
static double PositiveInfinity(void);
|
||||
static double NegativeInfinity(void);
|
||||
static double NaN(void);
|
||||
};
|
||||
//+------------------------------------------------------------------+
|
||||
//| Check for +inf |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CInfOrNaN::IsPositiveInfinity(const double x)
|
||||
{
|
||||
UDoubleValue val=x;
|
||||
//--- check
|
||||
return(val.bits==0x7FF0000000000000);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Check for -inf |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CInfOrNaN::IsNegativeInfinity(const double x)
|
||||
{
|
||||
UDoubleValue val=x;
|
||||
//--- check
|
||||
return(val.bits==0xFFF0000000000000);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Check for +-inf |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CInfOrNaN::IsInfinity(const double x)
|
||||
{
|
||||
return(MathClassify(x)==FP_INFINITE);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Check for NaN |
|
||||
//+------------------------------------------------------------------+
|
||||
bool CInfOrNaN::IsNaN(const double x)
|
||||
{
|
||||
return(MathClassify(x)==FP_NAN);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Return +inf |
|
||||
//+------------------------------------------------------------------+
|
||||
double CInfOrNaN::PositiveInfinity(void)
|
||||
{
|
||||
UDoubleValue val(0x7FF0000000000000);
|
||||
return(val.value);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Return -inf |
|
||||
//+------------------------------------------------------------------+
|
||||
double CInfOrNaN::NegativeInfinity(void)
|
||||
{
|
||||
UDoubleValue val(0xFFF0000000000000);
|
||||
return(val.value);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
//| Return NaN |
|
||||
//+------------------------------------------------------------------+
|
||||
double CInfOrNaN::NaN(void)
|
||||
{
|
||||
UDoubleValue val(0x7FFFFFFFFFFFFFFF);
|
||||
return(val.value);
|
||||
}
|
||||
//+------------------------------------------------------------------+
|
||||
Reference in New Issue
Block a user