vektor.cc

模糊聚类分析的源程序！

/********************************************************/
/*   filename: vektor.cc                                */
/*                                                      */
/********************************************************/
/* programmed by: Oliver Wagner                         */
/* last change: 26-04-95                                */
/********************************************************/
#include "vektor.h"

/********************************************************/
/*              Alles zur Klasse BVektor                */
/********************************************************/

BVektor::BVektor (int Groesse, char *Inhalt)
{
  int i;

  n = Groesse;
  gesetzt = 0;
  if (n != 0) {
    if ((Daten = (char *) malloc (sizeof (char) * ((n / 8) + 1))) == NULL)
        Fehlermeldung ("BVektor::BVektor()", SPEICHERFEHLER);
    if ((gesetzte = (int *) malloc (sizeof (int) * n)) == NULL)
        Fehlermeldung ("BVektor::BVektor()", SPEICHERFEHLER);

    if (Inhalt != NULL)
      for (i = 0; (i < n) && (Inhalt != NULL); i++)
	Setze_i (i, Inhalt[i]);
    else
      for (i = 0; i < ((n / 8) + 1); i++)
	Daten[i] = 0;
  } else {
    Daten = NULL;
    gesetzte = 0;
  }
};

BVektor::BVektor (const BVektor & Das)
{
  int i;

  n = Das.n;
  gesetzt = Das.gesetzt;

  if (n != 0) {
    if ((Daten = (char *) malloc (sizeof (char) * ((n / 8) + 1))) == NULL)
        Fehlermeldung ("BVektor::BVektor(const BVektor& Das)", SPEICHERFEHLER);
    if ((gesetzte = (int *) malloc (sizeof (int) * n)) == NULL)
        Fehlermeldung ("BVektor::BVektor(const BVektor& Das)", SPEICHERFEHLER);
    for (i = 0; i < (n / 8) + 1; i++) {
      Daten[i] = Das.Daten[i];
      gesetzte[i] = Das.gesetzte[i];
    }
    for (; i < n; i++)		/* Der Rest */
      gesetzte[i] = Das.gesetzte[i];
  } else {
    Daten = NULL;
    gesetzte = NULL;
  }

};

BVektor::~BVektor ()
{
  if (n != 0) {
    n = 0;
    free (Daten);
    free (gesetzte);
    Daten = NULL;
    gesetzte = NULL;
  }
};

void 
BVektor::Setze_Dim (int Damit)
{
  int i;

  if (n != Damit) {
    if (n != 0) {
      free (Daten);
      free (gesetzte);
    }
    if (Damit != 0) {
      if ((Daten = (char *) malloc (sizeof (char) * ((Damit / 8) + 1))) == NULL)
	  Fehlermeldung ("BVektor::Setze_Dim()", SPEICHERFEHLER);
      if ((gesetzte = (int *) malloc (sizeof (int) * Damit)) == NULL)
	  Fehlermeldung ("BVektor::Setze_Dim()", SPEICHERFEHLER);
      for (i = 0; i < (Damit / 8) + 1; i++)
	Daten[i] = 0;
    } else {
      Daten = NULL;
      gesetzte = NULL;
    }
    n = Damit;
    gesetzt = 0;
  }
};

void 
BVektor::print ()
{
  int i;

  printf ("\nBVektor :");
  for (i = 0; i < n; i++)
    if (Lese_i (i))
      printf ("1 ");
    else
      printf ("0 ");
  printf ("gesetze:");
  for (i = 0; i < gesetzt; i++)
    printf ("%d ", gesetzte[i]);
  printf ("\n");
};

void 
BVektor::Setze_i (int Pos, char x)
{
  int i;

  if (x) {
    if (!(Daten[Pos / 8] & (1 << (Pos % 8)))) {
      gesetzt++;		/* neu gesetzt */
      Daten[Pos / 8] |= (1 << (Pos % 8));

      /* jetzt den Index an die passende Stelle */
      if (gesetzt == 1)		/* Der erste liegt immer am Anfang */
	gesetzte[0] = Pos;
      else if (Pos < gesetzte[0]) {
	for (i = gesetzt - 1; i > 0; i--)
	  gesetzte[i] = gesetzte[i - 1];
	gesetzte[0] = Pos;
      } else			/* nicht am Anfang */
	for (i = gesetzt - 1; i > 0; i--) {
	  if (Pos < gesetzte[i - 1]) {	/* Positionen tauschen */
	    gesetzte[i] = gesetzte[i - 1];
	  } else {		/* jetzt setzen */
	    gesetzte[i] = Pos;
	    break;
	  }
	}
    }
  } else {
    if (Daten[Pos / 8] & (1 << (Pos % 8))) {
      gesetzt--;		/* war vorher gesetzt */
      Daten[Pos / 8] &= ((1 << (Pos % 8)) ^ 255);
      /* jetzt den Index wieder rauspulen */
      if (gesetzte != 0) {	/* sonst nichts zu tun */
	for (i = 0; gesetzte[i] != Pos; i++);
	Pos = i;		/* Dort ist Pos */
	for (i = Pos; i < gesetzt; i++) {	/* Positionen tauschen */
	  gesetzte[i] = gesetzte[i + 1];
	}
      }
    }
  }
};

char 
BVektor::Lese_i (int Pos)
{
  return ((TRUE) && ((Daten[(Pos / 8)]) & (1 << (Pos % 8))));
};

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

  fprintf (File, "%d %d ", n, gesetzt);
  for (i = 0; i <= (n / 8); i++)
    fprintf (File, "%d ", ((int) Daten[i]));
  for (i = 0; i < gesetzt; i++)
    fprintf (File, "%d ", gesetzte[i]);
  fprintf (File, "\n");
};

int 
BVektor::Laden (FILE * File)
{
  int i, Buffer;

  if (!(fscanf (File, "%d %d", &i, &Buffer))) {
#if 0
    this. ~ BVektor ();
#endif
    return (0);
  }
  Setze_Dim (i);
  gesetzt = Buffer;
  for (i = 0; i <= (n / 8); i++) {
    if (!(fscanf (File, "%d", &Buffer))) {
#if 0
      this. ~ BVektor ();
#endif
      return (0);
    }
    Daten[i] = (char) Buffer;
  }
  for (i = 0; i < gesetzt; i++)
    if (!(fscanf (File, "%d ", &(gesetzte[i])))) {
#if 0
      this. ~ BVektor ();
#endif
      return (0);
    }
  return (1);
};

BVektor 
BVektor::concat (BVektor & Dahinter)
return Result;
{
  int i, j = 0;

  Result.n = n + Dahinter.n;

  if (Result.n != 0) {
    if ((Result.Daten = (char *) malloc (sizeof (char) * ((Result.n / 8) + 1))) == NULL)
        Fehlermeldung ("BVektor::concat()", SPEICHERFEHLER);
    if ((Result.gesetzte = (int *) malloc (sizeof (int) * Result.n)) == NULL)
        Fehlermeldung ("BVektor::concat()", SPEICHERFEHLER);
    for (i = 0; i < n; i++)
      Result.Setze_i (j++, (*this)[i]);
    for (i = 0; i < Dahinter.n; i++)
      Result.Setze_i (j++, Dahinter[i]);
    /* Jetzt die Indizes aneinanderhaengen */
    j = 0;
    for (i = 0; i < gesetzt; i++)
      Result.gesetzte[j++] = gesetzte[i];
    for (i = 0; i < Dahinter.gesetzt; i++)
      Result.gesetzte[j++] = Dahinter.gesetzte[i] + n;
  } else {
    Result.Daten = NULL;
    Result.gesetzt = 0;
    Result.gesetzte = NULL;
  }
};

BVektor 
BVektor::operator& (BVektor & A)
return Result (*this);
{
  int i, j, l = 0;
  char Maske;

  Result.gesetzt = 0;
  if (Result.n != 0) {
    for (i = 0; i < (n / 8); i++) {
      Result.Daten[i] &= A.Daten[i];
      Maske = 1;
      for (j = 0; j < 8; j++, l++) {
	if (Maske & Result.Daten[i])
	  Result.gesetzte[Result.gesetzt++] = l;
	Maske <<= 1;
      }
    }
    Maske = 1;
    Result.Daten[i] &= A.Daten[i];
    for (j = 0; j < (n % 8); j++, l++) {
      if (Maske & Result.Daten[i])
	Result.gesetzte[Result.gesetzt++] = l;
      Maske <<= 1;
    }
  }
};

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

  Setze_Dim (Das.n);
  if (n != 0) {
    for (i = 0; i < (n / 8) + 1; i++)
      Daten[i] = Das.Daten[i];
    for (i = 0; i < n; i++)
      gesetzte[i] = Das.gesetzte[i];
  }
  gesetzt = Das.gesetzt;
};

void 
BVektor::operator= (char Damit)
{
  int i;

  if (n != 0) {
    if (Damit == 0) {
      gesetzt = 0;
      for (i = 0; i < (n / 8) + 1; i++)
	Daten[i] = (char) 0;
    } else {
      gesetzt = n;
      for (i = 0; i < (n / 8) + 1; i++)
	Daten[i] = (char) 255;
      for (i = 0; i < n; i++)
	gesetzte[i] = i;
    }
  }
};

/********************************************************/
/*              Alles zur Klasse IVektor                */
/********************************************************/
IVektor::IVektor (int Groesse, int *Inhalt)
{
  int i;

  n = Groesse;
  if (n != 0) {
    if ((Daten = (int *) malloc (sizeof (int) * n)) == NULL)
        Fehlermeldung ("IVektor::IVektor()", SPEICHERFEHLER);

    if (Inhalt != NULL)
      for (i = 0; i < n; i++)
	Daten[i] = Inhalt[i];
    else
      for (i = 0; i < n; i++)
	Daten[i] = 0;
  } else
    Daten = NULL;
};

IVektor::IVektor (const IVektor & Das)
{
  int i;

  n = Das.n;
  if (n != 0) {
    if ((Daten = (int *) malloc (sizeof (int) * n)) == NULL)
        Fehlermeldung ("IVektor::IVektor(const IVektor& Das)", SPEICHERFEHLER);

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

IVektor::~IVektor ()
{
  if (n != 0) {
    n = 0;
    free (Daten);
    Daten = NULL;
  }
};

void 
IVektor::Setze_Dim (int Damit)
{
  int i;

  if (n != Damit) {
    if (n != 0)
      free (Daten);
    n = Damit;
    if (n != 0) {
      if ((Daten = (int *) malloc (sizeof (int) * n)) == NULL)
	  Fehlermeldung ("IVektor::Setze_Dim(int Damit)", SPEICHERFEHLER);
      else {
	for (i = 0; i < n; i++)
	  Daten[i] = 0;
      }
    } else
      Daten = NULL;
  }
};

char 
IVektor::Ist_drinnen (int Das)
{
  int i;

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

int 
IVektor::Lese_Index (int Davon)
{
  int i;

  for (i = 0; i < n; i++)
    if (Daten[i] == Davon)
      return (i);
  return (-1);
};

void 
IVektor::print ()
{
  int i;

  printf ("\nIVektor :");
  for (i = 0; i < n; i++)
    printf ("%d ", Daten[i]);
  printf ("\n");
};

double 
IVektor::Vektorlaenge ()
{
  int i;
  double Result = 0;

  for (i = 0; i < n; i++) {
    Result += Daten[i] * Daten[i];
  }
  return (sqrt (Result));
};

void 
IVektor::Tausche (int den, int mitdem)
{
  int Buffer;

  Buffer = Daten[den];
  Daten[den] = Daten[mitdem];
  Daten[mitdem] = Buffer;
};

IVektor 
IVektor::Projiziere (BVektor & Diese)
return Result (Diese.Anzahl_gesetzt (), NULL);
{
  int i, j;

  for (i = 0, j = 0; i < n; i++)
    if (Diese.Lese_i (i) == TRUE)
      Result.Daten[j++] = Daten[i];
};

IVektor 
IVektor::Projiziere (IVektor & Diese)
return Result (Diese.Lese_Dim (), NULL);
{
  int i;

  for (i = 0; i < n; i++)
    Result[i] = Daten[Diese[i]];
};

IVektor 
IVektor::Projiziere (int ab)
  return Result (n - ab, NULL);
{
  int i;

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

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

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

int 
IVektor::Laden (FILE * File)
{
  int Dim;

  if (!(fscanf (File, "%d", &Dim))) {
#if 0
    this. ~ IVektor ();
#endif
    return (0);
  }
  Setze_Dim (Dim);
  for (Dim = 0; Dim < n; Dim++) {
    if (!(fscanf (File, "%d", &Daten[Dim]))) {
#if 0
      this. ~ IVektor ();
#endif
      return (0);
    }
  }
  return (1);
};

void 
IVektor::Tausche (IVektor & Damit)
{
  int *iBuffer;
  int i;

  iBuffer = Damit.Daten;
  Damit.Daten = Daten;
  Daten = iBuffer;
  i = Damit.n;
  Damit.n = n;
  n = i;
};

void 
IVektor::Plus_Sortiert (int Das)
{
  int *Buffer, i, j = 0;

  Buffer = Daten;
  if ((Daten = (int *) malloc (sizeof (int) * (n + 1))) == NULL)
      Fehlermeldung ("IVektor::Plus_Sortiert(int Das)", SPEICHERFEHLER);

  for (i = 0; i < n; i++) {
    if (Das > Buffer[j])
      Daten[i] = Buffer[j++];
    else {
      Daten[i++] = Das;
      for (; i <= n; i++)
	Daten[i] = Buffer[j++];
      break;
    }
  }
  n++;
  if (i < n)
    Daten[i] = Das;

  free (Buffer);
};

void 
IVektor::operator-= (IVektor & Minus)
{
  int i;

  for (i = 0; i < n; i++)
    Daten[i] = Daten[i] - Minus.Daten[i];
};

void 
IVektor::operator+= (IVektor & Plus)
{
  int i;

  for (i = 0; i < n; i++)
    Daten[i] = Daten[i] + Plus.Daten[i];
};

void 
IVektor::operator+= (int Das)
{
  int *Buffer, i;

  Buffer = Daten;
  if ((Daten = (int *) malloc (sizeof (int) * (n + 1))) == NULL)
      Fehlermeldung ("IVektor::operator+=(int Das)", SPEICHERFEHLER);
  for (i = 0; i < n; i++)
    Daten[i] = Buffer[i];
  Daten[i] = Das;
  free (Buffer);
  n++;
};

int 
IVektor::operator* (IVektor & Damit)
{
  int Result = 0, i;

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

IVektor 
IVektor::operator- (IVektor & Das) return Result;
{
  int i;

  Result.n = Das.n;
  if (Das.n != 0) {
    if ((Result.Daten = (int *) malloc (sizeof (int) * Das.n)) == NULL)
        Fehlermeldung ("IVektor::operator -", SPEICHERFEHLER);
    for (i = 0; i < Das.n; i++)
      Result.Daten[i] = Daten[i] - Das.Daten[i];
  } else
    Result.Daten = NULL;
};

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

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

void 
IVektor::operator= (int Das)
{
  int i;

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

};
/********************************************************/
/*              Alles zur Klasse DVektor                */
/********************************************************/
DVektor::DVektor (int Groesse, int Nr, double *Inhalt)
{
  int i;

  n = Groesse;
  Nummer = Nr;

  if (n != 0) {
    if ((Daten = (double *) malloc (sizeof (double) * n)) == NULL)
        Fehlermeldung ("DVektor::DVektor()", SPEICHERFEHLER);

    if (Inhalt != NULL)
      for (i = 0; i < n; i++)
	Daten[i] = Inhalt[i];
    else
      for (i = 0; i < n; i++)
	Daten[i] = 0;
  } else
    Daten = NULL;
};

DVektor::~DVektor ()
{
  if (n != 0) {
    n = 0;
    free (Daten);
    Daten = NULL;
  }
};

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

  n = Daraus.n;
  Nummer = Daraus.Nummer;

  if (n != 0) {
    if ((Daten = (double *) malloc (sizeof (double) * n)) == NULL)
        Fehlermeldung ("DVektor::DVektor(DVektor& )", SPEICHERFEHLER);

    for (i = 0; i < n; i++)
      Daten[i] = Daraus.Daten[i];
  } else
    Daten = NULL;
};

void 
DVektor::Setze_Dim (int Damit)
{
  int i;

  if (n != Damit) {
    if (n != 0)
      free (Daten);
    n = Damit;