regel.cc

模糊聚类的算法实现程序

  int i, j, InputDim = 0, OutputDim = 0, DatenNr, HuegelAnzahl, HuegelNr,
    DimNr, OK = TRUE;
  DVektorArray DatenBuffer, Huegel_vorher;
  IVektor *Huegel = 0;
  DVektor Y;
  Regel RegelBuffer;
  DMatrix *Zugehoerigkeit = &(Cluster.Lese_Zugehoerigkeit ());

  /* Zunaechst Input-Output_Dim feststellen */
  for (i = 0; i < Input_Dim; i++) {
    if (relevante_Dims[i])
      InputDim++;
  }
  for (i = Input_Dim; i < Daten.Lese_DatenDim (); i++) {
    if (relevante_Dims[i])
      OutputDim++;
  }

  RegelBuffer.Regel (InputDim, OutputDim, PT);
/***************************/
  /* Huegel_vorher erstellen */
/***************************/
  Huegel_vorher.DVektorArray (InputDim, Daten.Lese_Groesse (), NULL);
  Y.DVektor (Daten.Lese_Groesse (), 0, NULL);
  j = 0;
  for (i = 0; i < InputDim; i++) {
    if (relevante_Dims[i]) {
      for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++)
	Huegel_vorher[DatenNr][j] = Daten.Lese_Daten ()[DatenNr][i];
      j++;
    }
  }
  for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++)
    Y[DatenNr] = Zugehoerigkeit->Lese_i_j (ClusterNr, DatenNr);

/************************/
  /* Huegel suchen lassen */
/************************/
// ********************************
  // am 07.09.95 durch den unteren Aufruf ersetzt. Hoffentlich ist der besser !!
  switch (Art) {
  case Dim_insgesamt:
    Huegel = Huegel_vorher.Finde_Huegel (Y, HuegelAnzahl, Huegel_Grenze,
					 NAEHER_ERLAUBT, WINKEL_COSINUS);
    break;
  case Dim_einzeln:
    Huegel = Huegel_vorher.Finde_Huegel (Y, HuegelAnzahl, Huegel_Grenze,
					 NAEHER_ERLAUBT);
    break;
  default:
    break;
  }
  /* DatenBuffer erstellen */
  if (HuegelAnzahl != 0) {
    DatenBuffer.DVektorArray (2, 0, NULL);

    for (HuegelNr = 0; HuegelNr < HuegelAnzahl; HuegelNr++) {	/* Alle Huegel durchforsten */
      DatenBuffer.Setze_Groesse (Huegel[HuegelNr].Lese_Dim ());
      for (DatenNr = 0; DatenNr < Huegel[HuegelNr].Lese_Dim (); DatenNr++) {
	DatenBuffer[DatenNr][1] =
	  (*Zugehoerigkeit)[ClusterNr][Huegel[HuegelNr][DatenNr]];
      }
      i = 0;
      for (DimNr = 0; (DimNr < Daten.Lese_DatenDim ()) && OK; DimNr++) {
	/* einzelne Dimensionen durchlaufen */
	if (relevante_Dims[DimNr]) {
	  for (DatenNr = 0; DatenNr < Huegel[HuegelNr].Lese_Dim (); DatenNr++) {
	    DatenBuffer[DatenNr][0] = Daten.Lese_Daten ()[Huegel[HuegelNr][DatenNr]][DimNr];
	  }
	  if (!(RegelBuffer[i].Finde_Parameter (DatenBuffer, Z_Grenze)))
	    OK = FALSE;
	  RegelBuffer.Setze_Name (i, Daten.Lese_Name_Pointer (DimNr));
	  i++;
	}
      }
      if (OK)
	Result += RegelBuffer;
    }
    for (i = 0; i < HuegelAnzahl; i++)
      Huegel[i]. ~ IVektor ();
    free (Huegel);
  }
};

double 
Berechne_RC (DVektorArray & GruppeAInput,
	     DVektorArray & GruppeBInput,
	     DVektorArray & OutputA,
	     DVektorArray & OutputB,
	     Regelbasis & RegelnA, Regelbasis & RegelnB)
{
  Norm DieNorm;
  double DiffA = 0, DiffB = 0;
  int i;
  Regelbasis_Ausgabe Dummy;

  for (i = 0; i < GruppeAInput.Lese_Groesse (); i++) {
    RegelnB.Berechne (GruppeAInput[i], Dummy);
    DiffA += DieNorm.d_quadr (Dummy.Lese_Ergebnisse (), OutputA[i]);
  }
  DiffA = DiffA / GruppeAInput.Lese_Groesse ();

  for (i = 0; i < GruppeBInput.Lese_Groesse (); i++) {
    RegelnA.Berechne (GruppeBInput[i], Dummy);
    DiffB += DieNorm.d_quadr (Dummy.Lese_Ergebnisse (), OutputB[i]);
  }
  DiffB = DiffB / GruppeBInput.Lese_Groesse ();

  return ((DiffA + DiffB) / 2);
};

/********************************************************/
/*              Alles zur Klasse Regel_Ausgabe           */
/********************************************************/
Regel_Ausgabe::Regel_Ausgabe (int InputDim, int OutputDim)
{
  int i;

  Input_Dim = InputDim;
  Output_Dim = OutputDim;

  InputHoehen.DVektor (InputDim, 0, NULL);
  if (InputDim != 0) {
    if ((X_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * OutputDim)) == NULL)
      Fehlermeldung ("Regel_Ausgabe::Regel_Ausgabe", SPEICHERFEHLER);
    if ((Y_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * OutputDim)) == NULL)
      Fehlermeldung ("Regel_Ausgabe::Regel_Ausgabe", SPEICHERFEHLER);
    for (i = 0; i < OutputDim; i++) {
      X_OutputKurve[i].DVektor ();
      Y_OutputKurve[i].DVektor ();
    }
  } else
    X_OutputKurve = Y_OutputKurve = NULL;

  Ergebnisse.DVektor (OutputDim, 0, NULL);
};

Regel_Ausgabe::~Regel_Ausgabe ()
{
  int i;

  if (Output_Dim != 0) {
    for (i = 0; i < Output_Dim; i++) {
      X_OutputKurve[i]. ~ DVektor ();
      Y_OutputKurve[i]. ~ DVektor ();
    }
    free (X_OutputKurve);
    free (Y_OutputKurve);
    X_OutputKurve = Y_OutputKurve = NULL;
  }
  Input_Dim = Output_Dim = 0;
};

void 
Regel_Ausgabe::Setze_Dim (int xDim, int yDim)
{
  int i;

  if (xDim != Input_Dim) {
    if (Output_Dim != 0) {
      for (i = 0; i < Output_Dim; i++) {
	X_OutputKurve[i]. ~ DVektor ();
	Y_OutputKurve[i]. ~ DVektor ();
      }
      free (X_OutputKurve);
      free (Y_OutputKurve);
      X_OutputKurve = Y_OutputKurve = NULL;
    }
    if (xDim != 0) {
      if ((X_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * yDim)) == NULL)
	Fehlermeldung ("Regel_Ausgabe::Setze_Dim(int xDim, int yDim)", SPEICHERFEHLER);
      if ((Y_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * yDim)) == NULL)
	Fehlermeldung ("Regel_Ausgabe::Setze_Dim(int xDim, int yDim)", SPEICHERFEHLER);
      for (i = 0; i < yDim; i++) {
	X_OutputKurve[i].DVektor ();
	Y_OutputKurve[i].DVektor ();
      }
    } else
      X_OutputKurve = Y_OutputKurve = NULL;
    Input_Dim = xDim;
    InputHoehen.Setze_Dim (xDim);
  }
  Output_Dim = yDim;
  Ergebnisse.Setze_Dim (yDim);
};

Regel_Ausgabe & Regel_Ausgabe::operator = (Regel_Ausgabe & Das) {
  int i;

  if (Das.Output_Dim != Output_Dim) {
    if (Output_Dim != 0) {
      for (i = 0; i < Output_Dim; i++) {
	X_OutputKurve[i]. ~ DVektor ();
	Y_OutputKurve[i]. ~ DVektor ();
      }
      free (X_OutputKurve);
      free (Y_OutputKurve);
      X_OutputKurve = Y_OutputKurve = NULL;
    }
    if (Das.Output_Dim != 0) {
      if ((X_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * Das.Output_Dim)) == NULL)
	Fehlermeldung ("Regel_Ausgabe::operator=(Regel_Ausgabe& Das)", SPEICHERFEHLER);
      if ((Y_OutputKurve = (DVektor *) malloc (sizeof (DVektor) * Das.Output_Dim)) == NULL)
	Fehlermeldung ("Regel_Ausgabe::operator=(Regel_Ausgabe& Das)", SPEICHERFEHLER);
      for (i = 0; i < Das.Output_Dim; i++) {
	X_OutputKurve[i].DVektor ();
	Y_OutputKurve[i].DVektor ();
      }
    } else
      X_OutputKurve = Y_OutputKurve = NULL;
  }
  for (i = 0; i < Das.Input_Dim; i++) {
    X_OutputKurve[i] = Das.X_OutputKurve[i];
    Y_OutputKurve[i] = Das.Y_OutputKurve[i];
  }

  InputHoehen = Das.InputHoehen;
  Ergebnisse = Das.Ergebnisse;

  Input_Dim = Das.Input_Dim;
  Output_Dim = Das.Output_Dim;
};

/********************************************************/
/*         Alles zur Klasse RegelBasis_Ausgabe           */
/********************************************************/
Regelbasis_Ausgabe::Regelbasis_Ausgabe (int Groesse = 0, int InputDim = 0,
		    int OutputDim = 0)
{
  int i;

  Ergebnisse.DVektor (OutputDim, 0, NULL);
  if (Groesse != 0) {
    if ((Ausgaben = (Regel_Ausgabe **) malloc (sizeof (Regel_Ausgabe *) * Groesse)) == NULL)
      Fehlermeldung ("Regelbasis_Ausgabe::Regelbasis_Ausgabe", SPEICHERFEHLER);
  } else
    Ausgaben = NULL;
  for (i = 0; i < Groesse; i++)
    Ausgaben[i] = new Regel_Ausgabe (InputDim, OutputDim);
  Anzahl = Groesse;
};

Regelbasis_Ausgabe::~Regelbasis_Ausgabe ()
{
  int i;

  if (Anzahl != 0) {
    for (i = 0; i < Anzahl; i++)
      delete Ausgaben[i];
    free (Ausgaben);
    Ausgaben = NULL;
  }
  Anzahl = 0;
};

void 
Regelbasis_Ausgabe::Setze_Dim (int xDim, int yDim)
{
  int i;

  for (i = 0; i < Anzahl; i++) {
    Ausgaben[i]->Setze_Dim (xDim, yDim);
  }
  Ergebnisse.Setze_Dim (yDim);
};

void 
Regelbasis_Ausgabe::Setze_Groesse (int So)
{
  int i, xDim, yDim;
  Regel_Ausgabe **Buffer;

  if (Anzahl != 0) {
#if 0
    xDim = Ausgaben[0].Lese_InputDim ();
    yDim = Ausgaben[0].Lese_OutputDim ();
#else
    xDim = Ausgaben[0]->Lese_InputDim ();
    yDim = Ausgaben[0]->Lese_OutputDim ();
#endif
  } else
    xDim = yDim = 0;

  if (So != Anzahl) {
    if (So != 0) {
      Buffer = Ausgaben;
      if ((Ausgaben = (Regel_Ausgabe **) malloc (sizeof (Regel_Ausgabe *) * So)) == NULL)
	Fehlermeldung ("Regelbasis_Ausgabe::Regelbasis_Ausgabe", SPEICHERFEHLER);
      for (i = 0; (i < Anzahl) && (i < So); i++)
	Ausgaben[i] = Buffer[i];	/* alte uebernehmen */
      for (; i < Anzahl; i++)
	delete Buffer[i];	/* ueberfluessige */
      for (; i < So; i++)
	Ausgaben[i] = new Regel_Ausgabe (xDim, yDim);	/* brauche mehr */
      free (Buffer);
    } else {
      for (i = 0; i < Anzahl; i++)
	delete Ausgaben[i];
      free (Ausgaben);
      Ausgaben = NULL;
    }
    Anzahl = So;
  }
};

Regelbasis_Ausgabe & Regelbasis_Ausgabe::operator = (Regelbasis_Ausgabe & Das) {
  int i;

  if (Das.Anzahl != Anzahl) {
    for (i = 0; i < Anzahl; i++)
      delete Ausgaben[i];
    free (Ausgaben);
    Anzahl = Das.Anzahl;
    if (Anzahl != 0) {
      if ((Ausgaben = (Regel_Ausgabe **) malloc (sizeof (Regel_Ausgabe *) * Anzahl)) == NULL)
	Fehlermeldung ("Regelbasis_Ausgabe::operator=", SPEICHERFEHLER);
    } else
      Ausgaben = NULL;
    for (i = 0; i < Anzahl; i++)
      Ausgaben[i] = new Regel_Ausgabe (Das.Ausgaben[i]->Lese_InputDim (),
				       Das.Ausgaben[i]->Lese_OutputDim ());
  }
  for (i = 0; i < Anzahl; i++)
    *(Ausgaben[i]) = *(Das.Ausgaben[i]);
};

/***********************************************************/
Klasse::Klasse (int Dimension = 0, Parameter_Typ PT = Trapez)
{
  ((Dummy_Regel *) (this))->Dummy_Regel (Dimension, 0, PT);
};

Klasse::Klasse (const Klasse & Das)
{
  (*((Dummy_Regel *) this)) = ((const Dummy_Regel &) Das);
};

void 
Klasse::print ()
{
  int i;

  printf ("Falls ");
  for (i = 0; i < xDim; i++) {
    printf ("%s", Namen[i]);
    Daten[i]->print ();
    if (i + 1 != xDim)
      printf ("und   ");
  }
  printf ("dann Klasse %d.", Nummer);
};

void 
Klasse::Setze_Dimension (int So)
{
  int i;
  Parameter_Typ PT = Trapez;

  if (xDim != 0)
    PT = Daten[0]->Lese_Parameter_Typ ();

  if (So != xDim) {
    for (i = 0; i < xDim; i++) {
      free (Namen[i]);
      delete Daten[i];
    }
    free (Namen);
    free (Daten);
    Namen = NULL;
    Daten = NULL;
    if (So != 0) {
      if ((Namen = (char **) malloc (sizeof (char *) * So)) == NULL)
	  Fehlermeldung ("Klasse::Setze_Dimensionen", SPEICHERFEHLER);
      for (i = 0; i < So; i++) {
	if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	    Fehlermeldung ("Klasse::Setze_Dimensionen", SPEICHERFEHLER);
      }
      if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * So)) == NULL)
	Fehlermeldung ("Klasse::Setze_Dimensionen", SPEICHERFEHLER);
      switch (PT) {
      case Trapez:
	for (i = 0; i < So; i++)
	  Daten[i] = new Trapez_Parameter ();
	break;
      case Konvex:
	for (i = 0; i < So; i++)
	  Daten[i] = new Konvex_Parameter ();
	break;
      default:
	break;
      }
    } else
      Daten = NULL;
  }
  xDim = So;
};

void 
Klasse::Berechne (DVektor & Eingabe, Klassen_Ausgabe & Ausgabe)
{
  int i;

  Ausgabe.Setze_Dim (xDim);
  Ausgabe.Uebereinstimmung = 1;
  /* zunaechst die Hoehe berechnen */
  for (i = 0; i < xDim; i++) {
    Ausgabe.InputHoehen[i] = Daten[i]->Berechne_Hoehe (Eingabe[i]);
    if (Ausgabe.InputHoehen[i] < Ausgabe.Uebereinstimmung)
      Ausgabe.Uebereinstimmung = Ausgabe.InputHoehen[i];
  }
};

void 
Klasse::Berechne (DVektor & Eingabe, BVektor & Diese_Eingaben,
		  Klassen_Ausgabe & Ausgabe)
{
  int i;

  Ausgabe.Setze_Dim (xDim);
  if (Diese_Eingaben.Anzahl_gesetzt () == 0)
    Ausgabe.Uebereinstimmung = 0;
  else {
    Ausgabe.Uebereinstimmung = 1;
    /* zunaechst die Hoehe berechnen */
    for (i = 0; i < xDim; i++) {
      if (Diese_Eingaben[i]) {
	Ausgabe.InputHoehen[i] = Daten[i]->Berechne_Hoehe (Eingabe[i]);
	if (Ausgabe.InputHoehen[i] < Ausgabe.Uebereinstimmung)
	  Ausgabe.Uebereinstimmung = Ausgabe.InputHoehen[i];
      } else
	Ausgabe.InputHoehen[i] = 0;
    }
  }
};

Klasse & Klasse::operator = (Klasse & Das) {
  (*((Dummy_Regel *) this)) = ((Dummy_Regel &) Das);
};

Klasse 
Klasse_einlesen (FILE * File, int x)
  return Result (0, Trapez /* <- ist aber egal */ );
{
  int Buffer;

  fscanf (File, "%d", &Buffer);	/* Nummer einlesen */
  Result.File_einlesen (File, x, 0);
  Result.Setze_Nummer (Buffer);
};

/**************************************************************/
Klassifizierung::Klassifizierung (int Klassenanzahl = 0, int Dimension = 0)
{
  int i;

  Anzahl = Klassenanzahl;
  Dim = Dimension;

  if (Anzahl != 0) {
    if ((Klassen = (Klasse **) malloc (sizeof (Klasse *) * Anzahl)) == NULL)
      Fehlermeldung ("Klassifizierung::Klassifizierung", SPEICHERFEHLER);
    for (i = 0; i < Anzahl; i++)
      Klassen[i] = new Klasse (Dimension);
  } else
    Klassen = NULL;
};

Klassifizierung::~Klassifizierung ()
{
  int i;

  if (Anzahl != 0) {
    for (i = 0; i < Anzahl; i++)
      delete Klassen[i];
    free (Klassen);
    Dim = Anzahl = 0;
    Klassen = NULL;
  }
};