{
 Function PredictedRoR
 Statistical method for predicting future system trade results
 based on past trades.

 Copyright 2006 Breakout Futures
 www.BreakoutFutures.com

}
 input: NBack      (NumericSimple),    { # trades in average return, back }
        NForw      (NumericSimple),    { # trades in ave return, forward }
        NBins      (NumericSimple),    { # of bins }
        ReqMarg    (NumericSimple),    { Required margin per contract }
        SysName    (StringSimple),     { name of system calling this function }
        FName      (StringSimple);     { file name to write results to }

 Var:  ii        (0),     { loop counter }
       iave      (0),     { loop counter }
       ibin      (0),     { loop counter }
       iStart    (0),     { index of first trade to analyze }
       iEnd      (0),     { index of last trade }
       Sum       (0),     { sum of trade p/l's }
       NTrades   (0),     { number of trades }
       NTNew     (0),     { Number of new trades on current bar }
       NData     (0),     { number of data points }
       MinRoR    (0),     { minimum backward RoR }
       MaxRoR    (0),     { maximum backward RoR }
       ActNBins  (0),     { number of bins actually used }
       BinSize   (0),     { size of bins }
       NItems    (0),     { number of items in bin }
       TooFew    (TRUE),  { flag for setting bins }
       CurrRoR   (0),     { most recent RoR, looking back }
       CurrBin   (0),     { bin location of current RoR }
       CurrPred  (0),     { prediction based on bin value }
       Found     (FALSE), 
       StrOut    ("");     

 Array: TradePL[2000](0),    { Trade profit/losses }
        RoRF[2000](0),       { forward return }
        RoRB[2000](0),       { backward return }
        BinL[20](0),         { lower boundary of bin }
        BinU[20](0),         { upper boundary of bin }
        BinVal[20](0);       { value of bin }

 { Record trade profit/losses }
 NTNew = TotalTrades - NTrades;
 If NTNew > 0 then Begin
    for ii = 0 to NTNew - 1 Begin
		TradePL[NTrades] = PositionProfit(NTNew - ii);
        NTrades = NTrades + 1;
	End;
 End;

 { Compute results and write to file }
 If LastBarOnchart then Begin
    iStart = NBack - 1;
    iEnd = NTrades - NForw - 1;
    NData = iEnd - iStart + 1;

    { Calculate backward and forward returns }
    For ii = iStart to iEnd Begin
		
        { Calculate average trade return over last NBack trades }
        Sum = 0;
        For iave = 0 to NBack - 1 Begin
            Sum = Sum + TradePL[ii - NBack + iave + 1];
        End;

        if NBack > 0 and ReqMarg > 0 then
           Sum = Sum/NBack/ReqMarg;

        RoRB[ii - iStart] = Sum;

        { Track min and max backward returns }
        if ii = iStart then Begin
           MinRoR = Sum;
           MaxRoR = Sum;
        End;
		if Sum > MaxRoR then
           MaxRoR = Sum;
        if Sum < MinRoR then
           MinRoR = Sum;

        { Calculate average trade return over next NForw trades }
        Sum = 0;
        For iave = 0 to NForw - 1 Begin
            Sum = Sum + TradePL[ii + iave + 1];
        End;

        if NForw > 0 and ReqMarg > 0 then
           Sum = Sum/NForw/ReqMarg;

        RoRF[ii - iStart] = Sum;
    End;

    MaxRoR = MaxRoR * 1.01;   { Make sure last bin contains highest RoR }

    { Calculate average trade return over most recent NBack trades }
    Sum = 0;
    For iave = 0 to NBack - 1 Begin
        Sum = Sum + TradePL[NTrades - NBack + iave];
    End;

    if NBack > 0 and ReqMarg > 0 then
       CurrRoR = Sum/NBack/ReqMarg;

    { Collect data into bins based on backward looking returns }
    ActNBins = NBins;
    TooFew = TRUE;
    While ActNBins >= 3 and TooFew Begin
        TooFew = FALSE;
        BinSize = (MaxRoR - MinRoR)/ActNBins;
        For ibin = 0 to ActNBins - 1 Begin
            BinL[ibin] = MinRoR + BinSize * ibin;
            BinU[ibin] = BinL[ibin] + BinSize;

            Sum = 0;
            NItems = 0;
            For ii = 0 to NData - 1 Begin
                if RoRB[ii] >= BinL[ibin] and RoRB[ii] < BinU[ibin] then Begin
                   Sum = Sum + RoRF[ii];
                   NItems = NItems + 1;
                End;
            End;
            if NItems < 3 then
               TooFew = TRUE
            else
               BinVal[ibin] = Sum/NItems;
        End;

        { If too few trades in any bin, reduce # of bins }
        if TooFew then
           ActNBins = ActNBins  - 1;
    End;

    { Determine which bin current RoR is in and return prediction }
    if ActNBins >= 3 then Begin
       ibin = 0;
       Found = FALSE;
       While ibin < ActNBins and Found = FALSE Begin
           if CurrRoR >= BinL[ibin] and CurrRoR < BinU[ibin] then Begin
              CurrBin = ibin + 1;
              CurrPred = BinVal[ibin];
              Found = TRUE;
           End;
           ibin = ibin + 1;
       End;
		
       { Write results to file }
       FileAppend(FName, NewLine + "PREDICTEDROR Function" + NewLine + NewLine);
       FileAppend(FName, "Date/Time Generated: " + NumtoStr(CurrentDate, 0) + "/" +
                         NumtoStr(CurrentTime, 0) + NewLine);
       FileAppend(FName, "Symbol: " + GetSymbolName + NewLine);
       FileAppend(FName, "Strategy: " + SysName + NewLine);
       FileAppend(FName, "Look-back Length: " + NumtoStr(NBack, 0) + NewLine);
       FileAppend(FName, "Look-forward Length: " + NumtoStr(NForw, 0) + NewLine);
       FileAppend(FName, "Margin Requirement: $" + NumtoStr(ReqMarg, 2) + NewLine);
       FileAppend(FName, NewLine + "Results:" + NewLine);
       FileAppend(FName, "Current Rate of Return: " + NumtoStr(100 * CurrRoR, 3) + NewLine);
       FileAppend(FName, "Predicted Rate of Return: " + NumtoStr(100 * CurrPred, 3) + NewLine);
       FileAppend(FName, NewLine + "Bin, Lower RoR, Upper RoR, Predicted RoR" + NewLine);
       For ibin = 0 to ActNBins - 1 Begin
           StrOut = NumtoStr(ibin + 1, 0) + ", " + NumtoStr(100 * BinL[ibin], 3) + ",  " + 
                    NumtoStr(100 * BinU[ibin], 3) + ",  " + NumtoStr(100 * BinVal[ibin], 3) + NewLine;
           FileAppend(FName, StrOut);
       End;
    End
    Else Begin
	
       { Write error message }
	 FileAppend(FName, "Insufficient data for minimum number of bins." + NewLine);
    End;
 End;

 PredictedRoR = CurrPred;