regel.cc

模糊聚类的算法实现程序

      Ausgabe.Y_OutputKurve[i - xDim]. ~ DVektor ();
    }
  }
};

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

Regel 
Regel_einlesen (FILE * File, int x, int y)
  return Result (0, 0, Trapez /* <- ist aber egal */ );
{
  Result.File_einlesen (File, x, y);
};
/********************************************************/
/*              Alles zur Klasse Regelbasis             */
/********************************************************/
Regelbasis::Regelbasis (int Regelanzahl, int xDimension, int yDimension)
{
  int i;

  Anzahl = Regelanzahl;
  xDim = xDimension;
  yDim = yDimension;

  if (Anzahl != 0) {
    if ((Regeln = (Regel **) malloc (sizeof (Regel *) * Anzahl)) == NULL)
      Fehlermeldung ("Regelbasis::Regelbasis", SPEICHERFEHLER);
    for (i = 0; i < Anzahl; i++)
      Regeln[i] = new Regel (xDimension, yDimension);
  } else
    Regeln = NULL;
};

Regelbasis::~Regelbasis ()
{
  int i;

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

void 
Regelbasis::print ()
{
  int i;

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

void 
Regelbasis::Setze_xDimension (int i)
{
  int j;

  xDim = i;
  for (j = 0; j < Anzahl; j++)
    Regeln[j]->Setze_xDimension (i);
};

void 
Regelbasis::Setze_yDimension (int i)
{
  int j;

  yDim = i;
  for (j = 0; j < Anzahl; j++)
    Regeln[j]->Setze_yDimension (i);
};

void 
Regelbasis::Setze_Dimensionen (int In, int Out)
{
  int i;

  xDim = In;
  yDim = Out;
  for (i = 0; i < Anzahl; i++)
#if 0
    Regeln[i].Setze_Dimensionen (In, Out);
#else
    Regeln[i]->Setze_Dimensionen (In, Out);
#endif
}

void 
Regelbasis::Setze_Regelanzahl (int Damit)
{
  int i;
  Regel **Buffer;

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

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

  if ((File = fopen (Name, "w")) == NULL) {
    Fehlermeldung ("Regelbasis::Speichern(char *Name)", DATEIOEFFNENFEHLER);
  } else {
    fprintf (File, "rules\n");
    fprintf (File, "%d %d %d\n", Anzahl, xDim, yDim);

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

void 
Regelbasis::Berechne (DVektor & Eingabe,
		      Regelbasis_Ausgabe & Ausgabe)
{
  int DimNr, RegelNr;
  double GesammtHoehe = 0;

  Ausgabe.Setze_Dim (xDim, yDim);
  Ausgabe.Setze_Groesse (Anzahl);
  Ausgabe.Ergebnisse.NullVektor ();

  if (yDim != 0) {
    for (RegelNr = 0; RegelNr < Anzahl; RegelNr++) {
      /* Regeln auswerten */
#if 0
      Regeln[RegelNr].Berechne (Eingabe, *(Ausgabe.Ausgaben[RegelNr]));
#else
      Regeln[RegelNr]->Berechne (Eingabe, *(Ausgabe.Ausgaben[RegelNr]));
#endif
      GesammtHoehe += Ausgabe.Ausgaben[RegelNr]->Lese_Uebereinstimmung ();

      for (DimNr = 0; DimNr < yDim; DimNr++) {
	Ausgabe.Ergebnisse[DimNr] +=
	  Ausgabe.Ausgaben[RegelNr]->Lese_Ergebnisse ()[DimNr] *
	  Ausgabe.Ausgaben[RegelNr]->Lese_Uebereinstimmung ();
      }
    }
    /* Gewichte herausdividieren */
    if (GesammtHoehe != 0)
      for (DimNr = 0; DimNr < yDim; DimNr++)
	Ausgabe.Ergebnisse[DimNr] /= GesammtHoehe;
    else
      for (DimNr = 0; DimNr < yDim; DimNr++)
	Ausgabe.Ergebnisse[DimNr] = 0;
  }
};

void 
Regelbasis::Berechne (DVektor & Eingabe, BVektor & Diese_Regeln,
		      BVektor & Diese_Eingaben, BVektor & Diese_Ausgaben,
		      Regelbasis_Ausgabe & Ausgabe)
{
  int DimNr, RegelNr;
  double GesammtHoehe = 0;

  Ausgabe.Setze_Dim (xDim, yDim);
  Ausgabe.Setze_Groesse (Anzahl);
  Ausgabe.Ergebnisse.NullVektor ();

  if (yDim != 0) {
    for (RegelNr = 0; RegelNr < Anzahl; RegelNr++) {
      /* Regeln auswerten */
      if (Diese_Regeln[RegelNr]) {
#if 0
	Regeln[RegelNr].Berechne (Eingabe, Diese_Eingaben,
			      Diese_Ausgaben, *(Ausgabe.Ausgaben[RegelNr]));
#else
	Regeln[RegelNr]->Berechne (Eingabe, Diese_Eingaben,
			      Diese_Ausgaben, *(Ausgabe.Ausgaben[RegelNr]));
#endif
	GesammtHoehe += Ausgabe.Ausgaben[RegelNr]->Lese_Uebereinstimmung ();

	for (DimNr = 0; DimNr < yDim; DimNr++) {
	  if (Diese_Ausgaben[DimNr])
	    Ausgabe.Ergebnisse[DimNr] +=
	      Ausgabe.Ausgaben[RegelNr]->Lese_Ergebnisse ()[DimNr] *
	      Ausgabe.Ausgaben[RegelNr]->Lese_Uebereinstimmung ();
	}
      } else {			/* Ausgaben loeschen */
	Ausgabe.Ausgaben[RegelNr]-> ~ Regel_Ausgabe ();
      }
    }
    /* Gewichte herausdividieren */
    if (GesammtHoehe != 0)
      for (DimNr = 0; DimNr < yDim; DimNr++)
	Ausgabe.Ergebnisse[DimNr] /= GesammtHoehe;
    else
      for (DimNr = 0; DimNr < yDim; DimNr++)
	Ausgabe.Ergebnisse[DimNr] = 0;
  }
};

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

  if (Das.Anzahl != Anzahl) {
#if 0
    this. ~ Regelbasis ();
#else
    this-> ~ Regelbasis ();
#endif
    Anzahl = Das.Anzahl;
    if (Anzahl != 0) {
      if ((Regeln = (Regel **) malloc (sizeof (Regel *) * Anzahl)) == NULL)
	Fehlermeldung ("Regelbasis::operator=(...)", SPEICHERFEHLER);
      for (i = 0; i < Anzahl; i++)
	Regeln[i] = new Regel (*(Das.Regeln[i]));
    } else
      Regeln = NULL;
  } else {
    for (i = 0; i < Anzahl; i++)
      *(Regeln[i]) = *(Das.Regeln[i]);
  }
  xDim = Das.xDim;
  yDim = Das.yDim;
};

void 
Regelbasis::operator+= (Regel & Diese)
{
  Regel **Buffer;
  int i;

  Buffer = Regeln;

  xDim = Diese.Lese_xDimension ();
  yDim = Diese.Lese_yDimension ();	/* nur zur Sicherheit */
  if ((Regeln = (Regel **) malloc (sizeof (Regel *) * (Anzahl + 1))) == NULL)
    Fehlermeldung ("Regelbasis::Einfuegen_Regel", SPEICHERFEHLER);

  for (i = 0; i < Anzahl; i++)
    Regeln[i] = Buffer[i];


  Regeln[Anzahl] = new Regel (Diese);

  free (Buffer);
  Anzahl++;
};

void 
Regelbasis::operator+= (Regelbasis & Diese)
{
  Regel **Buffer;
  int i, j = 0;

  Buffer = Regeln;

  xDim = Diese.xDim;
  yDim = Diese.yDim;		/* nur zur Sicherheit */
  if (Anzahl + Diese.Anzahl != 0) {
    if ((Regeln = (Regel **) malloc (sizeof (Regel *) * (Anzahl + Diese.Anzahl))) == NULL)
      Fehlermeldung ("Regelbasis::Einfuegen_Regel", SPEICHERFEHLER);

    for (i = 0; i < Anzahl; i++)
      Regeln[i] = Buffer[i];
    for (i = Anzahl; i < Anzahl + Diese.Anzahl; i++) {
      Regeln[i] = new Regel (*(Diese.Regeln[j++]));
    }

    free (Buffer);
    Anzahl += Diese.Anzahl;
  }
};

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

  if ((File = fopen (Name, "r")) == NULL) {
    Fehlermeldung ("Regelbasis_einlesen(char *Name)", DATEIOEFFNENFEHLER);
    return (Result);
  }
  if (!(fscanf (File, "%18s", Buffer))) {
    Fehlermeldung ("Regelbasis_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if (strcmp (Buffer, "rules")) {
    Fehlermeldung ("Regelbasis_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if (3 != fscanf (File, "%d %d %d", &Result.Anzahl, &Result.xDim, &Result.yDim)) {
    Fehlermeldung ("Regelbasis_einlesen(char *Name)", DATEIFORMATFEHLER);
    return (Result);
  }
  if ((Result.Regeln = (Regel **) malloc (sizeof (Regel *) * Result.Anzahl)) == NULL)
    Fehlermeldung ("Regelbasis_einlesen(char *Name)", SPEICHERFEHLER);
  for (i = 0; i < Result.Anzahl; i++) {
    Result.Regeln[i] = new Regel (Regel_einlesen (File, Result.xDim, Result.yDim));
    if (Lese_Fehlerstatus () != KEINFEHLER) {
      i++;
      for (; i < Result.Anzahl; i++)
	Result.Regeln[i] = NULL;
      Result. ~ Regelbasis ();
      break;
    }
  }
};
/********************************************************/
/*              Alle anderen Funktionen                 */
/********************************************************/
Regelbasis 
Ermittle_Regeln (Clustering & Cluster,
		 double Z_Grenze,
		 Datensatz & Daten,
		 int Input_Dim,
		 BVektor & relevante_Dims,
		 Parameter_Typ PT)
  return Result (0, 0, 0);
{
  int i;
  Regelbasis Buffer;

  for (i = 0; i < Cluster.Lese_Zugehoerigkeit ().Lese_Dim_m (); i++) {
    Buffer = Ermittle_Regeln (Cluster, Z_Grenze, Daten,
			      Input_Dim, relevante_Dims, PT, i);
    if (Buffer.Lese_Dimension () != 0)
      Result += Buffer;
  }
};

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

  for (i = 0; i < Diese_Cluster.Anzahl_gesetzt (); i++) {
    Buffer = Ermittle_Regeln (Cluster, Z_Grenze, Daten,
			      Input_Dim, relevante_Dims, PT,
			      Diese_Cluster.Lese_gesetzte (i));
    if (Buffer.Lese_Dimension () != 0)
      Result += Buffer;

  }
};

Regelbasis 
Ermittle_Regeln (Clustering & Cluster,
		 double Z_Grenze,
		 Datensatz & Daten,
		 int Input_Dim,
		 BVektor & relevante_Dims,
		 Parameter_Typ PT,
		 int ClusterNr)
  return Result (0, 0, 0);
{
  int i, InputDim = 0, OutputDim = 0, DatenNr, DimNr, OK = TRUE;
  DVektorArray DatenBuffer;
  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);

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

  i = 0;
  for (DimNr = 0; (DimNr < Daten.Lese_DatenDim ()) && OK; DimNr++) {
    /* einzelne Dimensionen durchlaufen */
    if (relevante_Dims[DimNr]) {
      for (DatenNr = 0; DatenNr < Daten.Lese_Groesse (); DatenNr++) {
	DatenBuffer[DatenNr][0] = Daten.Lese_Daten ()[DatenNr][DimNr];
      }
      if (!(RegelBuffer[i].Finde_Parameter (DatenBuffer, Z_Grenze)))
	OK = FALSE;		/* Fehler */
      RegelBuffer.Setze_Name (i, Daten.Lese_Name_Pointer (DimNr));
      i++;
    }
  }
  if (OK)
    Result += RegelBuffer;
};

Regelbasis 
Finde_Regeln (double Huegel_Grenze,
	      Findungs_Art Art, Clustering & Cluster,
	      double Z_Grenze,
	      Datensatz & Daten,
	      int Input_Dim,
	      BVektor & relevante_Dims,
	      Parameter_Typ PT)
  return Result (0, 0, 0);
{
  int i;
  Regelbasis Buffer;

  for (i = 0; i < Cluster.Lese_Zugehoerigkeit ().Lese_Dim_m (); i++) {
    Buffer = Finde_Regeln (Huegel_Grenze, Art, Cluster, Z_Grenze, Daten, Input_Dim,
			   relevante_Dims, PT, i);
    if (Buffer.Lese_Dimension () != 0)
      Result += Buffer;
  }
};

Regelbasis 
Finde_Regeln (double Huegel_Grenze,
	      Findungs_Art Art, Clustering & Cluster,
	      double Z_Grenze,
	      Datensatz & Daten,
	      int Input_Dim,
	      BVektor & relevante_Dims,
	      Parameter_Typ PT,
	      BVektor & Diese_Cluster)
  return Result (0, 0, 0);
{
  int i;
  Regelbasis Buffer;

  for (i = 0; i < Diese_Cluster.Anzahl_gesetzt (); i++) {
    Buffer = Finde_Regeln (Huegel_Grenze, Art, Cluster, Z_Grenze, Daten, Input_Dim,
		       relevante_Dims, PT, Diese_Cluster.Lese_gesetzte (i));
    if (Buffer.Lese_Dimension () != 0)
      Result += Buffer;
  }
};

Regelbasis 
Finde_Regeln (double Huegel_Grenze,
	      Findungs_Art Art, Clustering & Cluster,
	      double Z_Grenze,
	      Datensatz & Daten,
	      int Input_Dim,
	      BVektor & relevante_Dims,
	      Parameter_Typ PT,
	      int ClusterNr)
  return Result (0, 0, 0);
{