
 function [P,C] = Split_mu_modificato(node,C)
%% PREPARAZIONE
global Stati

P=CreateMatrixTransition(Stati,1);
OrderInout=zeros(length(node.out),length(node.in));
OrderInoutPeso=zeros(length(node.out),length(node.in));
SortedOut=sort([node.out]);

for i=1:length(node.out)
        
    [FoundElementsRow FoundElementsCol] =find(node.inout == SortedOut(i));
   for j=1:length(FoundElementsCol)
    OrderInout(i,FoundElementsCol(j))=(node.inout(FoundElementsRow(j),FoundElementsCol(j)));
    OrderInoutPeso(i,FoundElementsCol(j))=(node.inoutPeso(FoundElementsRow(j),FoundElementsCol(j)));
   end    

end    

% normalizzaCol per normalizzare in base alle colonne, l'idea di base è
% effettuare la dizzerenza a 2 a 2 dei vari vettori e calcolare la norma di
% quello che esce, si splitta se il valore è > di un certo delta.

delta=ones(length(node.in))*-1;
q=0;

vincolo=0;

q=1;

    
for i=1:length(node.in)
    for j=1:length(node.in)
       
        delta(i,j)=indiceOrtogonalita(OrderInoutPeso(:,i),OrderInoutPeso(:,j));
    end
end

valoreTaglio=0.2;

[righe colonne]=find(delta<=valoreTaglio) ;

%% RICERCA CANDIDATI SPLIT
while vincolo==0 && q<=length(righe) && isempty(righe)==0



% righe e colonne sono gli indici dei 2 vettori colonna linearmente indipendenti.
if norm(node.inoutPeso(:,righe(q)))>1 && norm(node.inoutPeso(:,colonne(q)))>1
    vincolo=1;

end
q=q+1;
end

if (isempty(righe)==0)&& q<=length(righe)

    % Altro controllo possibile e' ignorare quando uno dei vettori che ha
    % generato l'ortogonalita' ha norma piccola es [1 1 0 0] 

  
    righe=righe(q);
colonne=colonne(q);

Partizione1=righe;
Partizione2=colonne;



for i=1:length(node.in)
    if (i~=righe) && (i~=colonne)
       if delta(i,righe)>delta(i,colonne)
          Partizione1=[Partizione1 i];
       else
          Partizione2=[Partizione2 i]; 
       end
    end
end
Partizione1;
Partizione2;



%% effettua lo split

app1=node;  %i 2 nuovi stati dopo lo split
app2=node;
numnodi=length(Stati)+1;

app1.inoutPeso=OrderInoutPeso;
app1.inout=OrderInout;

app2.inoutPeso=OrderInoutPeso;
app2.inout=OrderInout;


       app1.apice=[node.apice 1];  % crea un path formato da 1s e 2s 
       app2.apice=[node.apice 2];
       app2.pos=numnodi;
       
       app1.in=[node.in app2.pos] ;  
       
       
       %vettore che indica gli stati precedenti         
       
       mu1=10^-5;  %<====== PARAMETRO IMPOSTABILE riferito alla transizione fra i 2 app
       
       app1.in_peso=[node.in_peso mean(node.in_peso)*mu1];     %rispettivi pesi
       app1.in_tempo=[node.in_tempo mean(node.in_tempo)];
       app1.inout=[app1.inout [SortedOut]'];
       app1.inoutPeso=[app1.inoutPeso app1.inout(:,Partizione1(1))*0];
       
       
       app2.in=[node.in app1.pos] ;       %vettore che indica gli stati precedenti         
       app2.in_peso=[node.in_peso mean(node.in_peso)*mu1];     %rispettivi pesi
       app2.in_tempo=[node.in_tempo mean(node.in_tempo)];
       app2.inout=[app2.inout app2.inout(:,Partizione2(1))*0];
       
       
       app2.inoutPeso=[app2.inoutPeso app2.inout(:,Partizione2(1))];
  
       for i=1:length(node.in)
         
           peso1=delta(Partizione1(1),i)/(delta(Partizione1(1),i)+delta(Partizione2(1),i));  %assegla un peso al nodo 1 e 2 in dase a delta
           peso2=delta(Partizione2(1),i)/(delta(Partizione1(1),i)+delta(Partizione2(1),i));  %peso1+peso2=1
           
           
           % se la colonna relativa all'ingresso esaminato è ortogonale
           % a entrambe le "rappresentante dell'insieme" assegla il peso ad
           % una delle due (si splitterà un'altra volta)
           
           if isnan(peso1)==1
               peso1=0;
               peso2=1;
           end
          
   
           app1.in_peso(i)=node.in_peso(i)*peso1;  %distribuisce gli ingressi a seconda del peso
           app2.in_peso(i)=node.in_peso(i)*peso2;
           
           
           % come sopra solo che è per la matrice inout
           
           app1.inoutPeso(:,i)=OrderInoutPeso(:,i)*peso1;
           app2.inoutPeso(:,i)=OrderInoutPeso(:,i)*peso2;
           
          if (node.in(i)~=node.pos) && (node.in(i)~=numnodi)    
           temp=Stati(node.in(i));        %temporanea (carica lo stato precedente)
          
           %inizio modifica stato precedente relativo ill'ingresso preso in considerazione 
           temp.out=[temp.out numnodi];   
           
           % cerco all'interno dell'array out dello stato da cui provvengo
           % il nodo "di interesse"
           
           cost=temp.out_peso(find(temp.out==node.pos));  %variabile temporanea

           %lo riinserisco pesandolo
           temp.out_peso(find(temp.out==node.pos))=cost*peso1;
           temp.out_peso=[temp.out_peso cost*peso2];
           
           % procedo alla modifica di inout
           
           
           [temporaryrow temporarycol] =find(temp.inout==node.pos); % ricerca
                   
                 
          if isempty(temporaryrow)==0

           temporary=temp.inout(temporaryrow(1),:);% acquisizione vettore
           
           temp.inout= [temp.inout;temporary*numnodi/node.pos]; %creo il vettore di puntatori al nuovo stato creato
          
           cost=temp.inoutPeso(temporaryrow(1),:);% carico nella variabile cost i pesi
           
           % li riscrivo pesati
           temp.inoutPeso(temporaryrow(1),:)=cost*peso1;
           temp.inoutPeso= [temp.inoutPeso;cost*peso2];    
           % salvo le modifiche
          end 
           Stati(node.in(i))=temp;
         end
       end

 
         
        % su out dei 2 stati vanno le somme per riga della matrice inout
         app1.out_peso=[sum(app1.inoutPeso') ]; 
         app2.out_peso=[sum(app2.inoutPeso') ];
      
         [rig col]=size(app1.inoutPeso);
         
         mu2=mu1;
         
         app1.inoutPeso(:,col)=app1.out_peso'*mu2;
         [rig1 col1]=size(app2.inoutPeso);
         app2.inoutPeso(:,col1)=app2.out_peso'*mu2;
         
         
   
         app1.inoutPeso(rig+1,:)=app1.in_peso*mu2;
        
         app2.inoutPeso(rig1+1,:)=app2.in_peso*mu2;
         
         
         app1.out_peso=[app1.out_peso mean(app1.out_peso)*mu1 ]; 
         app2.out_peso=[app2.out_peso mean(app2.out_peso)*mu1];
         
         
         app1.out=[SortedOut app2.pos]; % aggiungo gli anelli che uniscono i 2 stati splittati
         app2.out=[SortedOut app1.pos];

         
      for i=1:length(node.out)
         if (node.out(i)~=node.pos) && (node.out(i)~=numnodi) 
          temp=Stati(node.out(i));
          
          temp.in=[temp.in numnodi];
          
          position2=find(app2.out==temp.pos);
          
          temp.in_peso=[temp.in_peso app2.out_peso(position2)];
         
          
          position1=find(app1.out==temp.pos);
          posIn=find(temp.in==node.pos);
          ww=temp.in;
          df=temp.inout;
          qq=temp.pos;
          temp.in_peso(posIn)=app1.out_peso(position1);
          temp.in_tempo=[temp.in_tempo temp.in_tempo(posIn)];
  
          temp.inout=[temp.inout temp.inout(:,posIn)];
 
          cost= temp.inoutPeso(:,posIn);

          % prende le 2 colonne della matrice e le divide pesandole tenendo
          % conto dei pesi usati per calcolare la matrice out degli stati
          % verso quel nodo.
          temp.inoutPeso(:,posIn)= cost*app1.out_peso(position1)/((1e-100)+app1.out_peso(position1)+app2.out_peso(position2));
          temp.inoutPeso=[temp.inoutPeso cost*app2.out_peso(position2)/((1e-100)+app1.out_peso(position1)+app2.out_peso(position2))];
          
          Stati(node.out(i))=temp;
         end    
      end

% salvo modifiche
Stati(node.pos)=app1;
Stati(length(Stati)+1)=app2;

%%  AGGIORNAMENTO C
    C=[C C(:,node.pos)];
    P=CreateMatrixTransition(Stati,1);


end











