clc;

nb_echelon=6;		% nombre d'echelon  entre les bornes suivantes pour les sorties progressives max 20
b_inf_prof=40;		% borne inferieure de l'intervalle de profit en pip
b_sup_prof=270;     % borne superieure de l'intervalle de profit en pip
b_inf_pour=10;		% borne inferieure de l'intervalle de pourcentage du trailing stop
b_sup_pour=90;		% borne superieure de l'intervalle de pourcentage du trailing stop
type_fonc_prof=1;	% type de fonction pour la taille de l'echelon liee au profit : 1=alpha (constant) ; 2=x^alpha*(sin(x))^beta
alpha_prof=1;	%-2:1:2	% alpha pour la fonction lie au profit selon la fonction choisie
beta_prof=1;     %-1:1:1	% beta pour a fonction lie au profit selon la fonction choisie
type_fonc_pour=1;	% type de fontcion pour la taille de l'echelon liee au pourcentage : 1=alpha (constant) ; 2=x^alpha*(sin(x))^beta
alpha_pour=1;	%-2:1:2	% alpha pour a fonction lie au pourcentage selon la fonction choisie
beta_pour=1;     %-1:1:1	% beta pour a fonction lie au pourcentage selon la fonction choisie
len=70;%10:10:
deltastopmin=35;
SL=65;%10:10:70
pfmin=100;
nattente=280;
lenmoy=895;
TP=0;%10:1:20

tick1=0.0001;
deltaLoss=2;
RSIlim=20;
maxbarback=900;
rsilen=14;

spread=3*tick1;

[lig,~]=find(time1==0);
time1(lig)=2400;
date1(lig)=date1(lig-1);

rsi=RSI_TS(close1(maxbarback+1:end),rsilen);
rsi(1:rsilen+1)=NaN;

[ligdebut,~]=find(date==date1(maxbarback));
[ligdebut2,~]=find(time(ligdebut)==time1(maxbarback));

nb_pas=size(nb_echelon,2)*size(b_inf_prof,2)*size(b_sup_prof,2)*size(b_inf_pour,2)*size(b_sup_pour,2)*...
    size(alpha_prof,2)*size(beta_prof,2)*size(alpha_pour,2)*size(beta_pour,2)*size(len,2)*...
    size(deltastopmin,2)*size(SL,2)*size(pfmin,2)*size(nattente,2)*size(lenmoy,2)*size(TP,2);
equity=zeros(1,nb_pas);
val_test=zeros(16,nb_pas);
num_pas=0;

for le=1:size(len,2)
    mystopH=hhigh(high1,len(le));
    mystopH(1:len(le))=NaN;
    mystopS=llow(low1,len(le));
    mystopS(1:len(le))=NaN;
    for lemo=1:size(lenmoy,2)
        mymoy=xaverage_TS(close1(maxbarback+1:end),lenmoy(lemo));
        for nb_e=1:size(nb_echelon,2)
            for bipr=1:size(b_inf_prof,2)
                for bspr=1:size(b_sup_prof,2)
                    for bipo=1:size(b_inf_pour,2)
                        for bspo=1:size(b_sup_pour,2)
                            for apr=1:size(alpha_prof,2)
                                for bpr=1:size(beta_prof,2)
                                    for apo=1:size(alpha_pour,2)
                                        for bpo=1:size(beta_pour,2)
                                            for delta=1:size(deltastopmin,2)
                                                for sl=1:size(SL,2)
                                                    for pf=1:size(pfmin,2)
                                                        for na=1:size(nattente,2)
                                                            for tp=1:size(TP,2)
                                                                num_pas=num_pas+1;
                                                                val_test(16,num_pas)=TP(tp);
                                                                val_test(15,num_pas)=lenmoy(lemo);
                                                                val_test(14,num_pas)=nattente(na);
                                                                val_test(13,num_pas)=pfmin(pf);
                                                                val_test(12,num_pas)=SL(sl);
                                                                val_test(11,num_pas)=deltastopmin(delta);
                                                                val_test(10,num_pas)=len(le);
                                                                val_test(9,num_pas)=beta_pour(bpo);
                                                                val_test(8,num_pas)=alpha_pour(apo);
                                                                val_test(7,num_pas)=beta_prof(bpr);
                                                                val_test(6,num_pas)=alpha_prof(apr);
                                                                val_test(5,num_pas)=b_sup_pour(bspo);
                                                                val_test(4,num_pas)=b_inf_pour(bipo);
                                                                val_test(3,num_pas)=b_sup_prof(bspr);
                                                                val_test(2,num_pas)=b_inf_prof(bipr);
                                                                val_test(1,num_pas)=nb_echelon(nb_e);
                                                                tic;
                                                                % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                
                                                                marketposition=0;
                                                                feu=0;
                                                                k=maxbarback+1;
                                                                nb_p=0;
                                                                entrypxB=0;
                                                                entrypxS=0;
                                                                ProfitMax=0;
                                                                myrsi=0;
                                                                StopS=0;
                                                                StopH=0;
                                                                PHpose=0;
                                                                PLpose=0;
                                                                moy=0;
                                                                compteur=nattente(na);
                                                                test=0;
                                                                ofloor=0;
                                                                opercent=0;
                                                                TSB=0;
                                                                TSS=0;
                                                                TPB=0;
                                                                TPS=0;
                                                                stoplossB=0;
                                                                stoplossB2=0;
                                                                stoplossS=0;
                                                                stoplossS2=0;
                                                                trade=-1e6*ones(size(close,1),1);
                                                                clear trades
                                                                
                                                                for i=(ligdebut(ligdebut2))+1:size(time,1)
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    % ////////////// Les sorties long et short sur stop loss
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    if marketposition==1 && TPB~=0 && TPB<=high(i) && TPB>high(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=max(open(i),TPB)-entrypxB2;
                                                                        %         trade(i,1)=TPB;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxB;
                                                                        entrypxB=0;
                                                                    end;
                                                                    if marketposition==1 && TSB~=0 && TSB>=low(i) && TSB<low(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=min(open(i),TSB)-entrypxB2;
                                                                        %         trade(i,1)=TSB;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxB;
                                                                        entrypxB=0;
                                                                    end;
                                                                    if marketposition==1 && stoplossB2~=0 && stoplossB2>=low(i) && stoplossB2<low(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=min(open(i),stoplossB2)-entrypxB2;
                                                                        %         trade(i,1)=stoplossB2;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxB;
                                                                        entrypxB=0;
                                                                    end;
                                                                    if marketposition==1 && stoplossB~=0 && stoplossB>=low(i) && stoplossB<low(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=min(open(i),stoplossB)-entrypxB2;
                                                                        %         trade(i,1)=stoplossB;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxB;
                                                                        entrypxB=0;
                                                                    end;
                                                                    
                                                                    if marketposition==-1 && TPS~=0 && TPS>=low(i) && TPS<low(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=entrypxS2-min(open(i),TPS);
                                                                        %         trade(i,1)=TPS;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxS;
                                                                        entrypxS=0;
                                                                    end;
                                                                    if marketposition==-1 && TSS~=0 && TSS<=high(i) && TSS>high(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=entrypxS2-max(open(i),TSS);
                                                                        %         trade(i,1)=TSS;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxS;
                                                                        entrypxS=0;
                                                                    end;
                                                                    if marketposition==-1 && stoplossS2~=0 && stoplossS2<=high(i) && stoplossS2>high(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=entrypxS2-max(open(i),stoplossS2);
                                                                        %         trade(i,1)=stoplossS2;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxS;
                                                                        entrypxS=0;
                                                                    end;
                                                                    if marketposition==-1 && stoplossS~=0 && stoplossS<=high(i) && stoplossS>high(i-1)
                                                                        marketposition=0;
                                                                        trade(i,1)=entrypxS2-max(open(i),stoplossS);
                                                                        %         trade(i,1)=stoplossS;
                                                                        %         trade(i,5)=date1(k);
                                                                        %         trade(i,4)=trades_de;
                                                                        %         trade(i,3)=time1(k);
                                                                        %         trade(i,2)=trades_te;
                                                                        %         trade(i,6)=entrypxS;
                                                                        entrypxS=0;
                                                                    end;
                                                                    
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    % ////////////// Les entrees
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    
                                                                    if entrypxB~=0 && entrypxB<=high(i) && entrypxB>high(i-1) && marketposition==0 && nb_p==0
                                                                        entrypxB2=max(open(i),entrypxB);
                                                                        if marketposition==-1
                                                                            trade(i,1)=entrypxS2-entrypxB2;
                                                                            %             trade(i,1)=entrypxB;
                                                                            %             trade(i,5)=date1(k);
                                                                            %             trade(i,4)=trades_de;
                                                                            %             trade(i,3)=time1(k);
                                                                            %             trade(i,2)=trades_te;
                                                                            %             trade(i,6)=entrypxS;
                                                                            entrypxS=0;
                                                                        end;
                                                                        marketposition=1;
                                                                        %         trades_de=date1(k);
                                                                        %         trades_te=time1(k);
                                                                        nb_p=1;
                                                                    end;
                                                                    
                                                                    if entrypxS~=0 && entrypxS>=low(i) && entrypxS<low(i-1) && marketposition==0 && nb_p==0
                                                                        entrypxS2=min(open(i),entrypxS);
                                                                        if marketposition==1
                                                                            trade(i,1)=entrypxS2-entrypxB2;
                                                                            %             trade(i,1)=entrypxS;
                                                                            %             trade(i,5)=date1(k);
                                                                            %             trade(i,4)=trades_de;
                                                                            %             trade(i,3)=time1(k);
                                                                            %             trade(i,2)=trades_te;
                                                                            %             trade(i,6)=entrypxB;
                                                                            entrypxB=0;
                                                                        end;
                                                                        marketposition=-1;
                                                                        %         trades_de=date1(k);
                                                                        %         trades_te=time1(k);
                                                                        nb_p=1;
                                                                    end;
                                                                    
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    
                                                                    if time(i)>=time1(k) || (date(i)~=date1(k))
                                                                        if (feu==0) && (k>=(maxbarback+(lenmoy(lemo)-len(le))))
                                                                            feu=1;
                                                                        end;
                                                                        compteur=compteur+1;
                                                                        myrsi=rsi(k-maxbarback);
                                                                        moy=mymoy(k-maxbarback);
                                                                        StopH=mystopH(k);
                                                                        StopS=mystopS(k);
                                                                        k=k+1;
                                                                        nb_p=0;
                                                                    end;
                                                                    PHpose=max(PHpose,high(i));
                                                                    PLpose=min(PLpose,low(i));
                                                                    
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    % ////////////// Les sorties progressives en fonction du profit
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    % // long
                                                                    
                                                                    if marketposition==1
                                                                        ProfitMax=(PHpose-entrypxB)/tick1;
                                                                        ProfitMax=round(ProfitMax);
                                                                        if ProfitMax>=pfmin(pf)
                                                                            compteur=0;
                                                                        else
                                                                            compteur=nattente(na);
                                                                        end;
                                                                        if TP(tp)==0 
                                                                            if ProfitMax>=b_inf_prof
                                                                                [ofloor,opercent]=sortie_variable(ProfitMax,nb_echelon(nb_e),b_inf_prof(bipr),b_sup_prof(bspr),b_inf_pour(bipo),b_sup_pour(bspo),type_fonc_prof,alpha_prof(apr),beta_prof(bpr),type_fonc_pour,alpha_pour(apo),beta_pour(bpo));
                                                                                TSB=PHpose-opercent*(ProfitMax)*tick1/100;
                                                                            else
                                                                                TSB=0;
                                                                            end;
                                                                        end;
                                                                    end;
                                                                    
                                                                    % // short
                                                                    
                                                                    if marketposition==-1
                                                                        ProfitMax=(entrypxS-PLpose)/tick1;
                                                                        ProfitMax=round(ProfitMax);
                                                                        if ProfitMax>=pfmin(pf)
                                                                            compteur=0;
                                                                        else
                                                                            compteur=nattente(na);
                                                                        end;
                                                                        if TP(tp)==0
                                                                            if ProfitMax>=b_inf_prof
                                                                                [ofloor,opercent]=sortie_variable(ProfitMax,nb_echelon(nb_e),b_inf_prof(bipr),b_sup_prof(bspr),b_inf_pour(bipo),b_sup_pour(bspo),type_fonc_prof,alpha_prof(apr),beta_prof(bpr),type_fonc_pour,alpha_pour(apo),beta_pour(bpo));
                                                                                TSS=PLpose+opercent*(ProfitMax)*tick1/100;
                                                                            else
                                                                                TSS=0;
                                                                            end;
                                                                        end;
                                                                    end;
                                                                    
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    % ////////////// Les entrees et sorties
                                                                    % //////////////////////////////////////////////////////////////////////////////////////////////////////////
                                                                    %
                                                                    % // long avec une sortie short
                                                                    
                                                                    if marketposition~=1 && feu==1
                                                                        if (StopH-StopS)>deltastopmin(delta)*tick1
                                                                            stoplossS2=StopH+deltaLoss*tick1;
                                                                        else
                                                                            stoplossS2=0;
                                                                        end;
                                                                        if compteur>=nattente(na) && myrsi<(100-RSIlim)
                                                                            entrypxB=max(StopH,moy);
                                                                            stoplossB=entrypxB-SL(sl)*tick1;
                                                                            if TP(tp)~=0
                                                                                TPB=entrypxB+TP(tp)*tick1;
                                                                            end;
                                                                        else
                                                                            entrypxB=0;
                                                                            TPB=0;
                                                                        end;
                                                                        PHpose=high(i);
                                                                    end;
                                                                    
                                                                    % // short avec une sortie long
                                                                    
                                                                    if marketposition~=-1 && feu==1
                                                                        if (StopH-StopS)>deltastopmin(delta)*tick1
                                                                            stoplossB2=StopS-deltaLoss*tick1;
                                                                        else
                                                                            stoplossB2=0;
                                                                        end;
                                                                        if compteur>=nattente(na) && myrsi>RSIlim
                                                                            entrypxS=min(StopS,moy);
                                                                            stoplossS=entrypxS+SL(sl)*tick1;
                                                                            if TP(tp)~=0
                                                                                TPS=entrypxS-TP(tp)*tick1;
                                                                            end;
                                                                        else
                                                                            entrypxS=0;
                                                                            TPS=0;
                                                                        end;
                                                                        PLpose=low(i);
                                                                    end;
                                                                end;
                                                                [lig,col]=find(trade(:,1)~=-1e6);
                                                                trades=trade(lig,:);
                                                                trades(:,1)=100000*(trades(:,1)-spread);
                                                                equity(1:size(trades(:,1),1),num_pas)=cumsum(trades(:,1));
                                                                thetemps=toc;
                                                                tr=3;
                                                            end;
                                                        end;
                                                    end;
                                                end;
                                            end;
                                        end;
                                    end;
                                end;
                            end;
                        end;
                    end;
                end;
            end;
        end;
    end;
end;

maxDD=zeros(size(equity,2),1);
coefcor1=zeros(size(equity,2),1);
% coefcor2=zeros(size(equity,2),1);
for i=1:size(equity,2)
    interm=nonzeros(equity(:,i));
    maxDD(i)=maxdrawdown(interm,'arithmetic');
    coefcor1(i)=interm(end)/maxDD(i);
%     [p,S,~]= polyfit((1:size(interm))',nonzeros(equity(:,i)),1);
%     coefcor2(i)=p(1)/S.normr;
end;
