matrix.h

模糊聚类分析的源程序！

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

class DMatrix;
class DMatrixArray;

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "fehler.h"
#include "vektor.h"
#endif

#ifndef _MATRIX_DATA
#define _MATRIX_DATA

const int MAXIT = 50;
const int ITERATIONEN = 10;
const int KORITER = 10;
const double BASIS = 2.0;
const double MACH_EPS = 2.20446049250313e-016;
class DMatrix
{
  friend DMatrixArray;
    protected:
  int m, n;			/* Hoehe, Breite der Matrix     */
  double *Daten;		/* Zeilenweise Daten            */
    public:
    DMatrix (int mDim = 0, int nDim = 0, double *Inhalt = NULL);
    DMatrix (const DMatrix & Daraus);
   ~DMatrix ();

  void print ();
  void Setze_Dim (int Neues_m, int Neues_n);
  inline int Lese_Dim_m () {
    return (m);
  };
  inline int Lese_Dim_n () {
    return (n);
  };

  void Einheitsmatrix (int Groesse);
  void Einheitsmatrix ();
  void NullMatrix ();
  DMatrix Projiziere (BVektor & Diese);
  DMatrix Projiziere (IVektor & Diese);
  DMatrix Deprojiziere (BVektor & Diese);
  DMatrix Gauss_Inverse ();
  double Determinante ();
  double Zeilensumme (int i);
  void Tausche_Zeilen (int x, int y);
  void Tausche_Spalten (int x, int y);
  void Zeile_Multiplizieren (int Zeile, double Damit);
  void Spalte_Multiplizieren (int Spalte, double Damit);
  void Zeile_plus_Zeile (int Diese, int plusDiese, double Faktor);
  DVektor Spalte_aus_Matrix (int i);
  DVektor Zeile_aus_Matrix (int i);
  void Setze_Spalte (int Die, DVektor & Damit);

  inline double &Lese_i_j (int i, int j) {
    return (Daten[i * n + j]);
  };
  void Setze_i_j (int i, int j, double Das) {
    Daten[i * n + j] = Das;
  };
  void Addiere_i_j (int i, int j, double Das) {
    Daten[i * n + j] += Das;
  };

  DVektorArray Eigenvektoren ();
  DVektorArray Eigenvektoren (IVektor & cnt);
  DMatrix Eigenmatrix ();
  DMatrix Eigenmatrix (IVektor & cnt);

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

  void Quicksort (int a, int b, int Index);

  void Tausche (DMatrix & Damit);

    DMatrix & operator = (const DMatrix & Das);
  void operator += (const DMatrix & Das);
  void operator *= (double Das);
  void operator /= (double Das);
  char operator == (double Das);
  char operator == (DMatrix & Das);
  DMatrix operator + (DMatrix & Das);
  DMatrix operator - (DMatrix & Das);
  DVektor operator *(DVektor & Das);
  DMatrix operator *(DMatrix & Das);
  inline double *operator[] (int Zeile) {
    return (&(Daten[n * Zeile]));
  };

  /* Rotationen: */
  friend DMatrix d2_Rot (double alpha);
  friend DMatrix d3_xRot (double alpha);
  friend DMatrix d3_yRot (double alpha);
  friend DMatrix d3_zRot (double alpha);

    protected:
  char Balance (DVektor & Skal, int &low, int &high);
  char Elmhes (int low, int high, IVektor & perm);
  void Elmtrans (int low, int high, IVektor & perm, DMatrix & Result);
  char Hqr2 (int low, int high, DVektor & wr, DVektor & wi,
	     DMatrix & eivec, IVektor & cnt);
  char Hqrvec (int low, int high, DVektor & wr, DVektor & wi,
	       DMatrix & eivec);
  void Balback (int low, int high, DVektor & skal);
  void Norm_1 (DVektor & wi);
};

DMatrix d2_Rot (double alpha);
DMatrix d3_xRot (double alpha);
DMatrix d3_yRot (double alpha);
DMatrix d3_zRot (double alpha);

class DMatrixArray
{
  int m, n;			/* Hoehe,Breite der Matrizen    */
  int Groesse;			/* Soviele Matrizen             */
  DMatrix **Daten;		/* Zeiger-Array auf DMatrizen   */
    public:
    DMatrixArray (int ArrayGroesse = 0, int mDim = 0, int nDim = 0, DMatrix * Inhalt = NULL);
    DMatrixArray (const DMatrixArray & Daraus);
   ~DMatrixArray ();

  void print ();

  void Setze_Groesse (int Neue_Groesse);
  void Setze_Dim (int Neues_m, int Neues_n);
  void Setze_Groesse_Dim (int Neue_Groesse, int Neues_m, int Neues_n);
  inline int Lese_Dim_m () {
    return (m);
  };
  inline int Lese_Dim_n () {
    return (n);
  };
  inline int Lese_Groesse () {
    return (Groesse);
  };

  void NullMatrix ();
  DMatrixArray Projiziere (BVektor & Diese);
  DMatrixArray Projiziere (IVektor & Diese);
  DMatrixArray Deprojiziere (BVektor & Diese);
  inline DMatrix *Lese_Matrix_Pointer (int Nummer) {
    return (Daten[Nummer]);
  };
  void Setze_Matrix (int Nummer, DMatrix & Damit);
  inline void Setze_i_j (int Nummer, int i, int j, double Damit) {
    Daten[Nummer]->Setze_i_j (i, j, Damit);
  };
  inline double &Lese_i_j (int Nummer, int i, int j) {
    return (Daten[Nummer]->Lese_i_j (i, j));
  };

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

  void Tausche (DMatrixArray & Damit);

  void operator = (const DMatrixArray & Das);
  void operator += (DMatrix & Die);
  inline DMatrix & operator[] (int i) {
    return (*Daten[i]);
  };
};

void swap (double &a, double &b);

#endif