cluster.cc

模糊聚类的算法实现程序

  }

  /* 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 ();
};