}  /* Jetzt noch in die Form eintragen */  for (ClusterNr = 0; ClusterNr < Cluster.Lese_Groesse (); ClusterNr++) {    for (Dim = 0; Dim < Daten.Lese_Dim (); Dim++) {      Laengen[ClusterNr][Dim] = sqrt (Achsen[ClusterNr][Dim] * Faktor[ClusterNr]);    }  }};void GK_Clustering::Berechne_Form (DVektorArray & Daten,			      DVektorArray & Cluster){  DVektor VBuffer (Daten.Lese_Dim (), 0, NULL);  int ClusterNr, DatenNr;  Covar.Setze_Dim (Daten.Lese_Dim (), Daten.Lese_Dim ());  Covar.Setze_Groesse (Cluster.Lese_Groesse ());/************ jetzt geht es aber wirklich los *************/  for (ClusterNr = 0; ClusterNr < Cluster.Lese_Groesse (); ClusterNr++) {    /* Das werden die Kovarianzmatrizen fuer den Cluster */    Covar[ClusterNr].NullMatrix ();    for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++) {      if (Zuordnung[DatenNr] == ClusterNr) {	VBuffer = Daten[DatenNr] - Cluster[ClusterNr];	Covar[ClusterNr] += VBuffer.Produkt (VBuffer);      }    }  }};void GK_Clustering::Speichere_Buffer (){  ClusterBuffer = Cluster;  UBuffer = Zugehoerigkeit;  ABuffer = AMatrizen;  rho_Buffer = rho;};void GK_Clustering::Uebernehme_Buffer (){  Zugehoerigkeit = UBuffer;  Cluster = ClusterBuffer;  AMatrizen = ABuffer;  rho = rho_Buffer;};void GK_Clustering::Tausche_Buffer (){  Zugehoerigkeit.Tausche (UBuffer);  Cluster.Tausche (ClusterBuffer);  AMatrizen.Tausche (ABuffer);  rho.Tausche (rho_Buffer);};void GK_Clustering::Loesche_Buffer (){  ClusterBuffer. ~ DVektorArray ();  UBuffer. ~ DMatrix ();  ABuffer. ~ DMatrixArray ();  rho_Buffer. ~ DVektor ();};/**********************************************************//**********************************************************/GK_parallel_Clustering::GK_parallel_Clustering (Guete_Typ Guete, int Soll_Iterationen,			char Possib){  Possibilistisch = Possib;  sprintf (Name, "%s", "GK_parallel");};Cluster_Typ GK_parallel_Clustering::Lese_Typ (){  return (GK_parallel);};void GK_parallel_Clustering::Berechne_Ai (DVektorArray & Daten, DMatrix & U,				     DVektorArray & Cluster){  int i, k, v;  double Summe1, Summe2;  for (i = 0; i < Cluster.Lese_Groesse (); i++) {	/* fuer alle Cluster */    /* Zunaechst die Summen berechnen */    Summe2 = 1.0;    for (v = 0; v < Daten.Lese_Dim (); v++) {      Summe1 = 0.0;      for (k = 0; k < Daten.Lese_Groesse (); k++) {	Summe1 += pow (U.Lese_i_j (i, k), M) *	  (Daten[k][v] - Cluster[i][v]) *	  (Daten[k][v] - Cluster[i][v]);      }      if (Summe1 == 0) {	Fehlermeldung ("GK_parallel_Clustering::Berechne_Ai(...)", INVERTIERFEHLER);	i = Cluster.Lese_Groesse ();	break;      }      AMatrizen[i].Setze_i_j (v, v, 1.0 / (double) Summe1);      Summe2 *= Summe1;    }				/* for(v=0 ; v < Daten.Lese_Dim() ; v++) */    if (Lese_Fehlerstatus () == KEINFEHLER) {      for (v = 0; v < Daten.Lese_Dim (); v++)	AMatrizen[i].Setze_i_j (v, v,		   pow (rho[i] * Summe2, 1.0 / ((double) Daten.Lese_Dim ())) *				AMatrizen[i].Lese_i_j (v, v));    }  }				/* for(i=0 ; i < U.Lese_Dim_m() ; i++) */};void GK_parallel_Clustering::Berechne_Form (DVektorArray & Daten,				       DVektorArray & Cluster){  parallel_Form_Berechnen (Daten, Cluster);};/**********************************************************//**********************************************************/GG_Clustering::GG_Clustering (Guete_Typ Guete, int Soll_Iterationen,	       char Possib){  sprintf (Name, "%s", "GG");};Cluster_Typ GG_Clustering::Lese_Typ (){  return (GG);};void GG_Clustering::Mein_Speichern (FILE * File){  rho.Speichern (File);  AMatrizen.Speichern (File);  Faktor.Speichern (File);  p.Speichern (File);  if (Art == OPTIMAL) {    ABuffer.Speichern (File);    Faktor_Buffer.Speichern (File);    p_Buffer.Speichern (File);  }};int GG_Clustering::Mein_Laden (FILE * File){  if ((!rho.Laden (File)) ||      (!AMatrizen.Laden (File)) ||      (!Faktor.Laden (File)) ||      (!p.Laden (File)))    return (0);  if (Art == OPTIMAL) {    if ((!ABuffer.Laden (File)) ||	(!Faktor_Buffer.Laden (File)) ||	(!p_Buffer.Laden (File)))      return (0);  }  return (1);};DVektorArray GG_Clustering::Mein_Clustern (DVektorArray & Daten,			      DVektorArray & Vorgabe_Protos)return Result (Daten.Lese_Dim (), Vorgabe_Protos.Lese_Groesse (), NULL);{  int i, l;  DMatrix U[2];  if (Zugehoerigkeit.Lese_Dim_m () != Vorgabe_Protos.Lese_Groesse ()) {    p.Setze_Dim (Vorgabe_Protos.Lese_Groesse ());    p = 1.0 / (double) p.Lese_Dim ();    Faktor.Setze_Dim (Cluster.Lese_Groesse ());    Faktor = 1.0 / p[0];    AMatrizen.Setze_Dim (Daten.Lese_Dim (), Daten.Lese_Dim ());    AMatrizen.Setze_Groesse (Vorgabe_Protos.Lese_Groesse ());    for (i = 0; i < Vorgabe_Protos.Lese_Groesse (); i++)      AMatrizen[i].Einheitsmatrix ();    U[0].Setze_Dim (Vorgabe_Protos.Lese_Groesse (),		    Daten.Lese_Groesse ());    Berechne_U (Daten, Vorgabe_Protos, U[0]);  } else    U[0] = Zugehoerigkeit;  U[1].Setze_Dim (Vorgabe_Protos.Lese_Groesse (),		  Daten.Lese_Groesse ());/********************/  /* Schleifen-Anfang *//********************/  l = 0;  while ((ClusterFertig != TRUE) && (Iterationen < Max_Iterationen)) {    Iterationen++;/***********************/    /* I. v_i's berechnen *//***********************/    Result = Berechne_v (U[l], Daten);/***************************/    /* II. A[] etc. bestimmen *//***************************/    Berechne_Ai (Daten, U[l], Result);    if (Lese_Fehlerstatus () != KEINFEHLER) {      ClusterFertig = TRUE;      Reset_Fehlerstatus ();      Result. ~ DVektorArray ();      return (Result);    }/********************/    /* III. p bestimmen *//********************/    Berechne_p (U[l]);/***********************/    /* IV. U_neu bestimmen *//***********************/    Berechne_Faktor ();    l = (l + 1) % 2;    Berechne_U (Daten, Result, U[l]);    if (Lese_Fehlerstatus () != KEINFEHLER) {      ClusterFertig = TRUE;      Reset_Fehlerstatus ();      Result. ~ DVektorArray ();      return (Result);    }/*************************/    /*  V. ||U[l-1]-U[l]||   *//*************************/    if (Die_Norm.d (U[0], U[1]) <= Delta_U)      ClusterFertig = TRUE;  };  Zugehoerigkeit = U[l];};void GG_Clustering::Berechne_Ai (DVektorArray & Daten, DMatrix & U,			    DVektorArray & Cluster){  int i;  Berechne_Covarianz (Daten, U, AMatrizen, Cluster);  for (i = 0; i < Cluster.Lese_Groesse (); i++) {    AMatrizen[i] = AMatrizen[i].Gauss_Inverse ();    if (Lese_Fehlerstatus () != KEINFEHLER)      break;  };};void GG_Clustering::Berechne_Faktor (){  int i;  for (i = 0; i < AMatrizen.Lese_Groesse (); i++)    Faktor[i] = p[i] / sqrt (AMatrizen[i].Determinante ());};int GG_Clustering::Berechne_Dist (DVektor & Dist, DVektor & Datum,			      DVektorArray & Cluster){  int Result = 0, i;  double Summe;  for (i = 0; i < Cluster.Lese_Groesse (); i++) {    Summe = Die_A_Norm.d_quadr (AMatrizen[i], Datum, Cluster[i]);    if (Summe < 1300) {      Dist[i] = exp (.5 * Summe) * Faktor[i];      if (Dist[i] == 0)	Result++;    } else      Dist[i] = MAXDOUBLE;  }  return (Result);};void GG_Clustering::Berechne_possib_U (DVektorArray & Daten,				  DVektorArray & Cluster, DMatrix & U){  int i, j;  double Buffer;  for (i = 0; i < Cluster.Lese_Groesse (); i++) {	/* alle Cluster */    for (j = 0; j < Daten.Lese_Groesse (); j++) {      Buffer = Die_A_Norm.d_quadr (AMatrizen[i], Daten[j], Cluster[i]);      if (Buffer < 1400) {	Buffer = exp (.5 * Buffer) * Faktor[i];	U[i][j] = 1.0 / (1.0 + pow (Buffer / eta[i],					1.0 / (M - 1.0)));      } else	U[i][j] = 0;    }  }};void GG_Clustering::Mache_Possibilistisch (DVektorArray & Daten,				      DVektorArray & Cluster){  int l;  DMatrix U[2];  char Test = FALSE;  U[0] = Zugehoerigkeit;  U[1].DMatrix (U[0].Lese_Dim_m (), U[0].Lese_Dim_n (), NULL);  l = 0;  Berechne_p (U[l]);  if (eta.Lese_Dim () == 0) {	/* Am Anfang */    p.Setze_Dim (Cluster.Lese_Groesse ());    Berechne_Ai (Daten, U[l], Cluster);    Berechne_Faktor ();    eta = Berechne_eta (Daten, Cluster, U[l]);  }  if (Possib_Zaehler <= 2) {    while ((Test == FALSE) && (Iterationen < Max_Iterationen)) {      Iterationen++;      /*    v_i's berechnen    */      Cluster = Berechne_v (U[l], Daten);      l = (l + 1) % 2;/*************************/      /*    U_neu berechnen    *//*************************/      Berechne_possib_U (Daten, Cluster, U[l]);      if (Die_Norm.d (U[0], U[1]) < Delta_U) {	Test = TRUE;	Possib_Zaehler++;	if (Possib_Zaehler <= 2) {	  Berechne_p (U[l]);	  Berechne_Ai (Daten, U[l], Cluster);	  Berechne_Faktor ();	  eta = Berechne_eta (Daten, Cluster, U[l]);	} else {	  Fertig = TRUE;	}      }    };  }				/* if(Possib_Zaehler <= 2) */  Zugehoerigkeit = U[l];};DVektor GG_Clustering::Berechne_eta (DVektorArray & Daten,			     DVektorArray & Cluster, DMatrix & U)return Result (Cluster.Lese_Groesse (), 0, NULL);{  int i, k;  double Potenz, Ni, Buffer, Test;  for (i = 0; i < Cluster.Lese_Groesse (); i++) {    Buffer = 0;    Ni = 0;    for (k = 0; k < Daten.Lese_Groesse (); k++) {      Test = Die_A_Norm.d_quadr (AMatrizen[i], Daten[k], Cluster[i]);      if (Test < 1400) {	Test = exp (.5 * Test) * Faktor[i];      } else	Test = MAXDOUBLE;      Potenz = pow (U[i][k], M);      Buffer += Potenz * Test;      Ni += Potenz;    }    Result[i] = (K / Ni) * Buffer;  }}void GG_Clustering::Berechne_p (DMatrix & U){  double Teiler = 0.0, Buffer;  int i, k;  for (i = 0; i < U.Lese_Dim_m (); i++) {    p[i] = 0;    for (k = 0; k < U.Lese_Dim_n (); k++) {      Buffer = pow (U[i][k], M);      p[i] += Buffer;      Teiler += Buffer;    }  }  for (i = 0; i < U.Lese_Dim_m (); i++)    p[i] /= Teiler;};/**********************************************************/GG_parallel_Clustering::GG_parallel_Clustering (Guete_Typ Guete, int Soll_Iterationen,			char Possib){  sprintf (Name, "%s", "GG_parallel");};Cluster_Typ GG_parallel_Clustering::Lese_Typ (){  return (GG_parallel);};void GG_parallel_Clustering::Berechne_Ai (DVektorArray & Daten, DMatrix & U,				     DVektorArray & Cluster){/******* Maximum-Likelihood-Schaetzer *********/  int i, k, v;  double Summe;  for (i = 0; i < Cluster.Lese_Groesse (); i++) {	/* fuer alle Cluster */    /* Zunaechst die Summen berechnen */    for (v = 0; v < Daten.Lese_Dim (); v++) {      Summe = 0;      for (k = 0; k < Daten.Lese_Groesse (); k++) {	Summe += pow (U[i][k], M) *	  (Daten[k][v] - Cluster[i][v]) *	  (Daten[k][v] - Cluster[i][v]);      }      AMatrizen[i][v][v] = Summe;    }				/* for(v=0 ; v < Daten.Lese_Dim() ; v++) */    Summe = 0;    for (k = 0; k < Daten.Lese_Groesse (); k++) {      Summe += pow (U[i][k], M);    }    for (v = 0; v < Daten.Lese_Dim (); v++) {      if (AMatrizen[i][v][v] == 0) {	Fehlermeldung ("GG_parallel_Clustering::Berechne_Ai(...)", INVERTIERFEHLER);	i = Cluster.Lese_Groesse ();	break;      } else {			/* Zuviele Cluster gesucht */	AMatrizen[i][v][v] = Summe / AMatrizen[i][v][v];      }    }  }				/* for(i=0 ; i < U.Lese_Dim_m() ; i++) */}void GG_parallel_Clustering::Berechne_Faktor (){  int i, j;  for (i = 0; i < AMatrizen.Lese_Groesse (); i++) {    Faktor[i] = 1;    for (j = 0; j < AMatrizen.Lese_Dim_m (); j++) {      Faktor[i] = Faktor[i] * AMatrizen[i][j][j];    }    Faktor[i] = 1.0 / (p[i] * Faktor[i]);  }};void GG_parallel_Clustering::Berechne_Form (DVektorArray & Daten,				       DVektorArray & Cluster){  parallel_Form_Berechnen (Daten, Cluster);};void GG_Clustering::Speichere_Buffer (){  ClusterBuffer = Cluster;  UBuffer = Zugehoerigkeit;  ABuffer = AMatrizen;  p_Buffer = p;  Faktor_Buffer = Faktor;};void GG_Clustering::Uebernehme_Buffer (){  Zugehoerigkeit = UBuffer;  Cluster = ClusterBuffer;  AMatrizen = ABuffer;  p = p_Buffer;  Faktor = Faktor_Buffer;};void GG_Clustering::Tausche_Buffer (){  Zugehoerigkeit.Tausche (UBuffer);  Cluster.Tausche (ClusterBuffer);  AMatrizen.Tausche (ABuffer);  p.Tausche (p_Buffer);  Faktor.Tausche (Faktor_Buffer);};void GG_Clustering::Loesche_Buffer (){  ClusterBuffer. ~ DVektorArray ();  UBuffer. ~ DMatrix ();  ABuffer. ~ DMatrixArray ();  p_Buffer. ~ DVektor ();  Faktor_Buffer. ~ DVektor ();};