CDouble & CDoubleVector - libreria per MetaTrader 5

A library for common rounding methods used in MQL development, primitive wrapper class for type (double), and vector for CDouble objects. MQL5 and MQL4 compatible!

CDouble

The CDouble class wraps a value of the primitive type double in an object. Additionally, this class provides several methods and static methods for rounding doubles and arrays/collections of type double.

Declaration

class CDouble : public CObject

Title

#include <Double.mqh>

Inheritance hierarchy

• CObject
  • CDouble

Virtual Methods implemented/overridden from class CObject: Type, Load, Save, Compare.

An object of type CDouble contains five data fields:

string

m_symbol

double

m_value

uchar

m_step

uchar

m_digits

ENUM_PRECISION

m_mode

Before we get any further into the docs, here is a quick practical example of the wrapper class in action:

MqlTick tick;
   SymbolInfoTick(_Symbol,tick);
   CDouble  price = tick.ask - 0.0087263487676283476,
            sl    = price - 500*_Point,
            tp    = price + 500*_Point,
            lots  = 5.25 / 3.78789;
   MqlTradeRequest r={0};
   r.symbol= _Symbol;
   r.price = price.AsRoundedTick();
   r.sl    = sl.AsRoundedTick();
   r.tp    = tp.AsRoundedTick();
   r.volume= lots.AsRoundedLots();
...

Another example using the static library methods:

MqlTick tick;
   SymbolInfoTick(_Symbol,tick);
   MqlTradeRequest r={0};
   r.symbol= _Symbol;
   r.price = tick.ask - 0.0087263487676283476,
   r.sl    = price - 500*_Point,
   r.tp    = price + 500*_Point,
   r.volume= 5.25 / 3.78789;
   ...
   CDouble::RoundTradeRequest(r);
   //automatically rounds the price fields to tick size
   //and the volume to lot step

Static Method Summary

Note: It is not necessary to know OOP or use a wrapper class instance in order to make use of this library. All one has to do is call the static functions with CDouble scope resolution. The syntax is as follows:

type variable_name = CDouble::Method(args);

static bool

IsEqual
(double number1,
 double number2,
 double step);

static bool

IsEqual
(double number1,
 double number2,
 int digits);

static int

Compare
(double number1,
 double number2,
 double step)

static double

RoundToStep
(const double number, 
 double step)

static double

RoundToDigit
(const double number, 
 int digits)

static double

RoundToStepUp
(const double number, 
 double step)

static double

RoundToStepDown
(const double number, 
 double step)

static double

RoundToTick
(const double number, 
 string symbol=NULL)

static double

RoundToLots
(const double number,
 string symbol=NULL,
 bool always_return_valid=true)

static void (MQL5)

RoundTradeRequest
(MqlTradeRequest &request)

static void

RoundArrayToStep
(double &arr[],
 double step = NULL)

static void

RoundArrayToStep
(CArrayDouble &arr,
 double step = NULL)

static int

GetDigits
(double floating_point)

static double 

GetPoint
(int digits)

static string

ToString
(double number,
 int digits)

Examples:

MqlTick tick;
   SymbolInfoTick(_Symbol,tick);
   double rnd_by_step   = CDouble::RoundToStep(tick.bid*1.052565465,_Point);
   double rnd_by_digits = CDouble::RoundToDigit(tick.bid*1.052565465,_Digits);
   double by_lot_step   = CDouble::RoundToLots(0.123423,_Symbol);
   double by_tick_size  = CDouble::RoundToTick(tick.ask-100*_Point,_Symbol);
   double roundup       = CDouble::RoundToStepUp(3.999999999,_Point);
   double rounddn       = CDouble::RoundToStepDown(3.999999999,_Point);
   int    digits        = CDouble::GetDigits(0.0000025);
   double point         = CDouble::GetPoint(10);
   bool   equal         = CDouble::IsEqual(tick.bid,tick.bid+0.00000009,_Point);
   string tostr         = CDouble::ToString(3.1399999999999999);
   int    compare       = CDouble::Compare(tick.ask,tick.bid);
   
#ifdef __MQL5__
   MqlTradeRequest r={0};
   r.symbol= _Symbol;
   r.price = tick.ask+0.000089849847658759198199999;
   r.sl    = r.price - 503 * _Point;
   r.tp    = r.price + 503 * _Point;
   r.volume= 1.127984984;
   
   CDouble::RoundTradeRequest(r);
#endif 

Constructor Summary

CDouble
(const ENUM_PRECISION mode = PRECISION_DEFAULT,
 const string symbol = NULL)

CDouble
(const CDouble &other)

Examples:

CDouble num;
CDouble bid(PRECISION_TICK_SIZE, _Symbol);
CDouble ask(bid)
CDouble ask2 = bid;
CDouble lots(PRECISION_LOT_STEP, _Symbol);

Assignment Summary - Overloaded Assignment Operators

void

Set(const double value)

void

Set(const CDouble &other)

void

Note: the = assignment operator can be called in the same line as the declaration.

Examples:

CDouble bid;
bid.Set(tick.bid);
CDouble ask = tick.ask;

CDouble pi = 3.14;
CDouble factor = 2;
pi*=factor;
Print(pi.ToString());
//6.28

Overloaded Arithmetic Operator Summary

double

Note: Only one arithmetic operator can be used per statement.

Syntax for overloaded operator arithmetic:

type_double_result <-- CDouble_object <-- operator <-- double
//CDouble object always goes on the left side of the operator

type_double_result <-- CDouble_object1 <-- operator <-- CDouble_object2
//order doesn't matter when using two CDouble objects.

Examples:

CDouble foo    = 3.14;
CDouble bar    = 10;
CDouble foobar = bar + foo;          //13.14
CDouble err    = bar + foo + foobar; //error - illegal operation use

double var = bar / foo;

Overloaded Comparison Operator Summary

bool

Examples:

CDouble foo = 3.14, bar = 3.139999999999999999999;
   
   Print(foo == bar); //true
   Print(foo <= bar); //true
   Print(foo >  bar); //false

Instance Method Summary

Precision Control (defaults): digits = 8; step = 1e-08

• There are three ways to control precision: Step, Digits, or PrecisionMode(ENUM_PRECISION). Any call to either of these setter methods will override the previous settings.
• Step is either the _Point or LOT_STEP or TickSize; represented as a floating point (e.g. 0.00001, 0.025, etc.)
• It is not necessary to set the step since RoundToTick and RoundToLot automatically use the appropriate step values for the rounded-return.

void

PrecisionMode
(const ENUM_PRECISION mode)

ENUM_PRECISION

PrecisionMode()

void

Step
(const double step_or_point)

double

Step()

void

Digits
(const int digits)

int

Digits()

double

AsRawDouble()

double

AsRounded()

double

AsRoundedUp()

double

AsRoundedDown()

double

AsRoundedTick()

double

AsRoundedLots
(bool always_return_valid = true)

int

ToInt()

long

ToLong()

string

ToStringPrecision()

string

ToString()

string

Symbol()

string

Symbol(const string symbol)

Examples:

CDouble pi2 = 3.14159265359;
   
   // getting value as... 
   double raw_double             = pi2.AsRawDouble();
   double round_double_to_step   = pi2.AsRounded();
   double tick_size_double       = pi2.AsRoundedTick();
   double lot_step_double        = pi2.AsRoundedLots();
   double rounded_up             = pi2.AsRoundedUp();
   double rounded_down           = pi2.AsRoundedDown();
   int    double_to_int          = pi2.ToInt();
   long   double_to_long         = pi2.ToLong();
   string precision_str          = pi2.ToStringPrecision();
   pi2 = 3.140000000009;
   pi2.Digits(8);
   string truncated_str          = pi2.ToString();

Virtual Method Summary

Methods overridden from CObject:

virtual int

Compare
(const CObject *node,
 const int mode=0)

virtual int

Type()

virtual bool

Save(const int file_handle)

virtual bool

Load(const int file_handle)

See CDoubleVector below for examples.

CDoubleVector

The CDoubleVector class is an object pointer collection specialized for CDouble dynamic instances.

Declaration

class CDoubleVector : public CArrayObj

Title

#include <Double.mqh>

Inheritance hierarchy

• CObject
  • CArray
    • CArrayObj
      • CDoubleVector

Virtual Methods implemented/overridden from class CArrayObj: CreateElement.

Instance Method Summary

**See CArrayObj for inherited public methods.

CDouble*

operator[]
(const int index)

bool

Add(const double value)

bool

AssignDoubleArray
(const double &array[])

bool

CopyOut(double &arr[])

bool

CopyOut(CArrayDouble &arr)

virtual bool

Save(const int file_handle)

virtual bool

Load(const int file_handle)

Examples:

CDoubleVector *vect = new CDoubleVector;
   
   double dubs[]={3.14,1.21,55.555};
   vect.AssignDoubleArray(dubs);
   vect.Add(tick.bid);
   
   //calling CDouble object by index
   Print(vect[vect.Total()-1].ToString());
   
   //add a new CDouble object
   CDouble *lot = new CDouble(PRECISION_LOT_STEP);
   lot = 1.22;
   vect.Add(lot);
   
   //sort vector ascending
   vect.Sort();
   
   int total = vect.Total();
   
   //save vector to file including CDouble object states and values
   string f = "testdub.bin";
   int    h = FileOpen(f,FILE_WRITE|FILE_BIN);
   if(vect.Save(h))
      Print("save successful");
   FileClose(h);
   delete vect;
   
   //load vector from file
   CDoubleVector vect_reborn;
   h=FileOpen(f,FILE_READ|FILE_BIN);
   if(vect_reborn.Load(h))
      Print("load successful");
   FileClose(h);
   total = vect_reborn.Total();
   Print("Total vector size = ",sizeof(vect_reborn)," bytes");
   for(int i=0;i<vect_reborn.Total();i++)
      Print(vect_reborn[i].ToString());
      
   //Copy out to double arr
   double arr2[];
   vect_reborn.CopyOut(arr2);
   Print(ArraySize(arr2));