matrix.cc

模糊聚类分析的源程序！

	for (r = 0; r < n; r++) {
	  DBuffer = Lese_i_j (i, r);
	  Setze_i_j (i, r, Lese_i_j (j, r));
	  Setze_i_j (j, r, DBuffer);
	}
	i++;
	j--;
      }
    } while (j >= i);
    Quicksort (a, j, Index);
    Quicksort (i, b, Index);
  }
};

void 
DMatrix::Tausche (DMatrix & Damit)
{
  double *dBuffer;
  int i;

  dBuffer = Damit.Daten;
  Damit.Daten = Daten;
  Daten = dBuffer;
  i = Damit.m;
  Damit.m = m;
  m = i;
  i = Damit.n;
  Damit.n = n;
  n = i;
};

DMatrix & DMatrix::operator = (const DMatrix & Das) {
  int i;

  if ((Das.n != n) || (Das.m != m)) {
    if ((n != 0) && (m != 0))
      free (Daten);
    m = Das.m;
    n = Das.n;
    if ((Daten = (double *) malloc (sizeof (double) * m * n)) == NULL)
        Fehlermeldung ("DMatrix::operator=(DMatrix& Das)", SPEICHERFEHLER);
  }
  for (i = 0; i < m * n; i++)
    Daten[i] = Das.Daten[i];
};

void 
DMatrix::operator+= (const DMatrix & Das)
{
  int i;

  for (i = 0; i < (m * n); i++)
    Daten[i] = Daten[i] + Das.Daten[i];
};

void 
DMatrix::operator*= (double Das)
{
  int i;

  for (i = 0; i < m * n; i++)
    Daten[i] *= Das;
};

void 
DMatrix::operator/= (double Das)
{
  int i;

  for (i = 0; i < m * n; i++)
    Daten[i] /= Das;
};

char 
DMatrix::operator== (double Das)
{
  int i;

  for (i = 0; i < m * n; i++)
    if (Daten[i] != Das)
      return (FALSE);
  return (TRUE);
};

char 
DMatrix::operator== (DMatrix & Das)
{
  int i;

  if ((n == Das.n) && (m == Das.m)) {
    for (i = 0; i < m * n; i++)
      if (Daten[i] != Das.Daten[i])
	return (FALSE);
    return (TRUE);
  }
  return (FALSE);
};


DMatrix 
DMatrix::operator+ (DMatrix & Das)
return Result (m, n, NULL);
{
  int i;

  for (i = 0; i < (m * n); i++)
    Result.Daten[i] = Daten[i] + Das.Daten[i];
};

DMatrix 
DMatrix::operator- (DMatrix & Das)
return Result (m, n, NULL);
{
  int i;

  for (i = 0; i < (m * n); i++)
    Result.Daten[i] = Daten[i] - Das.Daten[i];
};

DMatrix 
DMatrix::operator* (DMatrix & Das)
return Result (m, Das.n, NULL);
{
  int Spalte, Zeile, i, dort = 0;
  double Buf;

  for (Zeile = 0; Zeile < m; Zeile++)
    for (Spalte = 0; Spalte < Das.n; Spalte++) {
      Buf = 0;
      for (i = 0; i < n; i++)
	Buf += Lese_i_j (Zeile, i) * Das.Lese_i_j (i, Spalte);
      Result.Daten[dort++] = Buf;
    }
};

DVektor 
DMatrix::operator* (DVektor & Das)
return Result (m, 0, NULL);
{
  int i, j;
  double Buffer;

  for (i = 0; i < m; i++) {
    Buffer = 0;
    for (j = 0; j < n; j++)
      Buffer += Lese_i_j (i, j) * Das.Lese_i (j);
    Result.Setze_i (i, Buffer);
  }
};

DMatrix 
d2_Rot (double alpha)
  return Result (2, 2, NULL);
{
  Result[0][0] = cos (alpha);
  Result[0][1] = -sin (alpha);
  Result[1][1] = sin (alpha);
  Result[1][1] = cos (alpha);
};

DMatrix 
d3_xRot (double alpha)
return Result (3, 3, NULL);
{
  Result[0][0] = 1;
  Result[0][1] = 0;
  Result[0][2] = 0;
  Result[1][0] = 0;
  Result[1][1] = cos (alpha);
  Result[1][2] = -sin (alpha);
  Result[2][0] = 0;
  Result[2][1] = sin (alpha);
  Result[2][2] = cos (alpha);
};

DMatrix 
d3_yRot (double alpha)
return Result (3, 3, NULL);
{
  Result[0][0] = cos (alpha);
  Result[0][1] = 0;
  Result[0][2] = sin (alpha);
  Result[1][0] = 0;
  Result[1][1] = 1;
  Result[1][2] = 0;
  Result[2][0] = -sin (alpha);
  Result[2][1] = 0;
  Result[2][2] = cos (alpha);
};

DMatrix 
d3_zRot (double alpha)
return Result (3, 3, NULL);
{
  Result[0][0] = cos (alpha);
  Result[0][1] = -sin (alpha);
  Result[0][2] = 0;
  Result[1][0] = sin (alpha);
  Result[1][1] = cos (alpha);
  Result[1][2] = 0;
  Result[2][0] = 0;
  Result[2][1] = 0;
  Result[2][2] = 1;
};

/****************************************************************/
/*              Alles zur Klasse Matrix Array                   */
/****************************************************************/
DMatrixArray::DMatrixArray (int ArrayGroesse, int mDim, int nDim,
	      DMatrix * Inhalt)
{
  int i;

  Groesse = ArrayGroesse;
  m = mDim;
  n = nDim;
  if (Groesse != 0) {
    if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Groesse)) == NULL)
      Fehlermeldung ("DMatrixArray:DMatrixArray()", SPEICHERFEHLER);
    if (Inhalt != NULL) {
      for (i = 0; i < Groesse; i++)
	Daten[i] = new DMatrix (Inhalt[i]);
    } else {
      for (i = 0; i < Groesse; i++)
	Daten[i] = new DMatrix (m, n, NULL);
    }
  } else
    Daten = NULL;
};

DMatrixArray::DMatrixArray (const DMatrixArray & Daraus)
{
  int i;

  Groesse = Daraus.Groesse;
  m = Daraus.m;
  n = Daraus.n;
  if (Groesse != 0) {
    if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Groesse)) == NULL)
      Fehlermeldung ("DMatrixArray:DMatrixArray(const DMatrixArray& Daraus)", SPEICHERFEHLER);

    for (i = 0; i < Groesse; i++)
      Daten[i] = new DMatrix (*(Daraus.Daten[i]));
  } else
    Daten = NULL;
};

DMatrixArray::~DMatrixArray ()
{
  int i;

  for (i = 0; i < Groesse; i++)
    delete Daten[i];
  m = n = Groesse = 0;
  free (Daten);
  Daten = NULL;
};

void 
DMatrixArray::print ()
{
  int i;

  for (i = 0; i < Groesse; i++)
    Daten[i]->print ();
};

void 
DMatrixArray::Setze_Groesse (int Neue_Groesse)
{
  int i;
  DMatrix **Buffer;

  if (Neue_Groesse != Groesse) {
    for (i = Neue_Groesse; i < Groesse; i++)
      delete Daten[i];		/* Ueberfl"ussige L"oschen */
    Buffer = Daten;
    if (Neue_Groesse != 0) {
      if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Neue_Groesse)) == NULL)
	Fehlermeldung ("DMatrixArray:Setze_Groesse()", SPEICHERFEHLER);
      for (i = 0; (i < Groesse) && (i < Neue_Groesse); i++) {	/* Alte "ubernehmen */
	Daten[i] = Buffer[i];
#if 0
	Daten[i].NullMatrix ();
#else
	Daten[i]->NullMatrix ();
#endif
      }
      for (; i < Neue_Groesse; i++)
	Daten[i] = new DMatrix (m, n, NULL);
    } else
      Daten = NULL;
    Groesse = Neue_Groesse;
    free (Buffer);
  }
};

void 
DMatrixArray::Setze_Dim (int Neues_m, int Neues_n)
{
  int i;

  if ((m != Neues_m) || (n != Neues_n)) {
    m = Neues_m;
    n = Neues_n;
    for (i = 0; i < Groesse; i++)
      Daten[i]->Setze_Dim (Neues_m, Neues_n);
  }
};

void 
DMatrixArray::Setze_Groesse_Dim (int Neue_Groesse,
				 int Neues_m, int Neues_n)
{
  int i;
  DMatrix **Buffer;

  if (Neue_Groesse != Groesse) {
    for (i = Neue_Groesse; i < Groesse; i++)
      delete Daten[i];		/* Ueberfl"ussige L"oschen */
    Buffer = Daten;
    if (Neue_Groesse != 0) {
      if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Neue_Groesse)) == NULL)
	Fehlermeldung ("DMatrixArray:Setze_Groesse_Dim()", SPEICHERFEHLER);
      for (i = 0; (i < Groesse) && (i < Neue_Groesse); i++) {	/* Alte "ubernehmen */
	Daten[i] = Buffer[i];
	Daten[i]->Setze_Dim (Neues_m, Neues_n);
      }
      for (; i < Neue_Groesse; i++)
	Daten[i] = new DMatrix (Neues_m, Neues_n, NULL);
    } else
      Daten = NULL;
    Groesse = Neue_Groesse;
    m = Neues_m;
    n = Neues_n;
    free (Buffer);
  }
};

void 
DMatrixArray::NullMatrix ()
{
  int i;

  for (i = 0; i < Groesse; i++)
    Daten[i]->NullMatrix ();
};

DMatrixArray 
DMatrixArray::Projiziere (BVektor & Diese)
return Result (Groesse, Diese.Anzahl_gesetzt (), Diese.Anzahl_gesetzt (), NULL);
{
  int i;
  for (i = 0; i < Groesse; i++)
    Result[i] = Daten[i]->Projiziere (Diese);
};

DMatrixArray 
DMatrixArray::Projiziere (IVektor & Diese)
return Result (Groesse, Diese.Lese_Dim (), Diese.Lese_Dim (), NULL);
{
  int i;
  for (i = 0; i < Groesse; i++)
    Result[i] = Daten[i]->Projiziere (Diese);
};

DMatrixArray 
DMatrixArray::Deprojiziere (BVektor & Diese)
return Result (Groesse, Diese.Anzahl_gesetzt (), Diese.Anzahl_gesetzt (), NULL);
{
  int i;
  for (i = 0; i < Groesse; i++)
    Result[i] = Daten[i]->Deprojiziere (Diese);
};

void 
DMatrixArray::Setze_Matrix (int Nummer, DMatrix & Damit)
{
  if ((Nummer >= Groesse) || (Damit.Lese_Dim_m () != m) || (Damit.Lese_Dim_n () != n))
    Fehlermeldung ("DMatrixArray::Setze_Matrix(int Nummer, DMatrix& Damit)", DIMFEHLER);
  else
    (*(Daten[Nummer])) = Damit;
};

void 
DMatrixArray::Speichern (FILE * File)
{
  int i;

  fprintf (File, "%d %d %d\n", Groesse, m, n);
  for (i = 0; i < Groesse; i++)
    Daten[i]->Speichern (File);
};

int 
DMatrixArray::Laden (FILE * File)
{
  int i, j, k;

  if (!(fscanf (File, "%d %d %d", &i, &j, &k))) {
#if 0
    this. ~ DMatrixArray ();
#endif
    return (0);
  }
  Setze_Groesse_Dim (i, j, k);
  for (i = 0; i < Groesse; i++) {
    if (!(Daten[i]->Laden (File))) {
#if 0
      this. ~ DMatrixArray ();
#endif
      return (0);
    }
  }
  return (1);
};

void 
DMatrixArray::Tausche (DMatrixArray & Damit)
{
  DMatrix **dBuffer;
  int i;

  dBuffer = Damit.Daten;
  Damit.Daten = Daten;
  Daten = dBuffer;
  i = Damit.m;
  Damit.m = m;
  m = i;
  i = Damit.n;
  Damit.n = n;
  n = i;
  i = Damit.Groesse;
  Damit.Groesse = Groesse;
  Groesse = i;
};

void 
DMatrixArray::operator= (const DMatrixArray & Das)
{
  int i;

  if (Das.Groesse != Groesse) {
    for (i = 0; i < Groesse; i++)
      delete Daten[i];
    free (Daten);
    if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Das.Groesse)) == NULL)
      Fehlermeldung ("DMatrixArray::operator=()", SPEICHERFEHLER);
    for (i = 0; i < Das.Groesse; i++)
      Daten[i] = new DMatrix (*(Das.Daten[i]));
  } else {
    for (i = 0; i < Das.Groesse; i++)
      (*(Daten[i])) = (*(Das.Daten[i]));
  }
  Groesse = Das.Groesse;
  m = Das.m;
  n = Das.n;
};

void 
DMatrixArray::operator+= (DMatrix & Das)
{
  DMatrix **Buffer;
  int i;

  Buffer = Daten;
  if ((Daten = (DMatrix **) malloc (sizeof (DMatrix *) * Groesse + 1)) == NULL)
    Fehlermeldung ("DMatrixArray::operator+=()", SPEICHERFEHLER);

  for (i = 0; i < Groesse; i++)
    Daten[i] = Buffer[i];
  (*(Daten[Groesse])) = Das;
  Groesse = Groesse + 1;

  free (Buffer);
};

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

  Buffer = a;
  a = b;
  b = Buffer;
}