vektor.cc

模糊聚类的算法实现程序

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

void 
DVektor::NullVektor ()
{
  int i;

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

void 
DVektor::print ()
{
  int i;

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

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

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

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

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

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

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

DVektor 
DVektor::Deprojiziere (BVektor & Diese)
return Result (Diese.Lese_Dim (), Nummer, NULL);
{
  int i, k = 0;

  for (i = 0; i < Diese.Lese_Dim (); i++) {
    if (Diese.Lese_i (i))
      Result.Daten[i] = Daten[k++];
    else
      Result.Daten[i] = 0;
  }
  Result.Nummer = Nummer;
};

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

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

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

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

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

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

DVektor 
DVektor::Projiziere (int ab, int bis)
  return Result ((bis - ab) + 1, Nummer, NULL);
{
  int i;

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

void 
DVektor::VektorT_Mult (DVektor & Dieser, DMatrix & Damit)
{
  int i, j;
  double *Buffer;

  if (Damit.Lese_Dim_n () != 0) {
    if ((Buffer = (double *) malloc (sizeof (double) * Damit.Lese_Dim_n ())) == NULL)
        Fehlermeldung ("void DVektor::VektorT_Mult()", SPEICHERFEHLER);
  } else
    Buffer = NULL;

  n = Damit.Lese_Dim_n ();
  if (n != 0)
    free (Daten);
  Daten = Buffer;

  for (j = 0; j < n; j++) {
    Buffer[j] = 0;
    for (i = 0; i < Damit.Lese_Dim_m (); i++)
      Buffer[j] += Damit.Lese_i_j (i, j) * Dieser.Lese_i (i);
  }

};

DVektor 
DVektor::x (DVektor & B)
return Result (n, 0, NULL);
{
  int i;

  for (i = 0; i < n; i++)
    Result[i] = Daten[(i + 1) % n] * B[(i + 2) % n] - Daten[(i - 1) % n] * B[(i - 2) % n];
};

DMatrix 
DVektor::Produkt (DVektor & B)
return Result (n, B.n);
{
  int i, j;

  for (i = 0; i < n; i++)
    for (j = 0; j < B.n; j++)
      Result.Setze_i_j (i, j, Daten[i] * B.Daten[j]);
};

DMatrix 
DVektor::Produkt ()
return Result (n, n);
{
  int i, j;

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

void 
DVektor::Normiere ()
{
  int i;
  double Laenge = 0;

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

double 
DVektor::Abstand (DVektor & Davon)
{
  int i;
  double Result = 0;

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

  return (sqrt (Result));
};

double 
DVektor::Abstand (DVektor & Davon, BVektor & relevant)
{
  int i;
  double Result = 0;

  for (i = 0; i < relevant.Anzahl_gesetzt (); i++)
    Result += (Davon.Daten[relevant.Lese_gesetzte (i)] - Daten[relevant.Lese_gesetzte (i)]) *
      (Davon.Daten[relevant.Lese_gesetzte (i)] - Daten[relevant.Lese_gesetzte (i)]);

  return (sqrt (Result));
};

double 
DVektor::cos_Winkel (DVektor & Dazu)
{
  double Result = 0, LaengeA = 0, LaengeB = 0;
  int i;

  if (n > 1) {
    for (i = 0; i < n; i++) {	/* Laengen bestimmen */
      LaengeA += Daten[i] * Daten[i];
      LaengeB += Dazu.Daten[i] * Dazu.Daten[i];
    }
    LaengeA = sqrt (LaengeA * LaengeB);

    for (i = 0; i < n; i++)
      Result += Daten[i] * Dazu.Daten[i];
    Result /= LaengeA;
    return (Result);
  } else {
    if (((Dazu.Daten[0] >= 0) && (Daten[0] >= 0)) ||
	((Dazu.Daten[0] < 0) && (Daten[0] < 0)))	/* gleiches vorzeichen */
      return (1);
    else
      return (0);
  }
};


void 
DVektor::Quicksort (int a, int b, IVektor & Indizes)
{
  int r, i, j, iBuffer;
  double x, DBuffer;

  if (b > a) {
    i = a;
    j = b;
    /* Waehle r einmal in der Mitte */
    r = (a + b) / 2;
    x = Daten[r];
    do {
      while (Daten[i] < x)
	i++;
      while (Daten[j] > x)
	j--;
      if (i <= j) {
	DBuffer = Daten[i];
	iBuffer = Indizes[i];

	Daten[i] = Daten[j];
	Indizes[i] = Indizes[j];

	Daten[j] = DBuffer;
	Indizes[j] = iBuffer;

	i++;
	j--;
      }
    } while (j >= i);
    Quicksort (a, j, Indizes);
    Quicksort (i, b, Indizes);
  }
};


void 
DVektor::Quicksort (int a, int b, int Index)
{
  int r, i, j, NrBuffer;
  double x, *DBuffer;

  if (b > a) {
    i = a;
    j = b;
    /* Waehle r einmal in der Mitte */
    r = (a + b) / 2;
    x = this[r].Daten[Index];
    do {
      while (this[i].Daten[Index] < x)
	i++;
      while (this[j].Daten[Index] > x)
	j--;
      if (i <= j) {
	DBuffer = this[i].Daten;
	NrBuffer = this[i].Nummer;

	this[i].Daten = this[j].Daten;
	this[i].Nummer = this[j].Nummer;

	this[j].Daten = DBuffer;
	this[j].Nummer = NrBuffer;
	i++;
	j--;
      }
    } while (j >= i);
    Quicksort (a, j, Index);
    Quicksort (i, b, Index);
  }
};

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

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

double DVektor::operator () (double x) {
  double Result = 0;
  int i;

  if (n != 0)
    Result = Daten[n - 1];
  for (i = n - 2; i >= 0; i--)
    Result = Result * x + Daten[i];
  return (Result);
};

void 
DVektor::operator= (const DVektor & A)
{
  int i;

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

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

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

char 
DVektor::operator== (DVektor & Der)
{
  int i;

  if ((Der.n != n) || (Der.Nummer != Nummer))
    return (FALSE);

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

char 
DVektor::operator!= (DVektor & Der)
{
  int i;

  if ((Der.n != n) || (Der.Nummer != Nummer))
    return (TRUE);

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

void 
DVektor::operator*= (double Damit)
{
  int i;

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

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

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

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

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

void 
DVektor::operator<<= (int soviel)
{
  *this >>= (-soviel);
};

void 
DVektor::operator>>= (int soviel)
{
  int i, j;
  double Buffer;

  if (soviel < 0)
    soviel = n + (soviel % n);

  Buffer = Daten[0];
  for (i = 0, j = soviel % n; j != 0; i = j, j = (i + soviel) % n)
    Daten[i] = Daten[j];
  Daten[i] = Buffer;
};

void 
DVektor::operator/= (double Divisor)
{
  int i;

  for (i = 0; i < n; i++)
    Daten[i] /= Divisor;
};

DVektor 
DVektor::operator* (double Skalar)
  return Result (n, 0, NULL);
{
  int i;

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

DVektor 
DVektor::operator* (DMatrix & Die)
return Result;
{
  int i, j;

  if (Die.Lese_Dim_n () != 0) {
    if ((Result.Daten = (double *) malloc (sizeof (double) * Die.Lese_Dim_n ())) == NULL)
        Fehlermeldung ("void DVektor::operator*(DMatrix& Die)", SPEICHERFEHLER);
  } else
    Result.Daten = NULL;

  Result.n = Die.Lese_Dim_n ();
  Result.Nummer = 0;

  for (j = 0; j < Result.n; j++) {
    Result.Daten[j] = 0;
    for (i = 0; i < Die.Lese_Dim_m (); i++)
      Result.Daten[j] += Die.Lese_i_j (i, j) * Lese_i (i);
  }
};

double 
DVektor::operator* (DVektor & Das)
{
  double Result = 0;
  int i;

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

  return (Result);
};

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

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

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

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

/********************************************************/
/*              Alles zur Klasse BVektorArray           */
/********************************************************/
BVektorArray::BVektorArray (int VektorDim, int ArrayGroesse,
	      BVektor * Diese)
{
  int i;

  Groesse = ArrayGroesse;
  VektorDimension = VektorDim;

  if (Groesse != 0) {
    if ((Daten = (BVektor **) malloc (sizeof (BVektor *) * Groesse)) == NULL)
      Fehlermeldung ("BVektorArray::BVektorArray()", SPEICHERFEHLER);

    for (i = 0; i < Groesse; i++)
      Daten[i] = new BVektor (VektorDimension, NULL);

    if (Diese != NULL)
      for (i = 0; i < Groesse; i++)
	*(Daten[i]) = Diese[i];
  } else
    Daten = NULL;
};

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

  Groesse = Daraus.Groesse;
  VektorDimension = Daraus.VektorDimension;

  if (Groesse != 0) {
    if ((Daten = (BVektor **) malloc (sizeof (BVektor *) * Groesse)) == NULL)
      Fehlermeldung ("BVektorArray::BVektorArray(const BVektorArray& Daraus)", SPEICHERFEHLER);

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

BVektorArray::~BVektorArray ()
{
  VektorDimension = 0;

  int i;

  if (Groesse != 0) {
    for (i = 0; i < Groesse; i++) {
      delete Daten[i];
    }
    free (Daten);
    Daten = NULL;
    Groesse = 0;
  }
};

void 
BVektorArray::print ()
{
  int i;

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

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

  if (Damit != VektorDimension) {
    VektorDimension = Damit;
    for (i = 0; i < Groesse; i++)
      Daten[i]->Setze_Dim (Damit);
  }
};

void 
BVektorArray::Setze_Groesse (int Damit)
{
  int i;
  BVektor **Buffer;

  if (Damit != Groesse) {
    for (i = Damit; i < Groesse; i++)
      delete Daten[i];		/* Ueberfl"ussige L"oschen */
    Buffer = Daten;
    if (Damit != 0) {
      if ((Daten = (BVektor **) malloc (sizeof (BVektor *) * Damit)) == NULL)
	Fehlermeldung ("BVektorArray:Setze_Groesse()", SPEICHERFEHLER);
      for (i = 0; (i < Groesse) && (i < Damit); i++) {	/* Alte "ubernehmen */
	Daten[i] = Buffer[i];
	*(Daten[i]) = 0;;
      }
      for (; i < Damit; i++)
	Daten[i] = new BVektor (VektorDimension, NULL);
    } else
      Daten = NULL;
    Groesse = Damit;
    free (Buffer);
  }
}

void 
BVektorArray::Loesche (int von, int bis)
{
  if ((bis >= von) && (von >= 0) && (bis < Groesse)) {
    int i, j;
    BVektor **DatenBuffer;

    if ((Groesse - (von - bis + 1)) != 0) {
      if ((DatenBuffer = (BVektor **) malloc (sizeof (BVektor *) * (Groesse - (von - bis + 1)))) == NULL)
	Fehlermeldung ("void BVektorArray::Loesche...", SPEICHERFEHLER);
    } else
      DatenBuffer = 0;
    for (j = 0, i = 0; i < von; i++)
      DatenBuffer[j++] = Daten[i];
    for (i = von; i <= bis; i++)
      delete Daten[i];
    for (; i < Groesse; i++)
      DatenBuffer[j++] = Daten[i];

    Groesse = Groesse - (von - bis + 1);
    free (Daten);
    Daten = DatenBuffer;
  }
};

void