regel.h

模糊聚类分析的源程序！

/********************************************************/
/*   filename: regel.h                                  */
/*                                                      */
/********************************************************/
/* programmed by: Oliver Wagner                         */
/* last change:  (XXX: not updated)                     */
/********************************************************/
#ifndef _REGEL_H
#define _REGEL_H

class Parameter;
class Trapez_Parameter;
class Konvex_Parameter;
class Regel;
class Regelbasis;
class Regel_Ausgabe;
class Regelbasis_Ausgabe;
class Klasse;
class Klassifizierung;
class Klassen_Ausgabe;
class Klassifizierungs_Ausgabe;

enum Findungs_Art {
  Dim_einzeln, Dim_insgesamt
};
enum Parameter_Typ {
  Trapez, Konvex
};
enum Regel_Typ {
  Dummy, Typ_Regel, Typ_Klasse
};


#define PARAMETER_F_PROZENT .02
#define PARAMETER_SCHRITTE 40

#define _REGEL_DATA
#include "fehler.h"
#include "matrix.h"
#include "daten.h"
#include "norm.h"
#include "vektor.h"
#include "cluster.h"
#undef _REGEL_DATA
#endif

#ifndef _REGEL_DATA
#define _REGEL_DATA

class Parameter
{
#if 0
  protected:
#else
  public:
#endif
  Parameter_Typ So;
  public:
  Parameter () {
  };
  Parameter (const Parameter & Das) {
  };
  virtual ~ Parameter () {
  };
  virtual void print () = 0;

  virtual Parameter_Typ Lese_Parameter_Typ () = 0;

  virtual void Setze_Parameter (Parameter & Damit) = 0;
  virtual void Setze_xParameter (int Index, double Damit) = 0;
  virtual int Lese_Parameter_Anzahl () = 0;
  virtual double &Lese_xParameter (int i) = 0;
  virtual double Lese_yParameter (int i) = 0;

  virtual char Finde_Parameter (DVektorArray & Daraus,
				double Z_Grenze) = 0;

  virtual void Speichern (FILE * File) = 0;

  virtual double Berechne_Schwerpunkt (double Hoehe, DVektor & x, DVektor & y) = 0;
  virtual double Berechne_Hoehe (double Eingabe) = 0;
  virtual void Berechne_Form (double Hoehe, DVektor & x, DVektor & y) = 0;

  virtual Parameter & operator = (Parameter & Das) = 0;
protected:
};

class Trapez_Parameter: public Parameter
{
  protected:
  double Daten[4];
  double Steigung[2];
    public:
    Trapez_Parameter ();
    Trapez_Parameter (const Trapez_Parameter & Das);
    Trapez_Parameter (const Parameter & Das);
  void print ();

  inline Parameter_Typ Lese_Parameter_Typ () {
    return (So);
  };
  void Setze_Parameter (Parameter & Damit);
  void Setze_xParameter (int Index, double Damit);
  inline int Lese_Parameter_Anzahl () {
    return (4);
  };
  inline double &Lese_xParameter (int i) {
    return (Daten[i]);
  };
  double Lese_yParameter (int i);

  char Finde_Parameter (DVektorArray & Daraus, double Z_Grenze);

  void Speichern (FILE * File);
  friend Trapez_Parameter Trapez_einlesen (FILE * File);

  double Berechne_Schwerpunkt (double Hoehe, DVektor & x, DVektor & y);
  double Berechne_Hoehe (double Eingabe);
  void Berechne_Form (double Hoehe, DVektor & x, DVektor & y);

    Parameter & operator = (Parameter & Das);
    protected:
  double Parameter_Fehler (DVektorArray & Damit);
};

class Konvex_Parameter: public Parameter
{
  protected:
  DVektorArray Daten;
  public:
  Konvex_Parameter ();
  Konvex_Parameter (const Konvex_Parameter & Das);
    Konvex_Parameter (const Parameter & Das);
  void print ();

  inline Parameter_Typ Lese_Parameter_Typ () {
    return (So);
  };
  void Setze_Parameter (Parameter & Damit);
  void Setze_xParameter (int Index, double Damit);
  void Setze_yParameter (int Index, double Damit);
  inline int Lese_Parameter_Anzahl () {
    return (Daten.Lese_Dim ());
  };
  inline double &Lese_xParameter (int i) {
    return (Daten[0][i]);
  };
  inline double Lese_yParameter (int i) {
    return (Daten[1][i]);
  };

  char Finde_Parameter (DVektorArray & Daraus, double Z_Grenze);

  void Speichern (FILE * File);
  friend Konvex_Parameter Konvex_einlesen (FILE * File);

  double Berechne_Schwerpunkt (double Hoehe, DVektor & x, DVektor & y);
  double Berechne_Hoehe (double Eingabe);
  void Berechne_Form (double Hoehe, DVektor & x, DVektor & y);

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

/**************************************************************************/
class Dummy_Regel
{
  protected:
  Parameter ** Daten;
  int xDim, yDim;
  char **Namen;
  int Nummer;
    public:
    Dummy_Regel (int xDimension = 0, int yDimension = 0, Parameter_Typ PT = Trapez);
    Dummy_Regel (const Dummy_Regel & Das);
    virtual ~ Dummy_Regel ();

  virtual Regel_Typ Lese_Typ () {
    return (Dummy);
  };
  virtual void print () = 0;
  inline int Lese_Dimension () {
    return (xDim + yDim);
  };
  inline int &Lese_Nummer () {
    return (Nummer);
  };
  void Setze_Nummer (int i) {
    Nummer = i;
  };
  inline char *Lese_Name (int i) {
    return (Namen[i]);
  };
  void Setze_Name (int i, char *Damit) {
    strcpy (Namen[i], Damit);
  };

  void Speichern (FILE * File);

  void Setze_Parameter (int Index, Parameter & Damit);
  inline Parameter & Lese_Parameter (int Index) {
    return (*(Daten[Index]));
  };

    Dummy_Regel & operator = (const Dummy_Regel & Das);
    protected:
  void File_einlesen (FILE * File, int x, int y);
};

class Regel:public Dummy_Regel
{
  public:
  Regel (int xDimension = 0, int yDimension = 0, Parameter_Typ PT = Trapez);
    Regel (const Regel & Das);
   ~Regel ();

  inline Regel_Typ Lese_Typ () {
    return (Typ_Regel);
  };
  void print ();
  inline int Lese_xDimension () {
    return (xDim);
  };
  inline int Lese_yDimension () {
    return (yDim);
  };
  void Setze_Dimensionen (int In, int Out);
  void Setze_xDimension (int i);
  void Setze_yDimension (int i);

  friend Regel Regel_einlesen (FILE * File, int x, int y);

  void Berechne (DVektor & Eingabe, Regel_Ausgabe & Ausgabe);
  void Berechne (DVektor & Eingabe, BVektor & Diese_Eingaben,
		 BVektor & Diese_Ausgaben, Regel_Ausgabe & Ausgabe);

    Regel & operator = (Regel & Das);
  inline Parameter & operator[] (int i) {
    return (*Daten[i]);
  };
};

/**********************************************/
class Regelbasis
{
  Regel **Regeln;
  int Anzahl, xDim, yDim;
    public:
    Regelbasis (int Regelanzahl = 0, int xDimension = 0, int yDimension = 0);
   ~Regelbasis ();
  void print ();
  inline int Lese_Dimension () {
    return (xDim + yDim);
  };
  inline int Lese_xDimension () {
    return (xDim);
  };
  inline int Lese_yDimension () {
    return (yDim);
  };
  void Setze_xDimension (int i);
  void Setze_yDimension (int i);
  void Setze_Dimensionen (int In, int Out);

  inline char *Lese_Namen (int i) {
    return (Regeln[0]->Lese_Name (i));
  };

  void Setze_Regelanzahl (int Damit);
  inline int Lese_Regelanzahl () {
    return (Anzahl);
  };
  inline Regel & Lese_Regel (int Nummer) {
    return (*(Regeln[Nummer]));
  };

  void Speichern (char *Name);
  friend Regelbasis Regelbasis_einlesen (char *Name);

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

    Regelbasis & operator = (const Regelbasis & Das);
  void operator += (Regel & Diese);
  void operator += (Regelbasis & Das);
  inline Regel & operator[] (int i) {
    return (*(Regeln[i]));
  };

/* Ermitteln einfach die Regeln: */
  friend 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,