guete.h

模糊聚类分析的源程序！

/********************************************************/
/*   filename: guete.h                                  */
/*                                                      */
/********************************************************/
/* programmed by: Oliver Wagner                         */
/* last change:  (XXX: not updated)                     */
/********************************************************/

#ifndef _GUETE_H
#define _GUETE_H

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


enum Guete_Typ {
  NONE, S, PK, CS, D1, FHV, DPA, PD, CLASSIFY
};

class Guete;
class S_Guete;
class PK_Guete;
class CS_Guete;
class D1_Guete;
class FHV_Guete;
class DPA_Guete;
class PD_Guete;

#include "fehler.h"
#include "matrix.h"
#include "vektor.h"
#include "norm.h"
#include "cluster.h"


class Guete
{
  protected:
    Norm DieNorm;
    /* Soviele Cluster waren das: */
    int *Anzahlen;
    /* Das war der Wert der Guete: */
    double *Werte;
    /* Groesse der obigen Arrays: */
    int getestete;
    /* Die geeignetste Anzahl von Clustern: */
    int Bestes_bisher;
    /* Masze z.B. fuer das Zeichnen: */
    double Min_Wert, Max_Wert;
    /* Zeiger auf das Clusterobjekt, um deren Funkt. zu nutzen */
  public:
    Guete ();
    virtual ~Guete ();
    void Reset ();
    virtual Guete_Typ Lese_Typ () = 0;
    virtual void Berechne (DVektorArray & Daten, DMatrix & U,
			   DVektorArray & Cluster, double M) = 0;
    inline int Lese_Min_Anzahl () {
	return (Anzahlen[0]);
    }
    inline int Lese_Max_Anzahl () {
	return (Anzahlen[getestete - 1]);
    }
    inline double Lese_Min_Wert () {
	return (Min_Wert);
    }
    inline double Lese_Max_Wert () {
	return (Max_Wert);
    }
    inline int Lese_Bestes () {
	return (Bestes_bisher);
    }
    inline int Lese_getestet () {
	return (getestete);
    }
    inline int Lese_Anzahl (int i) {
	return (Anzahlen[i]);
    }
    inline double Lese_Werte (int i) {
	return (Werte[i]);
    }
    void Speichern (FILE * File);
    int Laden (FILE * File);
  protected:
    void Setze (int Anzahl, double Wert);
    virtual void Finde_Bestes () = 0;
};

class Min_Guete:public Guete
{
  void Finde_Bestes ();
};

class Max_Guete:public Guete
{
  void Finde_Bestes ();
};

class S_Guete:public Min_Guete
{
  public:
  S_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class CS_Guete:public Min_Guete
{
  public:
  CS_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class FHV_Guete:public Min_Guete
{
  public:
  FHV_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class PK_Guete:public Max_Guete
{
  public:
  PK_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class D1_Guete:public Max_Guete
{
  public:
  D1_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class DPA_Guete:public Max_Guete
{
  public:
  DPA_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

class PD_Guete:public Max_Guete
{
  public:
  PD_Guete ();
  Guete_Typ Lese_Typ ();
  void Berechne (DVektorArray & Daten, DMatrix & U,
		 DVektorArray & Cluster, double M);
};

#endif /* _GUETE_H */