import java.io.*;

class neuron {  
 double fak[]=null;                                     //neue Wichtungen
 double fakO[]=null;                                    //alte Wichtungen
 double kickO=1;                                        //alter Fehler
 int inz=0;                                             //Anzahl der Eingänge
 int anf=0;
 int pos=0;
 int lrn=100;
 neuron alt=null;                                       //Liste der Vorgängerneuronen
  
 public neuron(neuron at,int nanf,int anz,int ps) { 
  /* Initialisierung  */ 
  alt=at;                                               //Zeiger auf Vorgänger in der Neuronenliste
  pos=ps;
  anf=nanf;
  inz=anz;    
  fak=new double[inz];                                  //aktuelle Wichtungen   
  fakO=new double[inz];                                 //alte Wichtungen 
  for(int i=0;i<inz;i++) fak[i]=1;
  for(int i=0;i<inz;i++) fakO[i]=1;
 };
   
 public void lernen(double kickN) { 
  /* Stochastisches Lernen, kickN: Abweichung erzeugter Ausgänge von Vorgaben (Fehler) */
  if(kickN<kickO) {                                     //wenn Fehler kleiner  als alter Fehler ist, dann
   for(int i=0;i<inz;i++) fakO[i]=fak[i];               //Kopieren der Wichtungen als alte Wichtungen
   kickO=kickN;                                         //Kopieren Fehler als alter Fehler
  };
  for(int i=0;i<inz;i++) fak[i]=fakO[i]+lrn*(Math.random()-0.5)*kickN;   //Variation der Wichtungen über Zufallswerte*Fehler 
 }; 
   
 public void wert(double ein[][],int m) {
  double s=0;
  for(int i=0;i<inz;i++) s=s+ein[anf+i][m]*fak[i];      //gewichtete Summe der Eingangswerte
  s=Math.max(s,-1000);                                  //Berechnung des Ausgangs
  ein[pos][m]=1/(Math.exp(-s)+1);        
 };   
}
 
class cio {
 public static String stin(String fr) {
  /* Texteingabe per Tastatur, fr Frage */ 
  DataInputStream inp=new DataInputStream(System.in);
  String aw="";
  try {
   System.out.print(fr+": ");    
   aw=inp.readLine();
  }
  catch(IOException e){aw="";};  
  return aw;
 }
 
 public static int inin(String fr) {
  /* Zahleneingabe */
  return new Integer(stin(fr)).intValue();
 }  
 
 public static double dbin(String fr) {
  /* Zahleneingabe */
  return new Double(stin(fr)).doubleValue();
 }                      
} 
 
public class neusto {
 static double ein[][]=null;                            //Array der Eingangsvorgaben
 static neuron all[]=null;                              //Array der Neuronen
 static double aus[][]=null;                            //Array der Ausgangsvorgaben
 static int gez=0;                                      //Neuronenzahl   
  
 public static void main(String z[]) {
  /* Hauptroutine */   
  neuron anf=null,zw=null;
  int eez=0,enz=0,mez=0,nez=0,ale=0,fez=0,lsz=0;        //Anzahl: eez Ebenen, enz Eingänge, mez Muster, nez Neuronen/Ebene, Vorgängerebene: ale Anfang, fez Neuronenzahl
  int i=0,j=0,m=0;
  double kickN=1;   
  
  /*Organisieren des Netzes */ 
  eez=cio.inin("Ebenenzahl");
  enz=cio.inin("Zahl der Eingänge");
  mez=cio.inin("Zahl der Muster");
  fez=enz;gez=enz;    
  for(i=0;i<eez;i++) {    
   if(i==0) nez=enz;
   else {   
    if(i==eez-1) nez=cio.inin("Ausgangsebene-Neuronenzahl");
    else nez=cio.inin(i+". Ebene-Neuronenzahl");            
   } 
   for(j=0;j<nez;j++) {     
    anf=new neuron(anf,ale,fez,gez);                    //Anlegen der Neuronen pro Ebene, anf: Listenanfang aller Neuronen
    gez++;
   };
   ale=ale+fez;fez=nez;                                         
  };
  gez=gez-enz; 
  ein=new double[gez+enz][mez];
  aus=new double[nez][mez];
  all=new neuron[gez];
  fez=gez-1;
  for(zw=anf;zw!=null;zw=zw.alt){                       //Anlegen der Neuronenliste als Array       {
   all[fez]=zw;fez--;
  };
  fez=gez-nez;                                          //fez auf Anfang der Ausgangsebene 
  for (m=0;m<mez;m++) {
   System.out.println("Muster "+m+":");
   for(i=0;i<enz;i++) ein[i][m]=cio.dbin("Eingang "+i);           
   for(i=0;i<nez;i++) aus[i][m]=cio.dbin("Ausgang "+i);                       
  };                                      

  /* wiederholte Lernschritte, Ende nach 10000 Lernschritte oder Abweichung <= 0,02 */
  for(lsz=0;(lsz<10000)&&(kickN>0.02);lsz++) {          //lsz Zähler der Lernschritte
   kickN=0; 
   System.out.println("");
   for (m=0;m<mez;m++) {         
    System.out.print("#"+m+" | ");
    for(i=0;i<gez;i++) all[i].wert(ein,m);              //Berechnung der Ausgänge   
    for(i=0;i<nez;i++) {                                //Ermittlung der Abweichung der errechneten von den vorgegebenen Ausgängen
     kickN=kickN+Math.abs(aus[i][m]-ein[fez+i][m]);                                                              
     System.out.print(aus[i][m]+" : "+          ein[fez+i][m]+"     ");  //Ausgabe der Ausgangswerte
    };
    System.out.println("");
   }; 
   for(i=0;i<gez;i++) all[i].lernen(kickN);             //Lernschritt
  };
  System.out.println("Versuche: "+lsz+" Fehler: "+kickN);    
  
  /* Reaktion auf neue Muster testen */                                     
  while (cio.stin("neuer Versuch (j/n)").equals("j")) {   
   for(i=0;i<enz;i++) ein[i][0]=cio.dbin("Eingang "+i); 
   for(i=0;i<gez;i++) all[i].wert(ein,0);
   for(i=0;i<nez;i++) System.out.print(ein[fez+i][0]+"     ");
   System.out.println("");    
  };       
 }  
}