Lot calculation

Quoting nondisclosure00

Disliked

So, I know this topic has been beat to death. So I'm here to beat it up some more. Given the following formula: Lot=((Account_Balance*Risk_Percentage)/100)/(StopLoss*tickvalue) Given these values: Account_Balance=1000 Risk_Percentage=3 StopLoss=300 tickvalue=1 I get a value of 0.1. Now, that's great if I'm on a micro account (10,000 units=1 lot). But if I'm on a standard account (100,000 units = 1 lost) then the calculation is off. So, how does lot size play into this calculation? Right now it doesn't, and it should. Note: assume 5 digit broker,...

Ignored

PL = PriceDiff / MODE_TICKSIZE * MODE_TICKVALUE * Volume

double accountBalance = 1000.00;
double riskPercentage = 3.0;
int    stopLoss       = 300;        // always in pips
 
double tickSize  = MarketInfo(Symbol(), MODE_TICKSIZE);
double tickValue = MarketInfo(Symbol(), MODE_TICKVALUE);
 
// decimal digits of 1 pip (0, 2 or 4)
int pipDigits = Digits & (~1);                                      
 
// size of 1 pip (1.00, 0.01 or 0.0001)
double pip  = NormalizeDouble(1/MathPow(10, pipDigits), pipDigits);  
 
// resulting lots
double lots = (accountBalance * riskPercentage/100) / (stopLoss*pip / tickSize * tickValue);

Quoting nondisclosure00

Disliked

Lot=(Account_Balance*Risk_Percentage)/(StopLoss*tickvalue)

Ignored

Quoting emmzett

Disliked

{quote} I do not agree with @RedLineFred. Imho you should define price distances in the most natural way and that's always "pip". Next issue: You should not have to worry about account types and 2, 3, 4 or 5 digits (broker and symbol dependant). Instead you should always write logic in a way that it works everywhere. We start here: PL calculation from entry to exit. We have: PL = PriceDiff / MODE_TICKSIZE * MODE_TICKVALUE * Volume PL is your risk, PriceDiff is your...

Ignored

Quoting nondisclosure00

Disliked

{quote} Thanks for the brilliant explanation. I get most of your code. a question (I probably knew this at one time, but after 5 strokes; memory gets faded): Digits & (~1) I'm not sure what this does. Specifically the & (~1).

Ignored

int pipDigits = Digits - Digits % 2;   // two operations (subtraction + modulo)

int a = 100; // binary format: 1100100 (more leading zeros ommitted)
int b = 12;  // binary format: 0001100 (more leading zeros ommitted)

a & b = 4;   // binary format: 100 (all leading zeros removed)

int c = 1;       // binary format: 00000000000000000000000000000001 (with leading zeros)
~1 = 4294967294; // binary format: 11111111111111111111111111111110

Digits, e.g. 5   // binary format: 00000000000000000000000000000101 (with leading zeros)
~1               // binary format: 11111111111111111111111111111110

Digits    = 0   // binary format: 00000000 (more leading zeros ommitted)
pipDigits = 0   // binary format: 00000000 (more leading zeros ommitted)

Digits    = 1   // binary format: 00000001
pipDigits = 0   // binary format: 00000000

Digits    = 2   // binary format: 00000010
pipDigits = 2   // binary format: 00000010

Digits    = 3   // binary format: 00000011
pipDigits = 2   // binary format: 00000010

Digits    = 4   // binary format: 00000100
pipDigits = 4   // binary format: 00000100

Digits    = 5   // binary format: 00000101
pipDigits = 4   // binary format: 00000100

Quoting RedLineFred

Disliked

would be a lot simpler working in ticks

Ignored

Quoting emmzett

Disliked

{quote} TL;DR: "Digits & (~1)" is a bitwise operator expression and the fastest possible method to round an integer value down to the next even number. It's a shorter way of writing int pipDigits = Digits - Digits % 2; // two operations (subtraction + modulo) The underlying logic assumes "Digits" may be any value (even or odd) but the number of decimal digits of 1 pip is always even (0, 2, 4, ...). Long explanation: "&" is the binary AND operator. It works on bits instead of on regular decimal numbers and says: combine left (Digits) and right (~1)...

Ignored

...
...
...
   RefreshRates();  
      
   //MARKET DATA
   totalOrdr=OrdersTotal();
   double unit_cost = MarketInfo(_Symbol,MODE_TICKVALUE);
   dSpreadValue = MarketInfo(_Symbol, MODE_SPREAD);  
  
   tickValue = unit_cost*point;    
   CalculateRisk(); // Risk Calculation ONLY
   PipValue = ((ValuePerLot()*totalOpenLots)/100000000)/(IsPips == true ? 10 : 100);
   tickSize = PipValue;
   pair = _Symbol;
   pair = StringSubstr(pair,0,6);
   tickSize = fmax(tickSize,0.000001)/10000000;
 
   ATR_pips = (fmax(((fmax(iATR(_Symbol, xTF, ATR1_period, 0), iATR(_Symbol, xTF, ATR2_period, 0)) / tickSize)/1000000000),0.000001));
 
   ATR_pips *= (IsPips == true ? 10 : 100);
   TP_pips = NormalizeDouble((ATR_pips * TP_multiplier),2);
   SL_pips = NormalizeDouble((ATR_pips * SL_multiplier),2); 
...
...
...
double ValuePerLot() { // Value in account currency of a Point of Symbol.
   double xperlot = 0.0;
     tickSize = 0.00000001*(MarketInfo(_Symbol,MODE_TICKSIZE));
     double PipValuePerLot = (tickValue/tickSize);
     xperlot = PipValuePerLot; // Point or equivalent Pip(s)
   return(xperlot);    
}

Quoting emmzett

Disliked

{quote} A tick can be 0.01, or 0.02, or 0.05 or even 0.25. Good luck with that.

Ignored

Quoting emmzett

Disliked

{quote} I do not agree with @RedLineFred. Imho you should define price distances in the most natural way and that's always "pip". Next issue: You should not have to worry about account types and 2, 3, 4 or 5 digits (broker and symbol dependant). Instead you should always write logic in a way that it works everywhere. We start here: PL calculation from entry to exit. We have: PL = PriceDiff / MODE_TICKSIZE * MODE_TICKVALUE * Volume PL is your risk, PriceDiff is your...

Ignored

Quoting nondisclosure00

Disliked

{quote} I know it's been a while, but how do we take leverage into account in your formula?

Ignored

Quoting nondisclosure00

Disliked

{quote} I know it's been a while, but how do we take leverage into account in your formula?

Ignored