cluster.h

模糊聚类分析的源程序！

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

#include <math.h>
#include <stdio.h>
#include <values.h>

#define DEFAULT_M 	2.0
#define DEFAULT_K 	1.0
#define DEFAULT_DELTA_U	0.0001
#define DEFAULT_HUEGEL_GRENZE .05

enum Cluster_Typ {
  FCM, GK, GK_parallel, GG, GG_parallel
};
enum Art {
  KEINE, OPTIMAL, ANZAHL, KLASSEN
};

#define CLUSTER_KONVEXGRENZE 0.03
#define WINKEL_COSINUS .9848078	/* +- 10 Grad */
#define NAEHER_ERLAUBT 2
#define Namen_Laenge 20


class Clustering;
class FCM_Clustering;
class GK_Clustering;
class GK_parallel_Clustering;
class GG_Clustering;
class GG_parallel_Clustering;

#include "fehler.h"
#include "guete.h"
#include "matrix.h"
#include "vektor.h"
#include "norm.h"
#endif

#ifndef _CLUSTER_DATA
#define _CLUSTER_DATA

void Errechne_Covarianz (DVektorArray & Daten, DMatrix & U,
			 DMatrixArray & CMatrix, DVektorArray & Cluster,
			 double M);

class Clustering
{
  friend class FHV_Guete;
  friend class DPA_Guete;
  friend class PD_Guete;
    protected:
  char Name[Namen_Laenge];	/* Name des ClusterVerfahrens   */
  int Max_Iterationen;		/* Max-Anzahl der Iterationen   */
  int Iterationen;		/* Aktuelle Anzahl der Iterat.  */
  DVektorArray Vorgabe_Cluster;	/* Hier Vorgaben speichern      */
  DVektorArray Cluster;		/* Cluster-Zentren              */
  DVektorArray ClusterBuffer;	/* Bei Optimum-Suche alte sp.   */
  IVektor Zuordnung;		/* In welches Cl. gehoert Datum */
  IVektor Klassen;		/* Nummer der Klassen           */
  DMatrix Zugehoerigkeit;	/* Zugehoerigkeitsmatrix        */
  DMatrix UBuffer;		/* Bei Optimum-Suche alte sp.   */
  BVektor Die_sind_relevant;	/* welchen Dim's der Cluster    */
  BVektor Die_waren_relevant;	/* die nach angef. Clustern     */
  Guete *Guete_Verfahren;	/* Mein Guete_Verfahren         */
  double M, K;			/* Cluster-Parameter            */
  char Fertig, ClusterFertig;	/* Beides fertig ?              */
  enum Art Art;			/* Welche Clustermethode        */
  char Possibilistisch;		/* Nach Clustern noch poss.?    */
  int Possib_Zaehler;		/* i.d.R. werden's 2 Durchlaeufe */
  int zu_berechnen;		/* beim naechsten Durchlauf sov. */
  DVektor neuer_Proto;		/* Zum Zwischenspeichern des n. */
  DVektor eta;			/* fuer possibil. Nachclustern  */
  double Delta_U;		/* Veraenderungs-Grenze         */
  Norm Die_Norm;		/* Nicht immer wieder neu !!    */
    public:
    Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
		char Possib = FALSE);
    virtual ~ Clustering ();

  /* Die oben definierte Nummer */
  virtual Cluster_Typ Lese_Typ () = 0;
  char *Lese_Name () {
    return (Name);
  };
  /* Gibt es ueberhaupt noch etwas zu tun */
  char Ist_Fertig () {
    return (Fertig);
  };
  inline enum Art Lese_Art () {
    return (Art);
  };
  /* Soll es possibilistisch werden ?! */
  inline char Lese_Possib () {
    return (Possibilistisch);
  };
  inline void Setze_Possib (char So) {
    Possibilistisch = So;
  };
  inline Lese_Clusterdimension () {
    return (Die_waren_relevant.Lese_Dim ());
  };

  inline DVektorArray & Lese_Vorgabe_Prototypen () {
    return (Vorgabe_Cluster);
  };

  /* Eine der Guete Klassen auswaehlen: */
  void Setze_Guete (Guete_Typ Damit);
  /* Gueten auslesen: */
  inline Guete & Lese_Guete () {
    return (*Guete_Verfahren);
  };

  /* Setze die Indizes, die bei Uebergabe von Daten relevant sind: */
  void Setze_relevant (BVektor & Damit) {
    Die_sind_relevant = Damit;
  };
  inline BVektor & Lese_relevant () {
    return (Die_sind_relevant);
  };

  /* Wieviele Schritte, um naechsten Schritt ausgeben zu koennen */
  inline void Setze_Max_Iteration (int Damit) {
    Max_Iterationen = Damit;
  };
  inline int Lese_Max_Iteration () {
    return (Max_Iterationen);
  };

  /* Fuer die Cluster-Parameter: */
  inline void Setze_M (double Damit) {
    M = Damit;
  };
  inline double Lese_M () {
    return (M);
  };
  inline void Setze_K (double Damit) {
    K = Damit;
  };
  inline double Lese_K () {
    return (K);
  };
  inline void Setze_Delta_U (double Damit) {
    Delta_U = Damit;
  };
  inline double Lese_Delta_U () {
    return (Delta_U);
  };

  /* Setzt zurueck, was bisher geclustert wurden ist: */
  void Reset ();
  /* der einzige Weg, Cluster vorzugeben: */
  void Setze_Cluster (DVektorArray & Damit) {	/*Reset(); */
    Vorgabe_Cluster = Damit;
  };
  /* Findet Clusteranzahl-viele Cluster, stockt dabei evtl. die
     Vorgabe auf: */
  void Clustere (DVektorArray & Das, int Clusteranzahl);
  /* Findet Cluster in optimaler Anzahl, vorher sollte resetet 
     sein: */
  void Clustere (DVektorArray & Das);
  /* Findet Cluster in optimaler Anzahl aus klassif. Daten: */
  void Clustere_Klassen (DVektorArray & Das, int Fehlerprozent);
  /* Zu welchem Cluster gehoeren die Daten ?: */
  inline IVektor & Lese_Zuordnung () {
    return (Zuordnung);
  };
  inline int &Lese_Zuordnung (int i) {
    return (Zuordnung[i]);
  };

  /* Zum Auslesen der Ergebnisse */
  inline DVektor & Lese_Cluster (int Nummer) {
    return (Cluster[Nummer]);
  };
  inline DVektorArray & Lese_Cluster () {
    return (Cluster);
  };
  inline int Lese_Clusteranzahl () {
    return (Cluster.Lese_Groesse ());
  };
  inline DMatrix & Lese_Zugehoerigkeit () {
    return (Zugehoerigkeit);
  };
  virtual DMatrixArray Lese_Form (IVektor & Dimensionen,
				  DVektorArray & Daten) = 0;
  DVektor Berechne_Zugehoerigkeit (DVektor & Datum);
  void Speichern (char *Name);
  friend Clustering *Clustering_Laden (char *Name);
  virtual void Berechne_fuer_neue_Daten (DVektorArray & Diese_Daten);
    protected:
/******** NUR FUER MICH ************/
    virtual void Mein_Speichern (FILE * File) {
  };
  virtual int Mein_Laden (FILE * File) {
  };

  virtual DVektorArray Mein_Clustern (DVektorArray & Daten,
				      DVektorArray & Vorgabe_Protos) = 0;
  void Berechne_Zuordnung ();
  virtual int Berechne_Dist (DVektor & Dist, DVektor & Datum,
			     DVektorArray & Cluster) = 0;
  DVektorArray Berechne_v (DMatrix & MatrixU, DVektorArray & DieDaten);
  virtual void Berechne_U (DVektorArray & Daten,
			   DVektorArray & Cluster, DMatrix & U);
  virtual void Berechne_possib_U (DVektorArray & Daten,
				  DVektorArray & Cluster, DMatrix & U) = 0;
  virtual void Mache_Possibilistisch (DVektorArray & Das,
				      DVektorArray & Cluster) = 0;
  inline void Berechne_Covarianz (DVektorArray & Daten, DMatrix & U,
			   DMatrixArray & CMatrix, DVektorArray & Cluster) {
    Errechne_Covarianz (Daten, U, CMatrix, Cluster, M);
  };
  virtual DVektor Berechne_eta (DVektorArray & Daten,
				DVektorArray & Cluster, DMatrix & U);
  virtual void Berechne_Form (DVektorArray & Daten,
			      DVektorArray & Cluster) = 0;
  virtual void Speichere_Buffer ();
  virtual void Uebernehme_Buffer ();
  virtual void Tausche_Buffer ();
  virtual void Loesche_Buffer ();
};
Clustering *Clustering_Laden (char *Name);

/******************************************************************/
class FCM_Clustering: public Clustering
{
  protected:
  DVektor Radien;		/* Fuer die graphische Ausgabe  */
  public:
  FCM_Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
		  char Possib = FALSE);
  Cluster_Typ Lese_Typ ();
  DMatrixArray Lese_Form (IVektor & Dimensionen, DVektorArray & Daten);
    protected:
    DVektorArray Mein_Clustern (DVektorArray & Daten,
				DVektorArray & Vorgabe_Protos);
  int Berechne_Dist (DVektor & Dist, DVektor & Datum,
		     DVektorArray & Cluster);
  virtual void Berechne_possib_U (DVektorArray & Daten,
				  DVektorArray & Cluster, DMatrix & U);
  void Mache_Possibilistisch (DVektorArray & Das,
			      DVektorArray & Cluster);
  void Berechne_Form (DVektorArray & Daten,
		      DVektorArray & Cluster);
};

/******************************************************************/
class GK_Clustering: public Clustering
{
  protected:
  DVektor rho, rho_Buffer;	/* fuer GK                      */
  DMatrixArray Covar;		/* fuer nicht-parallel Ellipso. */
  DVektorArray Laengen;		/* fuer parallele Ellipsoide    */
  DMatrixArray AMatrizen;		/**/
  DMatrixArray  ABuffer;		/**/
  A_Norm Die_A_Norm;
    public:
    GK_Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
		   char Possib = FALSE);
   ~GK_Clustering ();
  Cluster_Typ Lese_Typ ();
  inline void Setze_rho (DVektor & Damit) {
    rho = Damit;
  };
  DMatrixArray Lese_Form (IVektor & Dimensionen, DVektorArray & Daten);
    protected:
    virtual void Mein_Speichern (FILE * File);
  virtual int Mein_Laden (FILE * File);

  DVektorArray Mein_Clustern (DVektorArray & Daten, DVektorArray & Vorgabe_Protos);
  int Berechne_Dist (DVektor & Dist, DVektor & Datum,
		     DVektorArray & Cluster);
  virtual void Berechne_possib_U (DVektorArray & Daten,
				  DVektorArray & Cluster, DMatrix & U);
  void Mache_Possibilistisch (DVektorArray & Das,
			      DVektorArray & Cluster);
  virtual void Berechne_Ai (DVektorArray & Daten, DMatrix & U,
			    DVektorArray & Cluster);
  DVektor Berechne_eta (DVektorArray & Daten,
			DVektorArray & Cluster, DMatrix & U);
  void parallel_Form_Berechnen (DVektorArray & Daten,
				DVektorArray & Cluster);
  DMatrixArray Lese_parallel_Form (IVektor & Dimensionen, DVektorArray & Daten);
  void Berechne_Form (DVektorArray & Daten,
		      DVektorArray & Cluster);
  void Speichere_Buffer ();
  void Uebernehme_Buffer ();
  void Tausche_Buffer ();
  void Loesche_Buffer ();
};

/******************************************************************/
class GK_parallel_Clustering: public GK_Clustering
{
  protected:
  public:
  GK_parallel_Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
			  char Possib = FALSE);
  Cluster_Typ Lese_Typ ();
  inline DMatrixArray Lese_Form (IVektor & Dimensionen, DVektorArray & Daten) {
    return (Lese_parallel_Form (Dimensionen, Daten));
  };
    protected:
  void Berechne_Form (DVektorArray & Daten,
		      DVektorArray & Cluster);
  void Berechne_Ai (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster);
};

/******************************************************************/
class GG_Clustering: public GK_Clustering
{
  protected:
  DVektor Faktor, Faktor_Buffer;
  DVektor p, p_Buffer;
    public:
    GG_Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
		   char Possib = FALSE);
  Cluster_Typ Lese_Typ ();
    protected:
    virtual void Mein_Speichern (FILE * File);
  virtual int Mein_Laden (FILE * File);

  DVektorArray Mein_Clustern (DVektorArray & Daten,
			      DVektorArray & Vorgabe_Protos);
  int Berechne_Dist (DVektor & Dist, DVektor & Datum,
		     DVektorArray & Cluster);
  virtual void Berechne_possib_U (DVektorArray & Daten,
				  DVektorArray & Cluster, DMatrix & U);
  void Mache_Possibilistisch (DVektorArray & Das,
			      DVektorArray & Cluster);
  DVektor Berechne_eta (DVektorArray & Daten,
			DVektorArray & Cluster, DMatrix & U);
  void Berechne_Ai (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster);
  void Berechne_p (DMatrix & U);
  void Speichere_Buffer ();
  void Uebernehme_Buffer ();
  void Loesche_Buffer ();
  void Tausche_Buffer ();
  virtual void Berechne_Faktor ();
};

/******************************************************************/
class GG_parallel_Clustering: public GG_Clustering
{
  protected:
  public:
  GG_parallel_Clustering (Guete_Typ Guete = S, int Soll_Iterationen = MAXINT,
			  char Possib = FALSE);
  Cluster_Typ Lese_Typ ();
  inline DMatrixArray Lese_Form (IVektor & Dimensionen, DVektorArray & Daten) {
    return (Lese_parallel_Form (Dimensionen, Daten));
  };
    protected:
  void Berechne_Form (DVektorArray & Daten,
		      DVektorArray & Cluster);
  void Berechne_Ai (DVektorArray & Daten, DMatrix & U,
		    DVektorArray & Cluster);
  void Berechne_Faktor ();
};

#endif