vektor.h

模糊聚类分析的源程序！

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

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

class BVektor;
class IVektor;
class DVektor;
class IVektorArray;
class DVektorArray;

#include "fehler.h"
#include "matrix.h"
#endif

#ifndef _VEKTOR_DATA
#define _VEKTOR_DATA

class BVektor
{
  int n;			/* soviele Bits                 */
  int gesetzt;			/* soviel sind auf 1 gesetzt    */
  char *Daten;			/* Die Daten natuerlich         */
  int *gesetzte;		/* sortierte Indizes, die gesetzt sind */
    public:
    BVektor (int Groesse = 0, char *Inhalt = NULL);
    BVektor (const BVektor & Das);
   ~BVektor ();
  void print ();

  void Setze_Dim (int Damit);
  inline int Lese_Dim () const {
    return (n);
  };
  void Setze_i (int Pos, char x);
  char Lese_i (int Pos);
  inline int Anzahl_gesetzt () {
    return (gesetzt);
  };
  inline Lese_gesetzte (int i) {
    return (gesetzte[i]);
  };

  void Speichern (FILE * File);
  int Laden (FILE * File);

  BVektor concat (BVektor & Dahinter);
  BVektor operator & (BVektor & A);
  void operator = (const BVektor & Das);
  void operator = (char Damit);
  char operator[] (int i) {
    return ((TRUE) && ((Daten[(i / 8)]) & (1 << (i % 8))));
  };
};


class IVektor
{
  int n;			/* soviele Daten        */
  int *Daten;			/* Die Daten            */
/********************/
    public:
    IVektor (int Groesse = 0, int *Inhalt = NULL);
    IVektor (const IVektor & Das);
   ~IVektor ();
  void print ();
  void Setze_Dim (int Damit);
  inline int Lese_Dim () const {
    return (n);
  };

  char Ist_drinnen (int Das);
  int Lese_Index (int Davon);
  double Vektorlaenge ();
  void Tausche (int den, int mitdem);
  IVektor Projiziere (BVektor & Diese);
  IVektor Projiziere (IVektor & Diese);
  IVektor Projiziere (int ab);
  void Setze_i (int Pos, int x) {
    Daten[Pos] = x;
  };
  inline int &Lese_i (int Pos) {
    return (Daten[Pos]);
  };

  void Speichern (FILE * File);
  int Laden (FILE * File);

  void Tausche (IVektor & Damit);

  void Plus_Sortiert (int Das);
  void operator = (const IVektor & Das);
  void operator = (int Das);
  int operator *(IVektor & Damit);
  void operator -= (IVektor & Minus);
  void operator += (IVektor & Plus);
  void operator += (int Das);
  IVektor operator - (IVektor & Das);
  inline int &operator[] (int i) {
    return (Daten[i]);
  };
};

class DVektor
{
  int n;			/* soviele Daten                */
  double *Daten;		/* Die Daten                    */
  int Nummer;			/* Nummer fuer den Vektor       */
    public:
    DVektor (int Groesse = 0, int Nr = 0, double *Inhalt = NULL);
   ~DVektor ();
    DVektor (const DVektor & Daraus);

  void print ();
  inline int Lese_Dim () const {
    return (n);
  };

  double Vektorlaenge ();
  inline void Setze_Nummer (int i) {
    Nummer = i;
  };
  inline int &Lese_Nummer () {
    return (Nummer);
  };
  void Setze_Dim (int Damit);
  void NullVektor ();
  inline double *Lese_Daten () {
    return (Daten);
  };

  void Speichern (FILE * File);
  int Laden (FILE * File);

  DVektor Deprojiziere (BVektor & Diese);
  DVektor Projiziere (BVektor & Diese);
  DVektor Projiziere (IVektor & Diese);
  DVektor Projiziere (int ab);
  DVektor Projiziere (int ab, int bis);

  void VektorT_Mult (DVektor & Dieser, DMatrix & Damit);
  DVektor x (DVektor & B);
  DMatrix Produkt (DVektor & B);	/* this * B~T */
  DMatrix Produkt ();		/* this * this~T */

  void Normiere ();
  double Abstand (DVektor & Davon);
  double Abstand (DVektor & Davon, BVektor & relevant);
  double cos_Winkel (DVektor & Dazu);

  inline void Setze_i (int Pos, double x) {
    Daten[Pos] = x;
  };
  inline double &Lese_i (int Pos) {
    return (Daten[Pos]);
  };

  inline void Quicksort (IVektor & Indizes) {
    Quicksort (0, n - 1, Indizes);
  };
  void Quicksort (int a, int b, IVektor & Indizes);
  void Quicksort (int a, int b, int Index);	/* nur fuer DVektor* */

  void Tausche (DVektor & Damit);

  double operator () (double x);
  void operator = (const DVektor & A);
  void operator = (double Das);
  char operator == (DVektor & Der);
  char operator != (DVektor & Der);
  void operator *= (double Damit);
  void operator += (DVektor & Plus);
  void operator -= (DVektor & Minus);
  void operator <<= (int soviel);
  void operator >>= (int soviel);
  DVektor operator *(DMatrix & Die);
  double operator *(DVektor & Das);
  DVektor operator *(double Skalar);
  void operator /= (double Divisor);
  DVektor operator + (DVektor & Das);
  DVektor operator - (DVektor & Das);
  inline double &operator[] (int i) const {
    return (Daten[i]);
  };
};

class BVektorArray
{
  int Groesse;			/* soviele IVektoren            */
  int VektorDimension;		/* Vektordimension halt         */
  BVektor **Daten;		/* Zeiger-Array auf BVektoren   */
    public:
    BVektorArray (int VektorDim = 0, int ArrayGroesse = 0,
		  BVektor * Diese = NULL);
    BVektorArray (const BVektorArray & Daraus);
   ~BVektorArray ();

  void print ();
  inline int Lese_Groesse () {
    return (Groesse);
  };
  void Setze_Groesse (int Damit);
  inline int Lese_Dim () {
    return (VektorDimension);
  } void Setze_Dim (int Damit);
  void Loesche (int von, int bis);

  void operator = (const BVektorArray & Das);
  void operator = (char Das);
  void operator += (BVektor & Damit);
  void operator -= (BVektor & Den);
    BVektorArray & operator++ (int);	/* noch einen neuen ungesetzen Vektor dazu */
  inline BVektor & operator[] (int i) {
    return (*Daten[i]);
  };
};

class IVektorArray
{
  int Groesse;			/* soviele IVektoren            */
  int VektorDimension;		/* Vektordimension halt         */
  IVektor **Daten;		/* Zeiger-Array auf IVektoren   */
    public:
    IVektorArray (int VektorDim = 0, int ArrayGroesse = 0,
		  IVektor * Diese = NULL);
    IVektorArray (const IVektorArray & Daraus);
   ~IVektorArray ();

  inline int Lese_Groesse () {
    return (Groesse);
  };
  void Setze_Groesse (int Damit);
  inline int Lese_Dim () {
    return (VektorDimension);
  } void Setze_Dim (int Damit);

  char Ist_vorhanden (IVektor & Soeiner);
  inline IVektor & Lese_Vektor (int Nummer) {
    return (*(Daten[Nummer]));
  };
  inline int &Lese_Vektor (int Nummer, int i)
#if 0
  {
    return (Daten[Nummer].Lese_i (i));
  };
#else
  {
    return (Daten[Nummer]->Lese_i (i));
  };
#endif
  inline void Setze_Vektor (int i, IVektor & Damit) {
    (*Daten[i]) = Damit;
  };
  inline void Setze_Vektor (int Vektor, int Index, int x) {
    Daten[Vektor]->Setze_i (Index, x);
  };

  void operator = (const IVektorArray & Das);
  void operator += (IVektor & Damit);
  void operator -= (IVektor & Den);
  inline IVektor & operator[] (int i) {
    return (*Daten[i]);
  };
};

class DVektorArray
{
  int Groesse;			/* Soviele DVektoren            */
  int VektorDimension;		/* Die Dimension der Vektoren   */
  DVektor **Daten;		/* Zeiger-Array auf DVektoren   */
  DVektor Durchschnitt;		/* Durchschnitt in jeder Dim    */
  DVektor Min, Max;		/* Max-Min-Werte "   "    "     */
  IVektor MinNummer, MaxNummer;	/* Index der Max-Min-Werte      */
    public:
    DVektorArray (int VektorDim = 0, int ArrayGroesse = 0,
		  DVektor * Diese = NULL);
    DVektorArray (const DVektorArray & Daraus);
   ~DVektorArray ();

  void print ();
  void print (int Anfang, int Ende);
  inline void Setze_Nummer (int i, int Nummer) {
    Daten[i]->Setze_Nummer (Nummer);
  };
  inline int Lese_Nummer (int i) {
    return (Daten[i]->Lese_Nummer ());
  };
  inline int Lese_Groesse () {
    return (Groesse);
  };
  void Setze_Groesse (int Damit);
  inline int Lese_Dim () {
    return (VektorDimension);
  } void Setze_Dim (int Damit);

  DVektor Zufallsvektor ();
  void NullVektor ();

  int Lese_Index (DVektor & Der);

  void Speichern (FILE * File);
  int Laden (FILE * File);

  DVektorArray Deprojiziere (BVektor & Diese);
  DVektorArray Projiziere (BVektor & Diese);
  DVektorArray Projiziere (IVektor & Diese);
  DVektorArray Projiziere (int ab);
  DVektorArray Projiziere (int ab, int bis);
  DVektor Projiziere (int Diesen, int ab, int bis) {
    Daten[Diesen]->Projiziere (ab, bis);
  };

  inline DVektor & Lese_Vektor (int Nummer) {
    return (*(Daten[Nummer]));
  };
  inline double &Lese_Vektor (int Nummer, int i)
#if 0
  {
    return (Daten[Nummer].Lese_i (i));
  };
#else
  {
    return (Daten[Nummer]->Lese_i (i));
  };
#endif
  void Setze_Vektor (int i, DVektor & Damit);
  void Setze_Vektor (int i, double *Damit);
  void Setze_Vektor (int Vektor, int Index, double x);
  void Aktualisiere_Min_etc ();

  inline double &Lese_Max (int i) {
    return (Max.Lese_i (i));
  };
  inline double &Lese_Min (int i) {
    return (Min.Lese_i (i));
  };
  inline DVektor & Lese_Max () {
    return (Max);
  };
  inline DVektor & Lese_Min () {
    return (Min);
  };
  inline int &Lese_MaxNummer (int i) {
    return (MaxNummer.Lese_i (i));
  };
  inline int &Lese_MinNummer (int i) {
    return (MinNummer.Lese_i (i));
  };
  inline IVektor & Lese_MaxNummer () {
    return (MaxNummer);
  };
  inline IVektor & Lese_MinNummer () {
    return (MinNummer);
  };

  inline DVektor & Lese_Durchschnitt () {
    return (Durchschnitt);
  };
  inline double Lese_Durchschnitt (int i) {
    return (Durchschnitt.Lese_i (i));
  };

  DVektorArray Quicksort (int Index);

  void Tausche (DVektorArray & Damit);

  void neuer_Zufallspunkt ();

  DVektorArray Mache_Konvex (int Index, double Untergrenze);
  DVektorArray Mache_Konvex ();
  /* gibt die Indizes der Huegel zurueck, wenn ueber alle Dimensionen */
  /* auf einmal gesucht wird: */
  IVektor *Finde_Huegel (DVektor & Y, int &soviele,
			 double Huegel_Grenze,
			 int Naeher_erlaubt,
			 double Winkel_Cosinus);
  IVektor *Finde_Huegel (DVektor & Y, int &soviele,
			 double Huegel_Grenze,
			 int Naeher_erlaubt);


  void operator = (const DVektorArray & Das);
  void operator += (const DVektor & Damit);
  void operator -= (DVektor & Damit);
  inline DVektor & operator[] (int i) {
    return (*Daten[i]);
  };
    protected:
  void Quicksort (int a, int b, int Index);
};

#endif