regel.h

模糊聚类的算法实现程序

			       BVektor & relevante_Dims,
			       Parameter_Typ PT,
			       int ClusterNr);

/* Ermitteln die Regeln, ueberpruefen aber die Konvexitaet der  */
/* Zugehoerigkeitkurven, und teilen sie falls noetig:           */
  friend Regelbasis Finde_Regeln (double Huegel_Grenze,
				  Findungs_Art Art, Clustering & Cluster,
				  double Z_Grenze,
				  Datensatz & Daten,
				  int InputDim,
				  BVektor & relevante_Dims,
				  Parameter_Typ PT);
  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);
  Regelbasis Finde_Regeln (double Huegel_Grenze,
			   Findungs_Art Art, Clustering & Cluster,
			   double Z_Grenze,
			   Datensatz & Daten,
			   int InputDim,
			   BVektor & relevante_Dims,
			   Parameter_Typ PT,
			   int ClusterNr);

};

/* Friend Funktionen: */

Regelbasis Ermittle_Regeln (Clustering & Cluster,
			    double Z_Grenze,
			    Datensatz & Daten,
			    int InputDim,
			    BVektor & relevante_Dims,
			    Parameter_Typ PT);
Regelbasis Ermittle_Regeln (Clustering & Cluster,
			    double Z_Grenze,
			    Datensatz & Daten,
			    int Input_Dim,
			    BVektor & relevante_Dims,
			    Parameter_Typ PT,
			    BVektor & Diese_Cluster);
Regelbasis Ermittle_Regeln (Clustering & Cluster,
			    double Z_Grenze,
			    Datensatz & Daten,
			    int Input_Dim,
			    BVektor & relevante_Dims,
			    Parameter_Typ PT,
			    int ClusterNr);

Regelbasis Finde_Regeln (double Huegel_Grenze,
			 Findungs_Art Art, Clustering & Cluster,
			 double Z_Grenze,
			 Datensatz & Daten,
			 int InputDim,
			 BVektor & relevante_Dims,
			 Parameter_Typ PT);
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);
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);

/*************************************************/
double Berechne_RC (DVektorArray & GruppeAInput,
		    DVektorArray & GruppeBInput,
		    DVektorArray & OutputA,
		    DVektorArray & OutputB,
		    Regelbasis & RegelnA, Regelbasis & RegelnB);

/***********************************************************/
class Regel_Ausgabe
{
  friend Regel;
    protected:
  double Uebereinstimmung;	/* Minimale Hoehe       */
  DVektor InputHoehen;		/* Uebereinst. pro Input */
  DVektor *X_OutputKurve;	/* x-Werte der Ausgabef. */
  DVektor *Y_OutputKurve;	/* y-Werte der Ausgabef. */
  DVektor Ergebnisse;		/* i.A. die Schwerpunkte */
  int Input_Dim, Output_Dim;	/* kommt von der Regel  */
    public:
    Regel_Ausgabe (int InputDim = 0, int OutputDim = 0);
   ~Regel_Ausgabe ();

  void Setze_Dim (int xDim, int yDim);
  inline double Lese_Uebereinstimmung () {
    return (Uebereinstimmung);
  };
  inline DVektor & Lese_InputHoehen () {
    return (InputHoehen);
  };
  inline DVektor & Lese_X_Output (int i) {
    return (X_OutputKurve[i]);
  };
  inline DVektor & Lese_Y_Output (int i) {
    return (Y_OutputKurve[i]);
  };
  inline DVektor & Lese_Ergebnisse () {
    return (Ergebnisse);
  };
  inline int Lese_InputDim () {
    return (Input_Dim);
  };
  inline int Lese_OutputDim () {
    return (Output_Dim);
  };

    Regel_Ausgabe & operator = (Regel_Ausgabe & Das);
};

class Regelbasis_Ausgabe
{
  friend Regelbasis;
    protected:
    Regel_Ausgabe ** Ausgaben;	/* aus den einzelnen Regel      */
  DVektor Ergebnisse;		/* berechnete Endergebnisse     */
  int Anzahl;
    public:
    Regelbasis_Ausgabe (int Groesse = 0, int InputDim = 0, int OutputDim = 0);
   ~Regelbasis_Ausgabe ();

  void Setze_Dim (int xDim, int yDim);
  void Setze_Groesse (int So);

  inline DVektor & Lese_Ergebnisse () {
    return (Ergebnisse);
  } inline Regel_Ausgabe & operator[] (int i) {
    return (*(Ausgaben[i]));
  };
    Regelbasis_Ausgabe & operator = (Regelbasis_Ausgabe & Das);
};

/****************************************************************/
/*              Klassifizierungs-Stuff                          */
/****************************************************************/
class Klasse: public Dummy_Regel
{
  protected:
  public:
  Klasse (int Dimension = 0, Parameter_Typ PT = Trapez);
  Klasse (const Klasse & Das);
   ~Klasse () {
  };

  inline Regel_Typ Lese_Typ () {
    return (Typ_Klasse);
  };
  void print ();
  inline int Lese_Dimension () {
    return (xDim);
  };
  void Setze_Dimension (int So);

  friend Klasse Klasse_einlesen (FILE * File, int Dim);

  void Berechne (DVektor & Eingabe, Klassen_Ausgabe & Ausgabe);
  void Berechne (DVektor & Eingabe, BVektor & Diese_Eingaben,
		 Klassen_Ausgabe & Ausgabe);
  Klasse & operator = (Klasse & Das);
  inline Parameter & operator[] (int i) {
    return (*Daten[i]);
  };
};

class Klassifizierung
{
  Klasse **Klassen;
  int Anzahl, Dim;
  IVektor Klassen_Nummern;
    public:
    Klassifizierung (int Klassenanzahl = 0, int Dimension = 0);
   ~Klassifizierung ();
  void print ();
  inline int Lese_Dimension () {
    return (Dim);
  };
  void Setze_Dimension (int So);

  void Setze_Klassenanzahl (int So);
  inline int Lese_Klassenanzahl () const{
    return (Anzahl);
  };
  inline Klasse & Lese_Klasse (int Nummer) {
    return (*(Klassen[Nummer]));
  };
  inline IVektor & Lese_Klassen_Nummern () {
    return (Klassen_Nummern);
  };

  void Speichern (char *Name);
  friend Klassifizierung Klassifizierung_einlesen (char *Name);

  void Berechne (DVektor & Eingabe, Klassifizierungs_Ausgabe & Ausgabe);
  void Berechne (DVektor & Eingabe, BVektor & Diese_Regeln,
		 BVektor & Diese_Eingaben,
		 Klassifizierungs_Ausgabe & Ausgabe);

    Klassifizierung & operator = (const Klassifizierung & Das);
  void operator += (Klasse & Das);
  void operator += (const Klassifizierung & Diese);
  inline Klasse & operator[] (int i) const {
    return (*(Klassen[i]));
  };

  friend Klassifizierung Ermittle_Klassifizierung (
						    Clustering & Cluster,
						    double Z_Grenze,
						    Datensatz & Daten,
						    int InputDim,
						    BVektor & relevante_Dims,
						    Parameter_Typ PT);
  friend Klassifizierung Ermittle_Klassifizierung (
						    Clustering & Cluster,
						    double Z_Grenze,
						    Datensatz & Daten,
						    int Input_Dim,
						    BVektor & relevante_Dims,
						    Parameter_Typ PT,
						    BVektor & Diese_Cluster);
  friend Klassifizierung Ermittle_Klassifizierung (
						    Clustering & Cluster,
						    double Z_Grenze,
						    Datensatz & Daten,
						    int Input_Dim,
						    BVektor & relevante_Dims,
						    Parameter_Typ PT,
						    int ClusterNr);
};

class Klassen_Ausgabe
{
  friend Klasse;
    protected:
  double Uebereinstimmung;	/* Minimale Hoehe       */
  DVektor InputHoehen;		/* Uebereinst. pro Input */
    public:
    Klassen_Ausgabe (int Dimension = 0);

  inline void Setze_Dim (int Dimension) {
    InputHoehen.Setze_Dim (Dimension);
  };
  inline int Lese_Dim () {
    return (InputHoehen.Lese_Dim ());
  };

  inline double Lese_Uebereinstimmung () {
    return (Uebereinstimmung);
  };
  inline DVektor & Lese_InputHoehen () {
    return (InputHoehen);
  };
    Klassen_Ausgabe & operator = (Klassen_Ausgabe & Das);
};

class Klassifizierungs_Ausgabe
{
  friend Klassifizierung;
    protected:
    Klassen_Ausgabe ** Ausgaben;	/* aus den einzelnen Klassen    */
  int Ergebnis;			/* zu der Klassse gehoert Eing. */
  int Aus_dieser_Regel;
  DVektor Klassen_Zugehoerigkeiten;
  int Anzahl;
  char geklappt;
  char eindeutig;
    public:
    Klassifizierungs_Ausgabe (int Groesse = 0, int Dim = 0);
   ~Klassifizierungs_Ausgabe ();

  void Setze_Dim (int Dim);
  void Setze_Groesse (int So);

  inline int Lese_Ergebnis () {
    return (Ergebnis);
  } inline int Lese_Aus_dieser_Regel () {
    return (Aus_dieser_Regel);
  } inline DVektor & Lese_Zugehoerigkeiten () {
    return (Klassen_Zugehoerigkeiten);
  };
  inline char &Lese_geklappt () {
    return (geklappt);
  };
  inline char &Lese_eindeutig () {
    return (eindeutig);
  };
  inline Klassen_Ausgabe & operator[] (int i) {
    return (*(Ausgaben[i]));
  };
    Klassifizierungs_Ausgabe & operator = (Klassifizierungs_Ausgabe & Das);
};

#endif