guete.cc

UNIX下使用的基于模糊Ｃ聚类分析的原码

/********************************************************/
/*   filename: guete.cc                                 */
/*                                                      */
/********************************************************/
/* programmed by: Oliver Wagner                         */
/* last change:  (XXX: not updated)                     */
/********************************************************/

#include "guete.h"

/*************************/
/* Alles zu Klasse Guete */
/*************************/
Guete::Guete ()
{
  Anzahlen = NULL;
  Werte = NULL;
  getestete = 0;
  Bestes_bisher = 0;
}

Guete::~Guete ()
{
  Reset ();
}

void 
Guete::Reset ()
{
  if (getestete != 0) {
    free (Anzahlen);
    free (Werte);
    Anzahlen = NULL;
    Werte = NULL;
  }
  getestete = 0;
  Bestes_bisher = 0;
}

void 
Guete::Setze (int Anzahl, double Wert)
{
  int i;
  char drinnen = FALSE;

  for (i = 0; i < getestete; i++) {
    if (Anzahlen[i] == Anzahl) {
      drinnen = TRUE;
      Werte[i] = Wert;
      Min_Wert = MAXDOUBLE;
      Max_Wert = -MAXDOUBLE;
      for (i = 0; i < getestete; i++) {
	if (Werte[i] < Min_Wert)
	  Min_Wert = Werte[i];
	if (Werte[i] > Max_Wert)
	  Max_Wert = Werte[i];
      }
      break;
    }
  }

  /* wenn fuer neue Clusteranzahl ,dann Speicher vergroessern */
  if (drinnen == FALSE) {
    double *dBuffer;
    int *iBuffer, j, dahin = getestete;

    if (getestete == 0) {
      Min_Wert = MAXDOUBLE;
      Max_Wert = -MAXDOUBLE;
    }
    if (! (dBuffer = (double *) malloc (sizeof (double) * (getestete + 1))))
        Fehlermeldung ("Guete::Setze()", SPEICHERFEHLER);
    if (! (iBuffer = (int *) malloc (sizeof (int) * (getestete + 1))))
        Fehlermeldung ("Guete::Setze()", SPEICHERFEHLER);


    for (i = 0, j = 0; j < getestete; i++) {
      if ((Anzahl < Anzahlen[j]) && (drinnen == FALSE)) {
	drinnen = TRUE;
	dahin = i;
      } else {
	iBuffer[i] = Anzahlen[j];
	dBuffer[i] = Werte[j];
	j += 1;
      }
    }
    iBuffer[dahin] = Anzahl;
    dBuffer[dahin] = Wert;

    free (Anzahlen);
    free (Werte);
    Anzahlen = iBuffer;
    Werte = dBuffer;
    getestete++;

    if (Wert < Min_Wert)
      Min_Wert = Wert;
    if (Wert > Max_Wert)
      Max_Wert = Wert;

  }
  Finde_Bestes ();
}

void 
Guete::Speichern (FILE * File)
{
  int i;

  fprintf (File, "%d %d %lf %lf\n", getestete, Bestes_bisher,
	   Min_Wert, Max_Wert);
  for (i = 0; i < getestete; i++)
    fprintf (File, "%d %lf ", Anzahlen[i], Werte[i]);
  fprintf (File, "\n");
}

int 
Guete::Laden (FILE * File)
{
  int i;

  if (!(fscanf (File, "%d %d %lf %lf", &i, &Bestes_bisher,
		&Min_Wert, &Max_Wert))) {
    Fehlermeldung ("Guete::Laden(File)", DATEIFORMATFEHLER);
    i = Bestes_bisher = 0;
    Min_Wert = Max_Wert = 0;
    free (Werte);
    free (Anzahlen);
    return (0);
  } else {			/* jetzt gehts los */
    if (getestete != 0) {
      free (Anzahlen);
      free (Werte);
    }
    getestete = i;
    if ((Werte = (double *) malloc (sizeof (double) * getestete)) == NULL) {
      Fehlermeldung ("Guete::Laden(File)", SPEICHERFEHLER);
      Werte = NULL;
      return (0);
    }
    if ((Anzahlen = (int *) malloc (sizeof (int) * getestete)) == NULL) {
      Fehlermeldung ("Guete::Laden(File)", SPEICHERFEHLER);
      free (Werte);
      Anzahlen = NULL;
    }
    for (i = 0; i < getestete; i++) {
      if (!fscanf (File, "%d %lf", &(Anzahlen[i]), &(Werte[i]))) {
#if 0
	this. ~ Guete ();
#endif
	return (0);
      }
    }
  }
  return (1);
}

/*****************************/
/* Alles zu Klasse Min_Guete */
/*****************************/
void 
Min_Guete::Finde_Bestes ()
{
  int i;
  double Bestes = MAXDOUBLE;

  for (i = 0; i < getestete; i++) {
    if (Werte[i] < Bestes) {
      Bestes = Werte[i];
      Bestes_bisher = Anzahlen[i];
    }
  }
}

/*****************************/
/* Alles zu Klasse Max_Guete */
/*****************************/
void 
Max_Guete::Finde_Bestes ()
{
  int i;
  double Bestes = -MAXDOUBLE;

  for (i = 0; i < getestete; i++) {
    if (Werte[i] > Bestes) {
      Bestes = Werte[i];
      Bestes_bisher = Anzahlen[i];
    }
  }
}

/***************************/
/* Alles zu Klasse S_Guete */
/***************************/
S_Guete::S_Guete ()
{
}

Guete_Typ 
S_Guete::Lese_Typ ()
{
  return (S);
}

void 
S_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		   DVektorArray & Cluster, double M)
{
  int i, k;
  double Result = 0;

  for (k = 0; k < Daten.Lese_Groesse (); k++) {
    for (i = 0; i < Cluster.Lese_Groesse (); i++) {
      Result += pow (U.Lese_i_j (i, k), M) *
	(DieNorm.d_quadr (Daten[k], Cluster[i])
	 - DieNorm.d_quadr (Cluster[i], Daten.Lese_Durchschnitt ()));
    }
  }
  Setze (Cluster.Lese_Groesse (), Result);
}

/****************************/
/* Alles zu Klasse CS_Guete */
/****************************/
CS_Guete::CS_Guete ()
{
}

Guete_Typ 
CS_Guete::Lese_Typ ()
{
  return (CS);
}

void 
CS_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster, double M)
{
  int i, j;
  double Result = 0, Min = MAXDOUBLE, Buffer;

  for (i = 0; i < Cluster.Lese_Groesse (); i++) {
    for (j = 0; j < Daten.Lese_Groesse (); j++) {
      Result += U.Lese_i_j (i, j) * U.Lese_i_j (i, j) *
	DieNorm.d_quadr (Daten[j], Cluster[i]);
    }
  }
  for (i = 0; i < Cluster.Lese_Groesse () - 1; i++) {
    for (j = i + 1; j < Cluster.Lese_Groesse (); j++) {
      Buffer = DieNorm.d_quadr (Cluster[j], Cluster[i]);
      if (Buffer < Min)
	Min = Buffer;
    }
  }
  Min *= Daten.Lese_Groesse ();
  Result /= Min;
  Setze (Cluster.Lese_Groesse (), Result);
}

/****************************/
/* Alles zu Klasse PK_Guete */
/****************************/
PK_Guete::PK_Guete ()
{
}

Guete_Typ 
PK_Guete::Lese_Typ ()
{
  return (PK);
}

void 
PK_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster, double M)
{
  int i, k;
  double Result = 0;

  for (k = 0; k < Daten.Lese_Groesse (); k++) {
    for (i = 0; i < Cluster.Lese_Groesse (); i++) {
      Result += U.Lese_i_j (i, k) * U.Lese_i_j (i, k);
    }
  }
  Result /= Daten.Lese_Groesse ();
  Setze (Cluster.Lese_Groesse (), Result);
}

/****************************/
/* Alles zu Klasse D1_Guete */
/****************************/
D1_Guete::D1_Guete ()
{
}

Guete_Typ 
D1_Guete::Lese_Typ ()
{
  return (D1);
}

void 
D1_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster, double M)
{
  int h = 0, i = 0, j, k, l;
  double Result = MAXDOUBLE, Max_h = -MAXDOUBLE, Buffer;
  DMatrix hartU (U.Lese_Dim_m (), U.Lese_Dim_n (), NULL);

  /* Zunaechst harte U_Matrix erzeugen */
  for (j = 0; j < Daten.Lese_Groesse (); j++) {
    Buffer = 0;
    for (i = 0; i < Cluster.Lese_Groesse (); i++) {
      if (U.Lese_i_j (i, j) > Buffer) {
	h = i;
	Buffer = U.Lese_i_j (i, j);
      }
    }
    hartU.Setze_i_j (h, j, 1.0);
  }

  /* Zunaechst unter dem Bruchstrich, und das nur einmal */
  for (h = 0; h < Cluster.Lese_Groesse (); h++) {
    Buffer = -MAXDOUBLE;
    for (k = 0; k < Daten.Lese_Groesse () - 1; k++) {
      for (l = k + 1; l < Daten.Lese_Groesse (); l++) {
	Buffer = DieNorm.d (Daten[k], Daten[l]) *
	  (hartU.Lese_i_j (h, k) * hartU.Lese_i_j (h, l));
	if (Buffer > Max_h)
	  Max_h = Buffer;
      }
    }
  }

  /* Jetzt oberhalb des Bruchstrichs */
  for (i = 0; i < Cluster.Lese_Groesse () - 1; i++) {
    for (j = i + 1; j < Cluster.Lese_Groesse (); j++) {
      for (k = 0; k < Daten.Lese_Groesse () - 1; k++) {
	for (l = k + 1; l < Daten.Lese_Groesse (); l++) {
	  if ((hartU.Lese_i_j (i, k) > 0) && (hartU.Lese_i_j (j, l) > 0)) {
	    Buffer = DieNorm.d (Daten[k], Daten[l]) /
	      (hartU.Lese_i_j (i, k) * hartU.Lese_i_j (j, l));
	    if (Buffer < Result)
	      Result = Buffer;
	  }
	}
      }
    }
  }
  Result /= Max_h;
  Setze (Cluster.Lese_Groesse (), Result);
}

/*****************************/
/* Alles zu Klasse FHV_Guete */
/*****************************/
FHV_Guete::FHV_Guete ()
{
}

Guete_Typ 
FHV_Guete::Lese_Typ ()
{
  return (FHV);
}

void 
FHV_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		     DVektorArray & Cluster, double M)
{
  double Result = 0;
  int i;
  DMatrixArray A (Cluster.Lese_Groesse (),
		  Daten.Lese_Dim (), Daten.Lese_Dim (), NULL);

  Errechne_Covarianz (Daten, U, A, Cluster, M);
  for (i = 0; i < Cluster.Lese_Groesse (); i++)
    Result += sqrt (A[i].Determinante ());
  Setze (Cluster.Lese_Groesse (), Result);
}

/*****************************/
/* Alles zu Klasse DPA_Guete */
/*****************************/
DPA_Guete::DPA_Guete ()
{
}

Guete_Typ 
DPA_Guete::Lese_Typ ()
{
  return (DPA);
}

void 
DPA_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		     DVektorArray & Cluster, double M)
{
  double Result = 0, Si;
  int i, j;
  DMatrix Inverse;
  DMatrixArray A (Cluster.Lese_Groesse (),
		  Daten.Lese_Dim (), Daten.Lese_Dim (), NULL);
  A_Norm DieNorm;

  Errechne_Covarianz (Daten, U, A, Cluster, M);

  for (i = 0; i < Cluster.Lese_Groesse (); i++) {
    Si = 0;
    Inverse = A[i].Gauss_Inverse ();
    for (j = 0; j < Daten.Lese_Groesse (); j++) {
      if (DieNorm.d_quadr (Inverse, Daten[j], Cluster[i]) < 1)
	Si += U[i][j];
    }
    Result += Si / sqrt (A[i].Determinante ());
  }

  Result /= Cluster.Lese_Groesse ();
  Setze (Cluster.Lese_Groesse (), Result);
}

/****************************/
/* Alles zu Klasse PD_Guete */
/****************************/
PD_Guete::PD_Guete ()
{

}

Guete_Typ 
PD_Guete::Lese_Typ ()
{
  return (PD);
}

void 
PD_Guete::Berechne (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster, double M)
{
  double Result = 0, Nenner = 0;
  int i, j;
  DMatrix Inverse;
  DMatrixArray A (Cluster.Lese_Groesse (),
		  Daten.Lese_Dim (), Daten.Lese_Dim (), NULL);
  A_Norm DieNorm;

  Errechne_Covarianz (Daten, U, A, Cluster, M);

  for (i = 0; i < Cluster.Lese_Groesse (); i++) {
    Nenner += sqrt (A[i].Determinante ());
    Inverse = A[i].Gauss_Inverse ();
    for (j = 0; j < Daten.Lese_Groesse (); j++) {
      if (DieNorm.d_quadr (Inverse, Daten[j], Cluster[i]) < 1)
	Result += U[i][j];
    }
  }
  Result /= Nenner;
  Setze (Cluster.Lese_Groesse (), Result);
}