Need some help to account for commissions in EA

Quoting genie

Disliked

If an EA puts on a trade with a risk of a % of account balance, how can I include the commission charged by the broker into the total % of my risk? The problem I am having is that the commission charged depends on the lot size and I don't know how much I will be charged until AFTER I have entered (via market order), because the EA calculates the lot size required to suit my predefined % of risk based on stop loss placement.

For example, I enter a position with 1% risk of my $100,000 account. Commission is $600. If I get stopped out, I lose $1000...

Ignored

Quoting genie

Disliked

Is there a way to include this commission without having the programmer changing the EA?

Ignored

Quoting LLaP

Disliked

The equation which calculates the lot size looks like this: lots=(balance*risk)/(stoploss*tickvalue).
It has to be changed to lots=(balance*risk)/[(stoploss+comission)*tickvalue].
That is easy for any programmer.

Ignored

Quoting LLaP

Disliked

The equation which calculates the lot size looks like this: lots=(balance*risk)/(stoploss*tickvalue).
It has to be changed to lots=(balance*risk)/[(stoploss+comission)*tickvalue].
That is easy for any programmer.

Ignored

Quoting genie

Disliked

The issue is that commission is based on lot size, not account equity. Which means it will vary according to the lot size put on by the EA, so we have 2 unknown variables in the equation?

Ignored

  int minimum = (AccountEquity() * risk_as_fraction_of_100 - 2 * commission_per_minimum_tradable_size) / base_value_per_minimum_tradable_size / sl_points;
  double lot = minimum * minimum_tradable_size_as_fraction_of_stdlot;

Quoting m.m.m.

Disliked

What you guys talking about?

The OP asked if the commission can be included *without* altering the original code.

Of course one can calculate the commission in, but has to alter the code..

The formula I would use (as commission is yet unknown..):

Inserted Code

  int minimum = (AccountEquity() * risk_as_fraction_of_100 - 2 * commission_per_minimum_tradable_size) / base_value_per_minimum_tradable_size / sl_points;
  double lot = minimum * minimum_tradable_size_as_fraction_of_stdlot;

Ignored

Quoting nubcake

Disliked

and the answer was "no". of course the code needs to be altered. that part is the easy part to answer.

Ignored

Quoting m.m.m.

Disliked

Right.

But, if he cannot alter the code then all the debating is pointless.

Anyway, let's wait and see how OP will proceed.

Ignored

Quoting genie

Disliked

Hey guys, thanks for all the replies. nubcake is right, I originally wanted to know if there was a way to do this on the non-programming side but soon it was evident that there wasn't. I did not want to request more changes to the programmer if it was not necessary. So since it was established that it will need to be done on the programming side, it is logical to continue the thread to find out how to calculate it.

I am not a programmer of course, so I don't understand the formulae you guys are posting. However, nubcake's explanation on #8 does...

Ignored

Quoting nubcake

Disliked

you need to be crystal clear. the way i read what you are saying is that the commission is some function of the lot size, and just scales as the lot size is changed.

e.g. 1 lot has commission of $1, and 100 lots has commission of $100. and so on. commission is just some fraction * the lot size.

are you saying that 1 lot could have commission of $1, 50 lots a commission of $23.50 lots, and 100 lots a commission of $102.78?

if there is no rhyme or reason to the formulation of the commission then... that's lame.

Ignored

potential_loss +=MathAbs(InstantOpen-StopLoss)/Point*MarketInfo(Symbol(),MODE_TICKVALUE)*InstantLot+OrderSwap()+ OrderCommission();

Quote

Disliked

$3.5 Commission per 100k trade

Quoting fxtr51

Disliked

Since the lot-size will change each time the user is moving the SL-line further or nearer to the Entry-line,
the OrderCommission will change determined by multiplying the new LotSize with a fix factor.

I am figuring out how to code the formula now and that is the whole point of this thread.

The RiskPercent is given.
The Lotsize is calculated according to the RiskPercent and the distance of StopLoss to the Entry.
And now I need to calculate the potential profit and potential loss in AccountCurrency (not all accounts
are held in Dollars) .

Ignored

Quoting nubcake

Disliked

so they manually enter a commission amount in the settings.

Ignored

Quote

Disliked

so it's like i said earlier. because i can't figure the algebra on this (and if anyone has any insight into working the algebra) i would just iterate the lot size upwards until it exceeds the set risk, then step down one. or are you saying you don't know how to calculate the money on a potential order?

Quoting fxtr51

Disliked

Yes, I think there is no other way, we need the input manually.



It is the calculation of the money I haven´t figured out a formula yet.

The broker publishes $ 3.50 commission for 100k on his website.
The account is held in Euro.

The Lotsize is no problem, I use the standard calculation everybody uses which returns the correct
lotsize ( that formula does the calculation so the account currency is included)

Now all I need is calculating the money in account currency for the potential profit at TP-line
and the money for the potential loss...

Ignored

//+------------------------------------------------------------------+
//|                                               nbToolsInclude.mq4 |
//|                                                          nubcake |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "nubcake"
#property link      ""

int iCumulativeBuyMoney, iCumulativeSellMoney;
double dCumulativeBuyPrice, dCumulativeSellPrice;

int iCumulativeLockedPoints;  //locked-in by stoplosses
double dCumulativeLockedMoney;
double dCumulativeLockedReward;

datetime bartimearray[10];  //used for testing if a backtest is unpaused (so that intense indi's can stop processing each bar slowing everything down)
bool testerseemsunpaused;

void nbToolInit() {
  int i;
  datetime tc;
  
  testerseemsunpaused = true;
  tc = GetTickCount();
  for (i = 0; i < 10; i++) bartimearray[i] = tc;
}

void nbToolRegisterNewBar() {
  int i;
  datetime tc;
  
  tc = GetTickCount();
  
  for (i = 9; i > 0; i--) bartimearray[i] = bartimearray[i-1];
  bartimearray[0] = tc;
  
  testerseemsunpaused = false;
  if (bartimearray[0] - bartimearray[9] < 1000) testerseemsunpaused = true;
}

bool f_nbToolTesterSeemsUnpaused() {
  return(testerseemsunpaused);
}

string f_nbToolOrderTypeToString(int OrderTypeNum) {
  string s;
  
  s = "UNKNOWN TICKET TYPE";
  switch(OrderTypeNum) {
    case OP_BUY : s = "BUY"; break;
    case OP_BUYLIMIT : s = "BUY LIMIT"; break;
    case OP_BUYSTOP : s = "BUY STOP"; break;
    case OP_SELL : s = "SELL"; break;
    case OP_SELLLIMIT : s = "SELL LIMIT"; break;
    case OP_SELLSTOP : s = "SELL STOP"; break;
  }
  
  return(s);
}

double f_nbToolPointsAsPips(int p, int dig) {
  double r;
  
  r = p;
  if (dig > 2) {
    while ((dig != 2) && (dig != 4)) {
      dig--;
      r = r / 10;
    }
  }
  
  return(r);
}

double f_nbToolPriceAsPips(double p, int dig) {
  p = f_nbToolPointsAsPips(p * MathPow(10, dig), dig);
  return(p);
}

//double f_nbToolCalcMoneyProfit(bool islong, double lotsize, double openprice, double closeprice) {
//int f_nbToolCalcPointsProfit(bool islong, double openprice, double closeprice) {
//double f_nbToolCalcRewardProfit(bool islong, double openprice, double closeprice, int riskpoints) {

double f_nbToolCalcMoneyProfit(bool islong, double lotsize, double openprice, double closeprice, double pricescale) {
  double funds;
 
/*  dtemp = openprice * 100000 * lotsize;
  dtemp2 = closeprice * 100000 * lotsize;
  if (islong) {
    dtemp = dtemp2 - dtemp;
  } else {
    dtemp = dtemp - dtemp2;      
  }  
  
  return(dtemp); */

  if (islong) {
    funds = -100000 * lotsize * (openprice * pricescale);
    funds = funds + 100000 * lotsize * (closeprice * pricescale);
  } else {
    funds = 100000 * lotsize * (openprice * pricescale);
    funds = funds + (-100000 * lotsize * (closeprice * pricescale));
  }
 
  return(funds);
}

int f_nbToolCalcPointsProfit(bool islong, double openprice, double closeprice) {
  double dtemp;
  int itemp;
  
  if (islong) {
    dtemp = closeprice - openprice;
  } else {
    dtemp = openprice - closeprice;
  }
  
  itemp = NormalizeDouble(dtemp * MathPow(10, Digits), 0);
  
  return(itemp);
}

double f_nbToolCalcRewardProfit(bool islong, double openprice, double closeprice, int riskpoints) {
  double dtemp;
  
  dtemp = 0;
  if (riskpoints > 0) {
    dtemp = f_nbToolCalcPointsProfit(islong, openprice, closeprice);
    dtemp = dtemp / riskpoints;
  }
  
  return(dtemp);
}

int nbToolResetPositionData() {
  iCumulativeBuyMoney = 0;
  iCumulativeSellMoney = 0;
  dCumulativeBuyPrice = 0;
  dCumulativeSellPrice = 0;
  
  iCumulativeLockedPoints = 0;
  dCumulativeLockedMoney = 0;
  dCumulativeLockedReward = 0;
  
  return(0);
}

int nbToolAddPositionData(bool islong, double lotsize, double openprice, double stopprice, int riskpoints, double pricescale) {
  if (islong == true) {
    iCumulativeBuyMoney += 100000 * lotsize;
    dCumulativeBuyPrice = dCumulativeBuyPrice + openprice * 100000 * lotsize;    
  } else {
    iCumulativeSellMoney += 100000 * lotsize;
    dCumulativeSellPrice = dCumulativeSellPrice + openprice * 100000 * lotsize;    
  }
  
  iCumulativeLockedPoints += f_nbToolCalcPointsProfit(islong, openprice, stopprice);
  dCumulativeLockedMoney = dCumulativeLockedMoney + f_nbToolCalcMoneyProfit(islong, lotsize, openprice, stopprice, pricescale);
  dCumulativeLockedReward = dCumulativeLockedReward + f_nbToolCalcRewardProfit(islong, openprice, stopprice, riskpoints);
  
  return(0);
}

double f_nbToolAveragePrice(bool islong) {
  double d;

  d = iCumulativeBuyMoney;
  if (d > 0) d = dCumulativeBuyPrice / d;
  if (islong == false) {
    d = iCumulativeSellMoney;
    if (d > 0) d = dCumulativeSellPrice / d;
  }
  
  return(d);
}

int f_nbToolTotalLockedPoints() {
  return(iCumulativeLockedPoints);
}

double f_nbToolTotalLockedMoney() {
  return(dCumulativeLockedMoney);
}