regel.cc

模糊聚类的算法实现程序

void 
Klassifizierung::print ()
{
  int i;

  for (i = 0; i < Anzahl; i++)
    Klassen[i]->print ();
};

void 
Klassifizierung::Setze_Dimension (int So)
{
  int j;

  Dim = So;
  for (j = 0; j < Anzahl; j++)
    Klassen[j]->Setze_Dimension (So);
};

void 
Klassifizierung::Setze_Klassenanzahl (int Damit)
{
  int i;
  Klasse **Buffer;
  if (Anzahl != Damit) {
    if (Damit != 0) {
      Buffer = Klassen;
      if ((Klassen = (Klasse **) malloc (sizeof (Klasse *) * Damit)) == NULL)
	Fehlermeldung ("Klassifizierung::Setze_Klassenanzahl()", SPEICHERFEHLER);
      for (i = 0; (i < Anzahl) && (i < Damit); i++)
	Klassen[i] = Buffer[i];	/* alte uebernehmen */
      for (; i < Anzahl; i++)
	delete Buffer[i];	/* ueberfluessige */
      for (; i < Damit; i++)
	Klassen[i] = new Klasse (Dim);	/* brauche mehr */
      free (Buffer);
    } else {
      for (i = 0; i < Anzahl; i++)
	delete Klassen[i];
      free (Klassen);
      Klassen = NULL;
    }
    Anzahl = Damit;
  }
};

void 
Klassifizierung::Speichern (char *Name)
{
  FILE *File;
  int i;

  if ((File = fopen (Name, "w")) == NULL) {
    Fehlermeldung ("Klassifizierung::Speichern(char *Name)", DATEIOEFFNENFEHLER);
  } else {
    fprintf (File, "classification\n");
    fprintf (File, "%d %d\n", Anzahl, Dim);

    for (i = 0; i < Anzahl; i++)
      Klassen[i]->Speichern (File);
    fclose (File);
  }
};

void 
Klassifizierung::Berechne (DVektor & Eingabe,
			   Klassifizierungs_Ausgabe & Ausgabe)
{
  BVektor Regeln (Anzahl, NULL), Eingaben (Eingabe.Lese_Dim (), NULL);

  Regeln = 1;
  Eingaben = 1;
  Berechne (Eingabe, Regeln, Eingaben, Ausgabe);
};

void 
Klassifizierung::Berechne (DVektor & Eingabe, BVektor & Diese_Regeln,
			   BVektor & Diese_Eingaben,
			   Klassifizierungs_Ausgabe & Ausgabe)
{
  int KlassenNr, KlassenBuffer = -1, i;
  double Max = 0;
  Ausgabe.geklappt = FALSE;
  Ausgabe.eindeutig = TRUE;

  Ausgabe.Setze_Dim (Dim);
  Ausgabe.Setze_Groesse (Anzahl);
  Ausgabe.Ergebnis = -1;	//0;

  Ausgabe.Aus_dieser_Regel = 0;
  Ausgabe.Klassen_Zugehoerigkeiten.Setze_Dim (Klassen_Nummern.Lese_Dim ());
  Ausgabe.Klassen_Zugehoerigkeiten = 0.0;

  if (Dim != 0) {
    for (KlassenNr = 0; KlassenNr < Anzahl; KlassenNr++) {
      /* Regeln auswerten */
      if (Diese_Regeln[KlassenNr]) {
#if 0
	Klassen[KlassenNr].Berechne (Eingabe, Diese_Eingaben, *(Ausgabe.Ausgaben[KlassenNr]));
#else
	Klassen[KlassenNr]->Berechne (Eingabe, Diese_Eingaben, *(Ausgabe.Ausgaben[KlassenNr]));
#endif
	/* die entsprechende Klassen_Zugehoerigkeit modifizieren */
#if 0
	i = Klassen_Nummern.Lese_Index (Klassen[KlassenNr].Lese_Nummer ());
#else
	i = Klassen_Nummern.Lese_Index (Klassen[KlassenNr]->Lese_Nummer ());
#endif
	if (Ausgabe.Ausgaben[KlassenNr]->Lese_Uebereinstimmung () > Ausgabe.Klassen_Zugehoerigkeiten[i])
	  Ausgabe.Klassen_Zugehoerigkeiten[i] = Ausgabe.Ausgaben[KlassenNr]->Lese_Uebereinstimmung ();
	/* jetzt die Ausgabe dieser Regeln speichern */
	if (Max < Ausgabe.Ausgaben[KlassenNr]->Lese_Uebereinstimmung ()) {
	  Max = Ausgabe.Ausgaben[KlassenNr]->Lese_Uebereinstimmung ();
	  Ausgabe.Ergebnis = Klassen[KlassenNr]->Lese_Nummer ();
	  Ausgabe.Aus_dieser_Regel = KlassenNr;
	  Ausgabe.geklappt = TRUE;
	  Ausgabe.eindeutig = TRUE;
	  KlassenBuffer = Ausgabe.Ergebnis;
	} else if ((Max == Ausgabe.Ausgaben[KlassenNr]->Lese_Uebereinstimmung ()) &&
	(Max != 0) && (Klassen[KlassenNr]->Lese_Nummer () != KlassenBuffer))
	  Ausgabe.eindeutig = FALSE;
      } else {
	Ausgabe.Ausgaben[KlassenNr]-> ~ Klassen_Ausgabe ();
      }
    }
  }
};

Klassifizierung & Klassifizierung::operator = (const Klassifizierung & Das) {
  int i;

  if (Das.Anzahl != Anzahl) {
#if 0
    this. ~ Klassifizierung ();
#else
    this-> ~ Klassifizierung ();
#endif
    Anzahl = Das.Anzahl;
    if (Anzahl != 0) {
      if ((Klassen = (Klasse **) malloc (sizeof (Klasse *) * Anzahl)) == NULL)
	Fehlermeldung ("Klassifizierung::operator=(Klassifizierung &Das)", SPEICHERFEHLER);
      for (i = 0; i < Anzahl; i++)
	Klassen[i] = new Klasse (*(Das.Klassen[i]));
    } else
      Klassen = NULL;
  } else {
    for (i = 0; i < Anzahl; i++)
      *(Klassen[i]) = *(Das.Klassen[i]);
  }
  Dim = Das.Dim;
  Klassen_Nummern = Das.Klassen_Nummern;
};

void 
Klassifizierung::operator+= (Klasse & Diese)
{
  Klasse **Buffer;
  int i, j;

  Buffer = Klassen;

  Dim = Diese.Lese_Dimension ();	/* nur zur Sicherheit */
  if ((Klassen = (Klasse **) malloc (sizeof (Klasse *) * (Anzahl + 1))) == NULL)
    Fehlermeldung ("Klassifizierung::operator+=(Klasse& Diese)", SPEICHERFEHLER);

  if (!(Klassen_Nummern.Ist_drinnen (Diese.Lese_Nummer ())))
    Klassen_Nummern.Plus_Sortiert (Diese.Lese_Nummer ());

  j = 0;
  for (i = 0; i < Anzahl; i++) {
    if (Diese.Lese_Nummer () > Buffer[j]->Lese_Nummer ())
      Klassen[i] = Buffer[j++];
    else {
      Klassen[i++] = new Klasse (Diese);
      for (; i < Anzahl; i++)
	Klassen[i] = Buffer[j++];
      break;
    }
  }
  Anzahl++;
  if (i < Anzahl)
    Klassen[i] = new Klasse (Diese);
  free (Buffer);
};

void 
Klassifizierung::operator+= (const Klassifizierung & Diese)
{
  Klasse **Buffer;
  int i, j, k = 0;

  Buffer = Klassen;

  Dim = Diese.Dim;		/* nur zur Sicherheit */

  if (Anzahl + Diese.Anzahl != 0) {
    if ((Klassen = (Klasse **) malloc (sizeof (Klasse *) * (Anzahl + Diese.Anzahl))) == NULL)
      Fehlermeldung ("Klassifizierung::operator+=(Klassifizierung& Diese)", SPEICHERFEHLER);

    for (i = 0; i < Diese.Lese_Klassenanzahl (); i++) {
      if (!(Klassen_Nummern.Ist_drinnen (Diese[i].Lese_Nummer ())))
	Klassen_Nummern.Plus_Sortiert (Diese[i].Lese_Nummer ());
    }

    j = 0;
    k = 0;
    for (i = 0; i < Anzahl + Diese.Anzahl; i++) {
      if (j < Anzahl) {
	if (k < Diese.Anzahl) {
	  if (Diese[k].Lese_Nummer () < Buffer[j]->Lese_Nummer ()) {
	    Klassen[i] = new Klasse (Diese[k++]);
	  } else {
	    Klassen[i] = Buffer[j++];
	  }
	} else {
	  Klassen[i] = Buffer[j++];
	}
      } else {
	Klassen[i] = new Klasse (Diese[k++]);
      }
    }
    Anzahl += Diese.Anzahl;

    free (Buffer);
  }
};

Klassifizierung 
Klassifizierung_einlesen (char *Name)
  return Result (0, 0);
{
  int i;
  FILE *File;
  char Buffer[20];

  if ((File = fopen (Name, "r")) == NULL) {
    Fehlermeldung ("Klassifizierung_einlesen(char *Name)", DATEIOEFFNENFEHLER);
    return (Result);
  }
  if (!(fscanf (File, "%18s", Buffer))) {
    Fehlermeldung ("Klassifizierung_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if (strcmp (Buffer, "classification")) {
    Fehlermeldung ("Klassifizierung_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if (2 != fscanf (File, "%d %d", &Result.Anzahl, &Result.Dim)) {
    Fehlermeldung ("Klassifizierung_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if ((Result.Klassen = (Klasse **) malloc (sizeof (Klasse *) * Result.Anzahl)) == NULL)
    Fehlermeldung ("Klassifizierung_einlesen(char *Name)", SPEICHERFEHLER);
  for (i = 0; i < Result.Anzahl; i++) {
    Result.Klassen[i] = new Klasse (Klasse_einlesen (File, Result.Dim));
    if (Lese_Fehlerstatus () != KEINFEHLER) {
      i++;
      for (; i < Result.Anzahl; i++)
	Result.Klassen[i] = NULL;
      Result. ~ Klassifizierung ();
      break;
    } else {
      /* Klassennummern feststellen */
      if (!(Result.Klassen_Nummern.Ist_drinnen (Result[i].Lese_Nummer ())))
	Result.Klassen_Nummern.Plus_Sortiert (Result[i].Lese_Nummer ());
    }
  }
};

Klassifizierung 
Ermittle_Klassifizierung (
			   Clustering & Cluster,
			   double Z_Grenze,
			   Datensatz & Daten,
			   int Input_Dim,
			   BVektor & relevante_Dims,
			   Parameter_Typ PT)
  return Result (0, 0);
{
  int i;

  for (i = 0; i < Cluster.Lese_Zugehoerigkeit ().Lese_Dim_m (); i++)
    Result += Ermittle_Klassifizierung (Cluster, Z_Grenze, Daten,
					Input_Dim, relevante_Dims, PT, i);
//  Result.Sortiere_nach_Klassen();
};

Klassifizierung 
Ermittle_Klassifizierung (
			   Clustering & Cluster,
			   double Z_Grenze,
			   Datensatz & Daten,
			   int Input_Dim,
			   BVektor & relevante_Dims,
			   Parameter_Typ PT,
			   BVektor & Diese_Cluster)
  return Result (0, 0);
{
  int i;

  for (i = 0; i < Diese_Cluster.Anzahl_gesetzt (); i++) {
    Result += Ermittle_Klassifizierung (Cluster, Z_Grenze, Daten,
					Input_Dim, relevante_Dims, PT,
					Diese_Cluster.Lese_gesetzte (i));
  }
//  Result.Sortiere_nach_Klassen();
};

Klassifizierung 
Ermittle_Klassifizierung (
			   Clustering & Cluster,
			   double Z_Grenze,
			   Datensatz & Daten,
			   int Input_Dim,
			   BVektor & relevante_Dims,
			   Parameter_Typ PT,
			   int ClusterNr)
  return Result (0, 0);
{
  int i = 0, j, DatenNr, DimNr, KlassenNr = 0;
  DVektorArray DatenBuffer;
  Klasse *KlassenBuffer;
  DMatrix *Zugehoerigkeiten = &(Cluster.Lese_Zugehoerigkeit ());
  double DBuffer = 0;


  KlassenBuffer = new Klasse (relevante_Dims.Anzahl_gesetzt (), PT);

  /* DatenBuffer erstellen */
  DatenBuffer.DVektorArray (2, Daten.Lese_Groesse (), NULL);
  for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++) {
    DatenBuffer[DatenNr][1] = Zugehoerigkeiten->Lese_i_j (ClusterNr, DatenNr);
  }

  i = 0;
  for (DimNr = 0; DimNr < Daten.Lese_DatenDim (); DimNr++) {
    /* einzelne Dimensionen durchlaufen */
    if (relevante_Dims[DimNr]) {
      for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++) {
	DatenBuffer[DatenNr][0] = Daten.Lese_Daten ()[DatenNr][DimNr];
      }
      (*KlassenBuffer)[i].Finde_Parameter (DatenBuffer, Z_Grenze);
#if 0
      KlassenBuffer.Setze_Name (i, Daten.Lese_Name_Pointer (DimNr));
#else
      KlassenBuffer->Setze_Name (i, Daten.Lese_Name_Pointer (DimNr));
#endif
      i++;
    }
  }
  /* Jetzt noch testen, welche Klasse */
  if (Daten.Lese_Daten_Typ () == Klassifiziert) {
    DBuffer = 0;
    for (j = 0; j < Zugehoerigkeiten->Lese_Dim_n (); j++) {
      if ((*Zugehoerigkeiten)[ClusterNr][j] > DBuffer) {
	DBuffer = (*Zugehoerigkeiten)[ClusterNr][j];
	KlassenNr = Daten.Lese_Daten ()[j].Lese_Nummer ();
      }
    }
  } else
    KlassenNr = Cluster.Lese_Cluster ()[ClusterNr].Lese_Nummer ();
  KlassenBuffer->Setze_Nummer (KlassenNr);
  Result += *KlassenBuffer;

  delete KlassenBuffer;
};

/*************************************************/
Klassen_Ausgabe::Klassen_Ausgabe (int Dimension = 0)
{
  InputHoehen.DVektor (Dimension, 0, NULL);
};

Klassen_Ausgabe & Klassen_Ausgabe::operator = (Klassen_Ausgabe & Das) {
  InputHoehen = Das.InputHoehen;
  Uebereinstimmung = Das.Uebereinstimmung;
};

Klassifizierungs_Ausgabe::Klassifizierungs_Ausgabe (int Groesse = 0, int Dim = 0)
{
  int i;

  Ergebnis = 0;
  if (Groesse != 0) {
    if ((Ausgaben = (Klassen_Ausgabe **) malloc (sizeof (Klassen_Ausgabe *) * Groesse)) == NULL)
      Fehlermeldung ("Klassifizierungs_Ausgabe::Klassifizierungs_Ausgabe(...)", SPEICHERFEHLER);
  } else
    Ausgaben = NULL;
  for (i = 0; i < Groesse; i++)
    Ausgaben[i] = new Klassen_Ausgabe (Dim);

  Anzahl = Groesse;
};

Klassifizierungs_Ausgabe::~Klassifizierungs_Ausgabe ()
{
  int i;

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

void 
Klassifizierungs_Ausgabe::Setze_Dim (int Dim)
{
  int i;

  for (i = 0; i < Anzahl; i++) {
    Ausgaben[i]->Setze_Dim (Dim);
  }
};

void 
Klassifizierungs_Ausgabe::Setze_Groesse (int So)
{
  int i, Dim;
  Klassen_Ausgabe **Buffer;

  if (Anzahl != 0)
#if 0
    Dim = Ausgaben[0].Lese_Dim ();
#else
    Dim = Ausgaben[0]->Lese_Dim ();
#endif
  else
    Dim = 0;

  if (So != Anzahl) {
    if (So != 0) {
      Buffer = Ausgaben;
      if ((Ausgaben = (Klassen_Ausgabe **) malloc (sizeof (Klassen_Ausgabe *) * So)) == NULL)
	Fehlermeldung ("void Klassifizierungs_Ausgabe::Setze_Groesse(int So)", 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 Klassen_Ausgabe (Dim);	/* brauche mehr */
      free (Buffer);
    } else {
      for (i = 0; i < Anzahl; i++)
	delete Ausgaben[i];
      free (Ausgaben);
      Ausgaben = NULL;
    }
    Anzahl = So;
  }
};

Klassifizierungs_Ausgabe & Klassifizierungs_Ausgabe::operator = (Klassifizierungs_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 = (Klassen_Ausgabe **) malloc (sizeof (Klassen_Ausgabe *) * Anzahl)) == NULL)
	Fehlermeldung ("Klassifizierungs_Ausgabe::operator=", SPEICHERFEHLER);
    } else
      Ausgaben = NULL;
    for (i = 0; i < Anzahl; i++)
      Ausgaben[i] = new Klassen_Ausgabe (Das.Ausgaben[i]->Lese_Dim ());
  }
  for (i = 0; i < Anzahl; i++)
    *(Ausgaben[i]) = *(Das.Ausgaben[i]);
  Ergebnis = Das.Ergebnis;
  Aus_dieser_Regel = Das.Aus_dieser_Regel;
  geklappt = Das.geklappt;
  eindeutig = Das.eindeutig;
  Klassen_Zugehoerigkeiten = Das.Klassen_Zugehoerigkeiten;
};