function [best_scn, best_scn_info_per, best_scn_train_nodes, best_scn_test_nodes] = SCN_Super_Parameter_Opt_INFO(iter_num, L_max,T_max, r,tol, data_X, data_y, test_X, test_y,Test_Nodes)
    % Parameters
    MaxIt = iter_num;
    nB = 1;
    len_lambdas = 10;
    nP = 30;
    [~,len_r] = size(r);
    dim = len_lambdas + len_r + 2;
    ub = [];
    lb = [];
    for i=1:len_lambdas
        ub = [ub 200];%[ub 5];%[ub 200];
        lb = [lb 100];%[lb 1];%[lb 100];
    end
    
    ub_r = linspace(0.9999999999,0.9999999999,len_r);
    lb_r = linspace(0.9,0.9,len_r);
    ub = [ub ub_r];
    lb = [lb lb_r];

    ub = [ub 2^40];
    lb = [lb 0];
    
    ub = [ub 10^9];
    lb = [lb 10^5];

    %% Initialization
    Cost=zeros(nP,1);
    M=zeros(nP,1);
    X = rand(nP, dim).*(ub - lb) + lb;
    Best_Cost = inf;
    best_scn_info_per = [];
    for i=1:nP
        Lambdas = X(i,1:len_lambdas);
        scn_r = X(i,len_lambdas + 1:len_lambdas+len_r);
        eta = X(i, end - 1);
        gamma = X(i,end);
        scn = SCN_Reg(L_max, T_max, tol, Lambdas, scn_r , eta, gamma, nB);
        [scn, Train_Nodes_RMSEs, Test_Nodes_RMSEs] = scn.Regression_Nodes(data_X, data_y, test_X, test_y,Test_Nodes);
        
        [rmse, ~, ~,~] = scn.GetResult(data_X, data_y);
        Cost(i) = rmse;
        M(i)=Cost(i);
        if Cost(i)<Best_Cost
            Best_Cost = Cost(i);
            best_scn = scn;
             best_scn_train_nodes = Train_Nodes_RMSEs;
            best_scn_test_nodes = Test_Nodes_RMSEs;
%             best_scn_info_per = per.Error;
        end
    end
    
    [~, ind]=sort(Cost);
    Best_X = X(ind(1),:);
    Best_Cost = Cost(ind(1));
    
    Worst_Cost = Cost(ind(end));
    Worst_X = X(ind(end),:);
    
    I=randi([2 5]);
    Better_X=X(ind(I),:);
    Better_Cost=Cost(ind(I));
    
    %% Main Loop of INFO
    for it=1:MaxIt
        alpha=2*exp(-4*(it/MaxIt));                                                           % Eqs. (5.1) & % Eq. (9.1)
        
        M_Best=Best_Cost;
        M_Better=Better_Cost;
        M_Worst=Worst_Cost;
        
        for i=1:nP
            
            % Updating rule stage
            del=2*rand*alpha-alpha;                                                           % Eq. (5)
            sigm=2*rand*alpha-alpha;                                                          % Eq. (9)
            
            % Select three random solution
            A1=randperm(nP);
            A1(A1==i)=[];
            a=A1(1);b=A1(2);c=A1(3);
            
            e=1e-25;
            epsi=e*rand;
            
            omg = max([M(a) M(b) M(c)]);
            MM = [(M(a)-M(b)) (M(a)-M(c)) (M(b)-M(c))];
            
            W(1) = cos(MM(1)+pi)*exp(-abs(MM(1)/omg));                                           % Eq. (4.2)
            W(2) = cos(MM(2)+pi)*exp(-abs(MM(2)/omg));                                           % Eq. (4.3)
            W(3)= cos(MM(3)+pi)*exp(-abs(MM(3)/omg));                                            % Eq. (4.4)
            Wt = sum(W);
            
            WM1 = del.*(W(1).*(X(a,:)-X(b,:))+W(2).*(X(a,:)-X(c,:))+ ...                      % Eq. (4.1)
                W(3).*(X(b,:)-X(c,:)))/(Wt+1)+epsi;
            
            omg = max([M_Best M_Better M_Worst]);
            MM = [(M_Best-M_Better) (M_Best-M_Better) (M_Better-M_Worst)];
            
            W(1) = cos(MM(1)+pi)*exp(-abs(MM(1)/omg));                                        % Eq. (4.7)
            W(2) = cos(MM(2)+pi)*exp(-abs(MM(2)/omg));                                             % Eq. (4.8)
            W(3) = cos(MM(3)+pi)*exp(-abs(MM(3)/omg));                                             % Eq. (4.9)
            Wt = sum(W);
            
            WM2 = del.*(W(1).*(Best_X-Better_X)+W(2).*(Best_X-Worst_X)+ ...                   % Eq. (4.6)
                W(3).*(Better_X-Worst_X))/(Wt+1)+epsi;
            
            % Determine MeanRule
            r = unifrnd(0.1,0.5);
            MeanRule = r.*WM1+(1-r).*WM2;                                                     % Eq. (4)
            
            if rand<0.5
                z1 = X(i,:)+sigm.*(rand.*MeanRule)+randn.*(Best_X-X(a,:))/(M_Best-M(a)+1);
                z2 = Best_X+sigm.*(rand.*MeanRule)+randn.*(X(a,:)-X(b,:))/(M(a)-M(b)+1);
            else                                                                              % Eq. (8)
                z1 = X(a,:)+sigm.*(rand.*MeanRule)+randn.*(X(b,:)-X(c,:))/(M(b)-M(c)+1);
                z2 = Better_X+sigm.*(rand.*MeanRule)+randn.*(X(a,:)-X(b,:))/(M(a)-M(b)+1);
            end
            
            % Vector combining stage
            u=zeros(1,dim);
            for j=1:dim
                mu = 0.05*randn;
                if rand <0.5
                    if rand<0.5
                        u(j) = z1(j) + mu*abs(z1(j)-z2(j));                                   % Eq. (10.1)
                    else
                        u(j) = z2(j) + mu*abs(z1(j)-z2(j));                                   % Eq. (10.2)
                    end
                else
                    u(j) = X(i,j);                                                            % Eq. (10.3)
                end
            end
            
            % Local search stage
            if rand<0.5
                L=rand<0.5;v1=(1-L)*2*(rand)+L;v2=rand.*L+(1-L);                              % Eqs. (11.5) & % Eq. (11.6)
                Xavg=(X(a,:)+X(b,:)+X(c,:))/3;                                                % Eq. (11.4)
                phi=rand;
                Xrnd = phi.*(Xavg)+(1-phi)*(phi.*Better_X+(1-phi).*Best_X);                   % Eq. (11.3)
                Randn = L.*randn(1,dim)+(1-L).*randn;
                if rand<0.5
                    u = Best_X + Randn.*(MeanRule+randn.*(Best_X-X(a,:)));                    % Eq. (11.1)
                else
                    u = Xrnd + Randn.*(MeanRule+randn.*(v1*Best_X-v2*Xrnd));                  % Eq. (11.2)
                end
                
            end
            
            % Check if new solution go outside the search space and bring them back
            New_X= BC(u,lb,ub);
            Lambdas = New_X(1:len_lambdas);
            scn_r = New_X(len_lambdas+1:len_lambdas+len_r);
            eta = New_X(end - 1);
            gamma = New_X(end);
            scn = SCN_Reg(L_max, T_max, tol, Lambdas, scn_r , eta, gamma, nB);
%             [scn, per] = scn.Regression(data_X, data_y);
            [scn, Train_Nodes_RMSEs, Test_Nodes_RMSEs] = scn.Regression_Nodes(data_X, data_y, test_X, test_y,Test_Nodes);
            [rmse, ~, ~,~] = scn.GetResult(data_X, data_y);
            New_Cost = rmse;
            
            if New_Cost<Cost(i)
                X(i,:)=New_X;
                Cost(i)=New_Cost;
                M(i)=Cost(i);
                if Cost(i)<Best_Cost
                    Best_X=X(i,:);
                    Best_Cost = Cost(i);
                    best_scn = scn;
                    best_scn_train_nodes = Train_Nodes_RMSEs;
                    best_scn_test_nodes = Test_Nodes_RMSEs;
%                     best_scn_info_per = per.Error;
                end
            end
        end
        
        % Determine the worst solution
        [~, ind]=sort(Cost);
        Worst_X=X(ind(end),:);
        Worst_Cost=Cost(ind(end));
        % Determine the better solution
        I=randi([2 5]);
        Better_X=X(ind(I),:);
        Better_Cost=Cost(ind(I));
    end

end

function X = BC(X,lb,ub) 
Flag4ub=X>ub;
Flag4lb=X<lb;
X=(X.*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;
end