/*-------------------------------------------------------------

Copyright (C) 2000 Alessandro Macri. 
All Rights Reserved.

Permission to use, copy, modify, and distribute this
software and its documentation for NON-COMMERCIAL purposes
and without fee is hereby granted provided that this
copyright notice appears in all copies.


THE AUTHOR AND PUBLISHER MAKE NO REPRESENTATIONS OR
WARRANTIES ABOUT THE SUITABILITY OF THE SOFTWARE, EITHER
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE, OR NON-INFRINGEMENT. THE AUTHORS
AND PUBLISHER SHALL NOT BE LIABLE FOR ANY DAMAGES SUFFERED
BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
THIS SOFTWARE OR ITS DERIVATIVES.

-------------------------------------------------------------*/


class Gen {
    // Anzahl der Desoxyribonukleinsäuren:
    // Vorerst als static final deklariert, da andere Zahlen (noch) keinen Sinn
    // ergeben.
    static final int anzDNS = 4;

    // Anzahl der zu codierenden Aminosäuren:
    // Um diese flexibel zu halten, ist anzAmino nicht als final deklariert.
    // So können auch Betrachtungen zu unterschiedlichen Mengen von Aminosäuren
    // durchgeführt werden
    int anzAmino;

    // Verweis auf Ähnlichkeitsmatrix
    private final Aminos amino;

    // Transkriptionstabelle:
    // Bildet die Menge der DNS-Tripel auf die Menge der Aminosäuren ab.
    int[][][] eintrag = new int [anzDNS][anzDNS][anzDNS];


    // Konstruktor:
    // Erzeugt ein Gen aus den notwendigen Daten.
    Gen (int[][][] tabelle, int anzAmino, Aminos amino) {

	// Übersetzungstabelle speichern.
	this.eintrag=tabelle;

	// Anzahl der zu codierenden Aminosäuren speichern.
	this.anzAmino=anzAmino;

	// Verweis auf Aminosäurentabelle setzen
	this.amino=amino;
    }

    // Konstruktor:
    // Erzeugt zufällig ein "lebensfähiges" Gen, d.h. eine 4x4x4 Matrix, die
    // als Übersetzungstabelle fuer <anzAmino> verschiedene Aminosäuren dient.
    Gen (Aminos amino) {
	int a,b,c;

	// Verweis auf Aminosäurentabelle setzen
	this.amino=amino;

	// Anzahl der zu codierenden Aminosäuren speichern.
	this.anzAmino=amino.getSize();

	// Die Matrix wird mit einer Zufallsbelegung versehen.
	while(true) {
	    for(a=0;a<anzDNS; a++) {
		for(b=0;b<anzDNS; b++) {
		    for(c=0;c<anzDNS; c++) {
			this.eintrag[a][b][c]=(int) ((anzAmino-1)*Math.random()+1);
		    }
		}
	    }
	    eintrag[0][2][2]=0;
	    eintrag[0][3][2]=0;
	    eintrag[0][2][3]=0;
	    if(!this.letal())
		break;
	}
    }
    
    // Lebensfähigkeit definieren:
    // Ein Gen ist lebensfähig, wenn es jede Aminosäure codieren kann.
    public boolean letal () {
	int a,b,c;
	boolean [] aminoMarker = new boolean [this.anzAmino];
	for(a=this.anzAmino-1; a>=0; --a) aminoMarker[a]=false;
	int anzahl=this.anzAmino;
	for(a=0;a<anzDNS; a++) {
	    for(b=0;b<anzDNS; b++) {
		for(c=0;c<anzDNS; c++) {
		    if(aminoMarker[this.eintrag[a][b][c]]==false) --anzahl;
		    aminoMarker[this.eintrag[a][b][c]]=true;
		}
	    }
	}
	return(anzahl!=0);
    }

    // Bewertungsfunktion:
    // Gibt ein numerisches Maß für die Qualität einer Übersetzung. Hier wird
    // als Maß die Fehlertoleranz der Übersetzung bzgl. der Ähnlichkeit der
    // codierten Aminosäure im Falle einer Erbgutveränderung verwendet.
    public double qualität () {
	int a1,a2,a3,i;
	double q=0.0,stop=0.0;
	for(a1=0;a1<anzDNS; a1++)
	    for(a2=0;a2<anzDNS; a2++)
		for(a3=0;a3<anzDNS; a3++)
		    if(eintrag[a1][a2][a3]!=0) {

		// Berechne die Summe von MS1, MS2 und MS3, d.h. die Summe der
		// Abweichungen bei allen Veränderungen an der ersten, zweiten,
		// oder dritten Stelle des DNS-Tripels, bzgl. der Ähnlichkeitsmatrix
		for(i=0; i<anzDNS; i++) {
			if(eintrag[i][a2][a3]!=0)
	    			q+=(amino.getDiff(eintrag[i][a2][a3],eintrag[a1][a2][a3]));
			else
	    			stop++;

		        if(eintrag[a1][i][a3]!=0)
			    	q+=(amino.getDiff(eintrag[a1][i][a3],eintrag[a1][a2][a3]));
			else
			    	stop++;
		
		        if(eintrag[a1][a2][i]!=0)
				q+=(amino.getDiff(eintrag[a1][a2][i],eintrag[a1][a2][a3]));
			else
			    	stop++;
			}
		}
	return q/(64*3*3-stop);
    }
    

    // Fortpflanzung:
    // Das Genmaterial wird in Form eines Blocks der zugrundeliegenden Tabelle
    // zwischen den Eltern ausgetauscht. dabei muß das Kind besser sein, als die
    // Eltern.
    public Gen crossover (Gen partner, double mutRate) {
	int a,b,c;
	int[][][] tabelle=new int[anzDNS][anzDNS][anzDNS];
	double q1=this.qualität();
	double q2=partner.qualität();
	double qmax;
	if(q1<q2) qmax=q1; else qmax=q2;

	// Ergebnis der Kreuzung
	Gen kind=null;

	// Blockgröße-1 in jeder Dimension
	int g1,g2,g3,anz2=anzDNS-1;

	// Position des Blocks
	int p1,p2,p3;

	// Offset für die Kopie
	int o1,o2,o3;

	for(int i=0;i<10;i++) {
	    // Größe, Position und Offset des auszutauschenden Blocks bestimmen
	    g1=(int) (1+anz2*Math.random());
	    g2=(int) (1+anz2*Math.random());
	    g3=(int) (1+anz2*Math.random());
	    p1=(int) ((anzDNS-g1)*Math.random());
	    p2=(int) ((anzDNS-g2)*Math.random());
	    p3=(int) ((anzDNS-g3)*Math.random());
	    o1=(int) ((anzDNS-g1-p1)*Math.random());
	    o2=(int) ((anzDNS-g2-p2)*Math.random());
	    o3=(int) ((anzDNS-g3-p3)*Math.random());

	    // Tabelle kopieren
	    for(a=0;a<anzDNS; a++)
		for(b=0;b<anzDNS; b++)
		    for(c=0;c<anzDNS; c++)
			tabelle[a][b][c]=eintrag[a][b][c];

	    // Block tauschen
	    for(a=p1;a<=g1+p1; a++)
		for(b=p2;b<=g2+p2; b++)
		    for(c=p3;c<=g3+p3; c++)
			tabelle[o1+a][o2+b][o3+c]=partner.eintrag[a][b][c];

	    // Mutieren
	    for(a=0;a<anzDNS; a++)
		for(b=0;b<anzDNS; b++)
		    for(c=0;c<anzDNS; c++)
			if(Math.random()<=mutRate)
			    tabelle[a][b][c]=(int) ((anzAmino-1)*Math.random()+1);

	    // Überzählige STOPs wieder entfernen...
	    for(a=0;a<anzDNS; a++)
		for(b=0;b<anzDNS; b++)
		    for(c=0;c<anzDNS; c++)
			if(tabelle[a][b][c]==0)
			    tabelle[a][b][c]=eintrag[a][b][c];

	    // ... und obligatorische STOPs einfügen
	    eintrag[0][2][2]=0;
	    eintrag[0][3][2]=0;
	    eintrag[0][2][3]=0;

	    kind=new Gen(tabelle,anzAmino,amino);
	    if(!kind.letal()) {
		if(kind.qualität()<qmax)
			    break;
	    }			
	}

	if(kind.letal() || kind.qualität()>qmax)
	    kind=this;
	return kind;
    }

    public String toString() {
	int a,b,c,i;
	String aus="\t";
	for(i=0; i<anzDNS; i++)
	    aus=aus+"   "+amino.getDNS(i)+"\t";
	aus=aus+"\n";
	aus=addLine(aus);

	for(a=0; a<anzDNS; a++) {
	    for(c=0; c<anzDNS; c++) {
		aus=aus+amino.getDNS(a)+" |\t";
		for(b=0; b<anzDNS; b++)
		    aus=aus+amino.getName(eintrag[a][b][c])+"\t";
		aus=aus+"| "+amino.getDNS(c)+"\n";
		
	    }
	    aus=addLine(aus);
	}	
	return aus;
    }
    
    private String addLine(String aus) {
	String str="";
	for(int i=0; i<=anzDNS; i++)
	    str=str+"-------";
	str=str+"\n";
	return aus.concat(str);
    }
    
    private double msDiff (int a1, int a2, int a3) {
	double erg=0,zwischen;
	int i;

	// Berechne die Summe von MS1, MS2 und MS3, d.h. die Summe der
	// Abweichungen bei allen Veränderungen an der ersten, zweiten,
	// oder dritten Stelle des DNS-Tripels, bzgl. der Ähnlichkeitsmatrix
	for(i=0; i<anzDNS; i++)
	    erg+=(amino.getDiff(eintrag[i][a2][a3],eintrag[a1][a2][a3]));
	for(i=0; i<anzDNS; i++)
	    erg+=(amino.getDiff(eintrag[a1][i][a3],eintrag[a1][a2][a3]));
	for(i=0; i<anzDNS; i++)
	    erg+=(amino.getDiff(eintrag[a1][a2][i],eintrag[a1][a2][a3]));
	return erg;
    }
    

}