function [reihe,uewktmat]=reiheschreiben(anzahlfaktoren,stufenvec,anzahlelemente,zaehlmat,signallaenge,...
                                        wiederholungsstatus,anzahlwiederholungen,wiederholungsvec,...
                                        ausschlussstatus,ausschlussmat,faktorausschlussstatus,abshfgktmat,faktorausschlussmodus,berichtstatus)

%   reiheschreiben

%   This software is protected by german copyright and international treaties.             
%   Copyright 2004 Markus Junghöfer & Peter Peyk. All Rights Reserved.                     
%                                                                                          
%   THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE        
%   NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO,    
%   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE    
%   OF THE SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,
%   TRADEMARKS OR OTHER RIGHTS. COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT,       
%   INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE      
%   OR DOCUMENTATION.                                                                      
        
reihe=[];
reihecell=cell(1);
indicesstring='';
for z=1:anzahlfaktoren
    indicesstring=[indicesstring,'index(',num2str(z),'),'] ;  
end
indicesstring(length(indicesstring))=[];


if wiederholungsstatus == 1
    
        %Wiederholungsvec
        %---------------
        if isempty(anzahlwiederholungen)
            
                restelemente=mengenminus(linspace(1,anzahlelemente,anzahlelemente),ausschlussmat);
                restelemente=shuffle(restelemente);
                
                wiederholungsvecrest=[];
                for t=1:length(restelemente)
                    wiederholungsvecrest(t)=wiederholungsvec(restelemente(t));
                end
                wiederholungsvecausschluss=[];
                for t=1:length(ausschlussmat)
                    wiederholungsvecausschluss(t)=wiederholungsvec(ausschlussmat(t));
                end
                
                %eine Reihe vorgeben ungeachtet der Wiederholung
                %---------------------
                eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(1)));']);
                eval(['reihecell{restelemente(1)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(1);']);
                reihe=mergemat(reihecell{restelemente(1)},reihe,ausschlussmat,1,-1,0);
                if isempty(reihe)
                    reihe=[];
                    uewktmat = [];
                    return
                end
                
                
                %unkritische Elemente mergen
				%---------------------------
				for j=2:length(restelemente)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(j)));']);
                    eval(['reihecell{restelemente(j)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(j);']);
                    reihe=mergemat(reihecell{restelemente(j)},reihe,ausschlussmat,1,wiederholungsvecrest(j),0);
                    if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
				end 
                
				%ausschlusselemente mergen
				%--------------------------------
                
                ausschlussmattmp=shuffle(ausschlussmat);
				for i=1:length(ausschlussmat)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==ausschlussmattmp(i)));']);
                    eval(['reihecell{ausschlussmattmp(i)}=ones(1,abshfgktmat(',indicesstring,'))*ausschlussmattmp(i);']);
                    reihe=mergemat(reihecell{ausschlussmattmp(i)},reihe,ausschlussmat,1,wiederholungsvecausschluss(i),0);
                     if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
				end 
                
                %Wiederholungen und Ausschluss der ersten Reihe optimieren
                %------------------------------------------
                reihe=optimizerepandausschluss(restelemente(1),reihe,ausschlussmat,wiederholungsvec,0);
               
                %Uebergangswahrscheinlichkeiten
				%-----------------------------------
				anzahlmat=zeros(signallaenge,anzahlelemente);
				for u=1:anzahlelemente
				anzahlmat(:,u)=(u==reihe(:));
				end	
				anzahlvec=sum(anzahlmat);
				equalvec=(anzahlvec(1)==anzahlvec);
				uewktmat=zeros(anzahlelemente);
				for l=1:(signallaenge-1)
                   for m=1:anzahlelemente
                      for n=1:anzahlelemente
                         if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                            uewktmat(m,n)=uewktmat(m,n)+1;
                         end
                      end
                   end
				end
                
                
        %einfache Wiederholungsangabe
        %----------------------------
        
        else
            if anzahlwiederholungen == -1
                
				%unkritische Elemente mergen
				%---------------------------
				restelemente=mengenminus(linspace(1,anzahlelemente,anzahlelemente),ausschlussmat);
                restelemente= shuffle(restelemente);
				for j=1:length(restelemente)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(j)));']);
                    eval(['reihecell{restelemente(j)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(j);']);
                    reihe=mergemat(reihecell{restelemente(j)},reihe,ausschlussmat,1,anzahlwiederholungen,0);
				end 
                if ~isempty(restelemente)
                    if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
                end
				%ausschlusselemente mergen
				%--------------------------------
                
                ausschlussmattmp=shuffle(ausschlussmat);
				for i=1:length(ausschlussmat)
                    if ~isempty(find(zaehlmat==ausschlussmattmp(i)))
                        eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==ausschlussmattmp(i)));']);
                        eval(['reihecell{ausschlussmattmp(i)}=ones(1,abshfgktmat(',indicesstring,'))*ausschlussmattmp(i);']);
                        reihe=mergemat(reihecell{ausschlussmattmp(i)},reihe,ausschlussmat,1,anzahlwiederholungen,0);
                    end
				end 
                
                if isempty(reihe)
                    fprintf('\n');
                    reihe=[];
                    uewktmat = [];
                    return
                end
                
                
                %Wiederholungen und Ausschluss der ersten Reihe optimieren
                %------------------------------------------
                if ~isempty(restelemente)
                    reihe=optimizerepandausschluss(restelemente(1),reihe,ausschlussmat,anzahlwiederholungen,0);
                elseif ~isempty(ausschlussmat)
                    uiwait(errordlg('Alle Elemente sind Ausschlusselemente!','Fehler:'));
                    reihe = -1;
                    uewktmat = -1;
                    return
                else
                   uiwait(errordlg('Da ist was ganz faul!','Fehler:'));
                   reihe = -1;
                   uewktmat = -1;
                   return
               end
               
                             
				%Uebergangswahrscheinlichkeiten
				%-----------------------------------
				anzahlmat=zeros(signallaenge,anzahlelemente);
				for u=1:anzahlelemente
				anzahlmat(:,u)=(u==reihe(:));
				end	
				anzahlvec=sum(anzahlmat);
				equalvec=(anzahlvec(1)==anzahlvec);
				uewktmat=zeros(anzahlelemente);
				for l=1:(signallaenge-1)
                   for m=1:anzahlelemente
                      for n=1:anzahlelemente
                         if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                            uewktmat(m,n)=uewktmat(m,n)+1;
                         end
                      end
                   end
				end
		
            elseif anzahlwiederholungen ~= -1
                
                restelemente=mengenminus(linspace(1,anzahlelemente,anzahlelemente),ausschlussmat);
                restelemente=shuffle(restelemente);
                %eine Reihe vorgeben ungeachtet der Wiederholung
                %---------------------
                eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(1)));']);
                eval(['reihecell{restelemente(1)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(1);']);
                reihe=mergemat(reihecell{restelemente(1)},reihe,ausschlussmat,1,-1,0);
                if isempty(reihe)
                    reihe=[];
                    uewktmat = [];
                    return
                end
                
                
                %unkritische Elemente mergen
				%---------------------------
				for j=2:length(restelemente)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(j)));']);
                    eval(['reihecell{restelemente(j)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(j);']);
                    reihe=mergemat(reihecell{restelemente(j)},reihe,ausschlussmat,1,anzahlwiederholungen,0);
                    if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
				end 
                
				%ausschlusselemente mergen
				%--------------------------------
                
                ausschlussmattmp=shuffle(ausschlussmat);
				for i=1:length(ausschlussmat)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==ausschlussmattmp(i)));']);
                    eval(['reihecell{ausschlussmattmp(i)}=ones(1,abshfgktmat(',indicesstring,'))*ausschlussmattmp(i);']);
                    reihe=mergemat(reihecell{ausschlussmattmp(i)},reihe,ausschlussmat,1,anzahlwiederholungen,0);
                     if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
				end 
                
                %Wiederholungen und Ausschluss der ersten Reihe optimieren
                %------------------------------------------
                reihe=optimizerepandausschluss(restelemente(1),reihe,ausschlussmat,anzahlwiederholungen,0);
               
              
				
                
                %Uebergangswahrscheinlichkeiten
				%-----------------------------------
				anzahlmat=zeros(signallaenge,anzahlelemente);
				for u=1:anzahlelemente
				anzahlmat(:,u)=(u==reihe(:));
				end	
				anzahlvec=sum(anzahlmat);
				equalvec=(anzahlvec(1)==anzahlvec);
				uewktmat=zeros(anzahlelemente);
				for l=1:(signallaenge-1)
                   for m=1:anzahlelemente
                      for n=1:anzahlelemente
                         if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                            uewktmat(m,n)=uewktmat(m,n)+1;
                         end
                      end
                   end
				end
            end
    end
        
 elseif wiederholungsstatus == 0
     
            if faktorausschlussstatus == 1
 
%------------------------------------------------------------------------------------------------------------------        
                if faktorausschlussmodus == 1
                    [faktorausschlussmat,faktorfolgemat]=calcfaktorausschlussmat(anzahlfaktoren,stufenvec,anzahlelemente,zaehlmat);
                    restanzahl=length(faktorfolgemat{1});
					%choicemat erstellen
                    %--------------------
					intervall=(signallaenge*4/restanzahl);
                    idvec=[];
					while sum(idvec)<anzahlelemente
                        
                        %choicemat erstellen (Reihe mit Nummer des Folgeelements (choicematwert ist Spaltenindex der Folgematrix)
                        %-----------------------------------------
                        choicemat=(randperm(signallaenge*4))'; 
                        for w=1:anzahlelemente
                                indices=and(choicemat>intervall*(w-1),choicemat<=intervall+intervall*(w-1));
                                choicemat(indices,1)=w;
                        end
                         
                        %reihe schreiben
                        %-----------------
                        reihe=zeros(1,signallaenge);
                        reihe(1,1)=randint(1,anzahlelemente);
                        reihenzaehler=2;
                        springzaehler=0;
                        k=2;
                        while k<signallaenge*4
                            if length(find(reihe==faktorfolgemat{reihe(1,reihenzaehler-1)}(choicemat(k,1))))>signallaenge/anzahlelemente-1
                                springzaehler = springzaehler+1;
                            else
                                reihe(1,reihenzaehler)=faktorfolgemat{reihe(1,reihenzaehler-1)}(choicemat(k,1));
                                reihenzaehler=reihenzaehler+1;
                                springzaehler=0;
                            end
                            k=k+1;
                            if reihenzaehler>signallaenge
                                break
                            end
                        end
				
                        %anzahl überprüfen
                        %-------------------
                        for n=1:anzahlelemente
                            sumvec(1,n)=sum(reihe==n);
                            idvec=(sumvec(1,1)==sumvec);
                        end
			        end
                     
                    %Uebergangswahrscheinlichkeiten
					%-----------------------------------
					anzahlmat=zeros(signallaenge,anzahlelemente);
					for u=1:anzahlelemente
					anzahlmat(:,u)=(u==reihe(:));
					end	
					anzahlvec=sum(anzahlmat);
					equalvec=(anzahlvec(1)==anzahlvec);
					uewktmat=zeros(anzahlelemente);
					for l=1:(signallaenge-1)
                       for m=1:anzahlelemente
                          for n=1:anzahlelemente
                             if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                                uewktmat(m,n)=uewktmat(m,n)+1;
                             end
                          end
                       end
					end
                    
%------------------------------------------------------------------------------------------------------------------                
                elseif faktorausschlussmodus == 0
                
                    if anzahlfaktoren ==1
                        uiwait(errordlg('faktorausschlussoption benötigt mehrere Faktoren!','Achtung:'));
                        reihe=-1;
                        uewktmat=[];
                        return
                    end
                                    
                    mergestatus = 0;
                    mergestatuszaehler=1;
                    elementemat=[]; 
                    while  mergestatus == 0
                        mergestatus = 1;
                        
                        %ausschluss für jedes Element berechnen
                        %---------------------------------------
                        faktorausschlussmat=calcfaktorausschlussmat(anzahlfaktoren,stufenvec,anzahlelemente,zaehlmat);
                        %elemente nach groessten Distanzen im Sinne von Ausschluss umordnen
                        %----------------------------------------------------------------
                        if mergestatuszaehler == 1
                            
                            elementemat(1)=randint(1,anzahlelemente);
                            for j=2:anzahlelemente
                                
                                restelemente=mengenminus(linspace(1,anzahlelemente,anzahlelemente),elementemat);
                                ausschlusscharakteristika=zeros(length(restelemente),1);
                                %Ausschluss aller vorherigen prüfen
                                %------------------------------------
                                for k=1:length(elementemat)
                                    for s=1:length(restelemente)
                                        if ~isempty(find(restelemente(s)==faktorausschlussmat{elementemat(k)}))
                                            ausschlusscharakteristika(s)=ausschlusscharakteristika(s)+1;
                                        end
                                    end
                                end
                                if length(find(ausschlusscharakteristika==min(ausschlusscharakteristika)))>1
                                    minima= find(ausschlusscharakteristika==min(ausschlusscharakteristika));
                                    next = minima(randint(1,length(minima)));
                                else
                                    next = find(ausschlusscharakteristika==min(ausschlusscharakteristika));
                                end
                                
                                elementemat(j)=restelemente(next);
                            end
                            
                        else
                            elementemat=shuffle(elementemat);
                        end
                            
                        
                        %eine Reihe vorgeben ungeachtet der Wiederholung
                        %---------------------
                        eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==elementemat(1)));']);
                        eval(['reihecell{elementemat(1)}=ones(1,abshfgktmat(',indicesstring,'))*elementemat(1);']);
                        reihe=mergemat(reihecell{elementemat(1)},reihe,[],1,-1,0);
                        
                        %restliche elemente mit jeweiligem Ausschluss mergen
                        %--------------------------
                        j=2;
                        leerzaehler=1;
                        while j<anzahlelemente+1
                            eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==elementemat(j)));']);
                            eval(['reihecell{elementemat(j)}=ones(1,abshfgktmat(',indicesstring,'))*elementemat(j);']);
                            reihemem=reihe;
                            reihe=mergemat(reihecell{elementemat(j)},reihe,faktorausschlussmat{elementemat(j)},0,1,0);
                            if isempty(reihe)
                                %ohne ausschluss
                                %---------------
                                answer = questdlg('Mergemat durch Ausschluss erschwert. Von Ausschluss für dieses Element absehen?','Frage:','ja','nein','ja');
                                if strcmp(answer,'ja')
                                    reihe=mergemat(reihecell{elementemat(j)},reihemem,[],0,1,0);
                                end
                            end
                            
                            
                            if isempty(reihe)
                                mergestatus = 0;
                                mergestatuszaehler = mergestatuszaehler+1;
                                break
                            end
                            j=j+1;
						end 
                             
                        %Wiederholungen und Ausschluss der ersten Reihe optimieren
                        %------------------------------------------
                        if mergestatus ==1 
                            if ~isempty(reihe)
                                reihe=optimizerepandfaktorausschluss(reihe,faktorausschlussmat,0,elementemat(1));
                                if isempty(reihe)
                                    mergestatus = 0;
                                end
                            end
                        end
                        
						%Uebergangswahrscheinlichkeiten
						%-----------------------------------
                        if mergestatus ~=0
                            if ~isempty(reihe)
								anzahlmat=zeros(signallaenge,anzahlelemente);
								for u=1:anzahlelemente
								anzahlmat(:,u)=(u==reihe(:));
								end	
								anzahlvec=sum(anzahlmat);
								equalvec=(anzahlvec(1)==anzahlvec);
								uewktmat=zeros(anzahlelemente);
								for l=1:(signallaenge-1)
                                   for m=1:anzahlelemente
                                      for n=1:anzahlelemente
                                         if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                                            uewktmat(m,n)=uewktmat(m,n)+1;
                                         end
                                      end
                                   end
								end
                            end
                        end
                        if mod(mergestatuszaehler,30)==0
                            if berichtstatus ==1
                                answer = questdlg('Reiheschreiben wiederholt erfolglos! Weitersuchen?','Achtung:','ja','nein','ja');
                                if strcmp(answer,'nein')
                                    reihe=-1;
                                    uewktmat=-1;
                                    return
                                end
                            else
                                reihe=-1;
                                uewktmat=-1;
                                return
                            end
                        end
                    end
                
                end
                
%------------------------------------------------------------------------------------------------------------------                
                
                
                
            elseif faktorausschlussstatus == 0
     
                restelemente=mengenminus(linspace(1,anzahlelemente,anzahlelemente),ausschlussmat);
                restelemente=shuffle(restelemente);
                
                if isempty(restelemente)
                    uiwait(errordlg('Kompletter Ausschluss verhindert Reihenbildung!','Achtung:'));
                    reihe = -1;
                    uewktmat = -1;
                    return
                end
                
                %eine Reihe vorgeben ungeachtet der Wiederholung
                %---------------------
                eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(1)));']);
                eval(['reihecell{restelemente(1)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(1);']);
                reihe=mergemat(reihecell{restelemente(1)},reihe,ausschlussmat,1,-1,0);
                
                %unkritische Elemente mergen
				%---------------------------
				for j=2:length(restelemente)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==restelemente(j)));']);
                    eval(['reihecell{restelemente(j)}=ones(1,abshfgktmat(',indicesstring,'))*restelemente(j);']);
                    reihe=mergemat(reihecell{restelemente(j)},reihe,ausschlussmat,1,1,0);
                    if isempty(reihe)
                        reihe=[];
                        uewktmat = [];
                        return
                    end
				end 
                
				%ausschlusselemente mergen
				%--------------------------------
                ausschlussmattmp=shuffle(ausschlussmat);
				for i=1:length(ausschlussmat)
                    eval(['[',indicesstring,']=ind2sub(size(zaehlmat),find(zaehlmat==ausschlussmattmp(i)));']);
                    eval(['reihecell{ausschlussmattmp(i)}=ones(1,abshfgktmat(',indicesstring,'))*ausschlussmattmp(i);']);
                    reihe=mergemat(reihecell{ausschlussmattmp(i)},reihe,ausschlussmat,1,1,0);
                    if isempty(reihe)
                        uewktmat = [];
                        return
                    end
				end 
                
                %Wiederholungen und Ausschluss der ersten Reihe optimieren
                %------------------------------------------
                reihe=optimizerepandausschluss(restelemente(1),reihe,ausschlussmat,1,0);
                if isempty(reihe)
                    uewktmat=[];
                    return
                elseif length(reihe)==1 & reihe == -1
                    reihe = -1;
                    uewktmat = -1;
                    return
                end
                
				%Uebergangswahrscheinlichkeiten
				%-----------------------------------
				anzahlmat=zeros(signallaenge,anzahlelemente);
				for u=1:anzahlelemente
				    anzahlmat(:,u)=(u==reihe(:));
				end	
				anzahlvec=sum(anzahlmat);
				equalvec=(anzahlvec(1)==anzahlvec);
				uewktmat=zeros(anzahlelemente);
				for l=1:(signallaenge-1)
                   for m=1:anzahlelemente
                      for n=1:anzahlelemente
                         if and(anzahlmat(l,m)==1,anzahlmat(l,m)==anzahlmat(l+1,n))
                            uewktmat(m,n)=uewktmat(m,n)+1;
                         end
                      end
                   end
				end
            end
end
        
% %-----------------------------------------------------------
% %Fehlermeldung
% %-----------------------------------------------------------
% else 
%     errorcell=cell(1);
%     errorcell{1}='Für die Option: ';
%     errorcell{2}='';
%     errorcell{3}=['  Faktoren: ',num2str(anzahlfaktoren)];
%     errorcell{4}=['  gleichverteilte Wkt = ',wktstatus];
%     if whlstatus == 0
%         errorcell{5}=['  Wiederholungen zulassen: n'];
%     else 
%         errorcell{5}=['  Wiederholungen zulassen: ',num2str(whlstatus)];
%     end
%     if isempty(ausschlussmat)
%         errorcell{6}='  Ausschluss: n';
%     else
%         errorcell{6}=['  Ausschluss: ',whlspez,' :',num2str(ausschlussmat)];
%     end
%     errorcell{7}=['  Übgwkten: ',uewktoptstatus];
%     errorcell{8}='';
%     errorcell{9}='existiert noch kein Skript!';
%     errordlg(errorcell,'Sorry!');
%     return
% end



return