vektor.cc

模糊聚类分析的源程序！

BVektorArray::operator+= (BVektor & Damit)
{
  int i;
  BVektor **DatenBuffer;

  if ((VektorDimension != Damit.Lese_Dim ()) &&
      (Groesse != 0))
    Fehlermeldung ("BVektorArray::operator+=", DIMFEHLER);

  VektorDimension = Damit.Lese_Dim ();

  if ((DatenBuffer = (BVektor **) malloc (sizeof (BVektor *) * (Groesse + 1))) == NULL)
    Fehlermeldung ("void BVektorArray::operator+=(BVektor& Damit)", SPEICHERFEHLER);

  for (i = 0; i < Groesse; i++)
    DatenBuffer[i] = Daten[i];
  DatenBuffer[Groesse] = new BVektor (Damit);

  Groesse++;
  free (Daten);
  Daten = DatenBuffer;
};

void 
BVektorArray::operator-= (BVektor & Den)
{
  int i, j, der = -1;
  BVektor **DatenBuffer;

  for (i = 0; i < Groesse; i++) {	/* den passenden Suchen */
    if (Daten[i] == &Den) {
      der = i;
      delete Daten[i];
      break;
    }
  }
  if ((Groesse != 0) && (der != -1)) {
    if (Groesse != 1) {
      if ((DatenBuffer = (BVektor **) malloc (sizeof (BVektor *) * (Groesse - 1))) == NULL)
	Fehlermeldung ("void BVektorArray::operator-=(BVektor& Damit)", SPEICHERFEHLER);
    } else
      DatenBuffer = 0;
    for (i = 0, j = 0; i < Groesse; i++) {
      if (i != der)
	DatenBuffer[j] = Daten[i];
    }
    Groesse--;
    free (Daten);
    Daten = DatenBuffer;
  }
};

BVektorArray & BVektorArray::operator++ (int) {
  int i;
  BVektor **DatenBuffer;

  if ((DatenBuffer = (BVektor **) malloc (sizeof (BVektor *) * (Groesse + 1))) == NULL)
    Fehlermeldung ("void BVektorArray::operator+=(BVektor& Damit)", SPEICHERFEHLER);

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

  Groesse++;
  free (Daten);
  Daten = DatenBuffer;
};


void 
BVektorArray::operator= (char Das)
{
  int i;

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

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

  if ((Groesse != Das.Groesse) || (VektorDimension != Das.VektorDimension)) {
#if 0
    this. ~ BVektorArray ();
#else
    this-> ~ BVektorArray ();
#endif
    Groesse = Das.Groesse;
    VektorDimension = Das.VektorDimension;
    if (Groesse != 0) {
      if ((Daten = (BVektor **) malloc (sizeof (BVektor *) * Groesse)) == NULL)
	Fehlermeldung ("void IBektorArray::operator=(BVektorArray *Das)", SPEICHERFEHLER);
    } else
      Daten = NULL;

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

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

  Groesse = ArrayGroesse;
  VektorDimension = VektorDim;

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

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

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

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

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

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

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

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

  int i;

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

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

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

void 
IVektorArray::Setze_Groesse (int Damit)
{
  int i;
  IVektor **Buffer;

  if (Damit != Groesse) {
    for (i = Damit; i < Groesse; i++)
      delete Daten[i];		/* Ueberfl"ussige L"oschen */
    Buffer = Daten;
    if (Damit != 0) {
      if ((Daten = (IVektor **) malloc (sizeof (IVektor *) * Damit)) == NULL)
	Fehlermeldung ("IVktorArray: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 IVektor (VektorDimension, NULL);
    } else
      Daten = NULL;
    Groesse = Damit;
    free (Buffer);
  }
}

void 
IVektorArray::operator+= (IVektor & Damit)
{
  int i;
  IVektor **DatenBuffer;

  if ((VektorDimension != Damit.Lese_Dim ()) &&
      (Groesse != 0))
    Fehlermeldung ("IVektorArray::operator+=", DIMFEHLER);

  VektorDimension = Damit.Lese_Dim ();

  if ((DatenBuffer = (IVektor **) malloc (sizeof (IVektor *) * (Groesse + 1))) == NULL)
    Fehlermeldung ("void IVektorArray::operator+=(IVektor& Damit)", SPEICHERFEHLER);

  for (i = 0; i < Groesse; i++)
    DatenBuffer[i] = Daten[i];
  DatenBuffer[Groesse] = new IVektor (Damit);

  Groesse++;
  free (Daten);
  Daten = DatenBuffer;
};

void 
IVektorArray::operator-= (IVektor & Den)
{
  int i, j, der = -1;
  IVektor **DatenBuffer;

  for (i = 0; i < Groesse; i++) {	/* den passenden Suchen */
    if (Daten[i] == &Den) {
      der = i;
      delete Daten[i];
      break;
    }
  }
  if ((Groesse != 0) && (der != -1)) {
    if (Groesse != 1) {
      if ((DatenBuffer = (IVektor **) malloc (sizeof (IVektor *) * (Groesse - 1))) == NULL)
	Fehlermeldung ("void IVektorArray::operator+=(IVektor& Damit)", SPEICHERFEHLER);
    } else
      DatenBuffer = 0;
    for (i = 0, j = 0; i < Groesse; i++) {
      if (i != der)
	DatenBuffer[j] = Daten[i];
    }
    Groesse--;
    free (Daten);
    Daten = DatenBuffer;
  }
};

char 
IVektorArray::Ist_vorhanden (IVektor & Soeiner)
{
  int i, j;
  char Result;

  for (i = 0; i < Groesse; i++) {
    Result = TRUE;
    for (j = 0; j < VektorDimension; j++) {
      if (Soeiner.Lese_i (j) != Daten[i]->Lese_i (j)) {		/* nicht gleich */
	Result = FALSE;
	break;
      }
    }
    if (Result == TRUE)
      return (TRUE);
  }
  return (FALSE);
};

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

  if ((Groesse != Das.Groesse) || (VektorDimension != Das.VektorDimension)) {
#if 0
    this. ~ IVektorArray ();
#else
    this-> ~ IVektorArray ();
#endif
    Groesse = Das.Groesse;
    VektorDimension = Das.VektorDimension;
    if (Groesse != 0) {
      if ((Daten = (IVektor **) malloc (sizeof (IVektor *) * Groesse)) == NULL)
	Fehlermeldung ("void IVektorArray::operator=(IVektorArray *Das)", SPEICHERFEHLER);
    } else
      Daten = NULL;

    for (i = 0; i < Groesse; i++)
      Daten[i] = new IVektor (*(Das.Daten[i]));
  } else {
    for (i = 0; i < Groesse; i++)
      (*(Daten[i])) = *(Das.Daten[i]);
  }
};

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

  Groesse = ArrayGroesse;
  VektorDimension = VektorDim;

  Durchschnitt.DVektor (VektorDim, 0, NULL);
  Max.DVektor (VektorDim, 0, NULL);
  Min.DVektor (VektorDim, 0, NULL);
  MaxNummer.IVektor (VektorDim, NULL);
  MinNummer.IVektor (VektorDim, NULL);

  for (i = 0; i < VektorDim; i++) {
    Max[i] = -MAXDOUBLE;
    Min[i] = MAXDOUBLE;
  }


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

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

    if (Diese != NULL)
      for (i = 0; i < Groesse; i++)
	Setze_Vektor (i, Diese[i].Lese_Daten ());
  } else
    Daten = NULL;
};

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

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

  if (Groesse != 0) {
    if ((Daten = (DVektor **) malloc (sizeof (DVektor *) * Groesse)) == NULL)
      Fehlermeldung ("DVektorArray::DVektorArray(const DVektorArray& Daraus)", SPEICHERFEHLER);
    for (i = 0; i < Groesse; i++)
      Daten[i] = new DVektor (*(Daraus.Daten[i]));
  } else
    Daten = NULL;

  Min = (DVektor &) Daraus.Min;
  Max = (DVektor &) Daraus.Max;
  MinNummer = (IVektor &) Daraus.MinNummer;
  MaxNummer = (IVektor &) Daraus.MaxNummer;
  Durchschnitt = (DVektor &) Daraus.Durchschnitt;

};

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

  int i;

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

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

  if (Damit != VektorDimension) {
    VektorDimension = Damit;
    for (i = 0; i < Groesse; i++)
      Daten[i]->Setze_Dim (Damit);
    Durchschnitt.Setze_Dim (Damit);
    Min.Setze_Dim (Damit);
    Max.Setze_Dim (Damit);
    MinNummer.Setze_Dim (Damit);
    MaxNummer.Setze_Dim (Damit);
  }
};

void 
DVektorArray::Setze_Groesse (int Damit)
{
  int i;
  DVektor **Buffer;

  if (Damit != Groesse) {
    for (i = Damit; i < Groesse; i++)
      delete Daten[i];		/* Ueberfl"ussige L"oschen */
    Buffer = Daten;
    if (Damit != 0) {
      if ((Daten = (DVektor **) malloc (sizeof (DVektor *) * Damit)) == NULL)
	Fehlermeldung ("DVktorArray:Setze_Groesse()", SPEICHERFEHLER);
      for (i = 0; (i < Groesse) && (i < Damit); i++) {	/* Alte "ubernehmen */
	Daten[i] = Buffer[i];
	Daten[i]->NullVektor ();
      }
      for (; i < Damit; i++)
	Daten[i] = new DVektor (VektorDimension, i, NULL);
    } else
      Daten = NULL;
    Groesse = Damit;
    Durchschnitt = 0;
    Min = 0;
    Max = 0;
    MinNummer = 0;
    MaxNummer = 0;
    free (Buffer);
  }
}

void 
DVektorArray::NullVektor ()
{
  int i;

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

DVektor 
DVektorArray::Zufallsvektor ()
return Result (VektorDimension, 0, NULL);
{
  int i;

  if (Groesse != 0) {
    for (i = 0; i < VektorDimension; i++)
      Result[i] = (double) (Min[i] +
		  ((double) rand () / (double) MAXINT) * (Max[i] - Min[i]));
  }
};

int 
DVektorArray::Lese_Index (DVektor & Der)
{
  int i;

  for (i = 0; i < Groesse; i++) {
    if (Daten[i] == &Der)
      return (i);
  }

  return (-1);
};

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

  fprintf (File, "%d %d\n", Groesse, VektorDimension);
  Durchschnitt.Speichern (File);
  Min.Speichern (File);
  Max.Speichern (File);
  MinNummer.Speichern (File);
  MaxNummer.Speichern (File);
  for (i = 0; i < Groesse; i++)
    Daten[i]->Speichern (File);
};

int 
DVektorArray::Laden (FILE * File)
{
  int x, y;

  if (!(fscanf (File, "%d %d ", &x, &y)))
    return (0);
  Setze_Groesse (x);
  Setze_Dim (y);
  if ((!Durchschnitt.Laden (File)) || (!Min.Laden (File)) ||
      (!Max.Laden (File)) || (!MinNummer.Laden (File)) ||
      (!MaxNummer.Laden (File))) {
#if 0
    this. ~ DVektorArray ();
#endif
    return (0);
  }
  for (x = 0; x < Groesse; x++) {
    if (!(Daten[x]->Laden (File))) {
#if 0
      this. ~ DVektorArray ();
#endif
      return (0);
    }
  }
  return (1);
};

DVektorArray 
DVektorArray::Deprojiziere (BVektor & Diese)
return Result (Diese.Lese_Dim (), Groesse, NULL);
{
  int i;

  for (i = 0; i < Groesse; i++) {
    *(Result.Daten[i]) = Daten[i]->Deprojiziere (Diese);
  }
};

DVektorArray 
DVektorArray::Projiziere (BVektor & Diese)
return Result;
{
  int i;

  if (Groesse != 0) {
    if ((Result.Daten = (DVektor **) malloc (sizeof (DVektor *) * Groesse)) == NULL)
      Fehlermeldung ("DVektorArray::Projiziere", SPEICHERFEHLER);
  } else
    Result.Daten = NULL;

  Result.Groesse = Groesse;
  Result.VektorDimension = Diese.Anzahl_gesetzt ();
  for (i = 0; i < Groesse; i++) {
    Result.Daten[i] = new DVektor (Diese.Anzahl_gesetzt (),
				   Daten[i]->Lese_Nummer (), NULL);
    (*(Result.Daten[i])) = Daten[i]->Projiziere (Diese);
    Result.Daten[i]->Setze_Nummer (Daten[i]->Lese_Nummer ());
  }

  Result.Min = Min.Projiziere (Diese);
  Result.Max = Max.Projiziere (Diese);
  Result.MinNummer = MinNummer.Projiziere (Diese);
  Result.MaxNummer = MaxNummer.Projiziere (Diese);
  Result.Durchschnitt = Durchschnitt.Projiziere (Diese);
};

DVektorArray 
DVektorArray::Projiziere (IVektor & Diese)
return Result;
{
  int i;

  if (Groesse != 0) {
    if ((Result.Daten = (DVektor **) malloc (sizeof (DVektor *) * Groesse)) == NULL)
      Fehlermeldung ("DVektorArray::Projiziere", SPEICHERFEHLER);
  } else
    Result.Daten = NULL;

  Result.Groesse = Groesse;
  Result.VektorDimension = Diese.Lese_Dim ();
  for (i = 0; i < Groesse; i++) {
    Result.Daten[i] = new DVektor (Diese.Lese_Dim (),
				   Daten[i]->Lese_Nummer (), NULL);
    (*(Result.Daten[i])) = Daten[i]->Projiziere (Diese);
    Result.Daten[i]->Setze_Nummer (Daten[i]->Lese_Nummer ());
  }

  Result.Min = Min.Projiziere (Diese);
  Result.Max = Max.Projiziere (Diese);
  Result.MinNummer = MinNummer.Projiziere (Diese);
  Result.MaxNummer = MaxNummer.Projiziere (Diese);
  Result.Durchschnitt = Durchschnitt.Projiziere (Diese);
};

DVektorArray 
DVektorArray::Projiziere (int ab)
  return Result;
{
  int i;

  if (Groesse != 0) {
    if ((Result.Daten = (DVektor **) malloc (sizeof (DVektor *) * Groesse)) == NULL)
      Fehlermeldung ("DVektorArray::Projiziere", SPEICHERFEHLER);
  } else
    Result.Daten = NULL;

  for (i = 0; i < Groesse; i++) {
    Result.Daten[i] = new DVektor (0, Daten[i]->Lese_Nummer (), NULL);
    (*(Result.Daten[i])) = Daten[i]->Projiziere (ab);
    Result.Daten[i]->Setze_Nummer (Daten[i]->Lese_Nummer ());
  }

  Result.Groesse = Groesse;
  Result.VektorDimension = Daten[i]->Lese_Dim ();

  Result.Min = Min.Projiziere (ab);
  Result.Max = Max.Projiziere (ab);
  Result.MinNummer = MinNummer.Projiziere (ab);
  Result.MaxNummer = MaxNummer.Projiziere (ab);
  Result.Durchschnitt = Durchschnitt.Projiziere (ab);
};

DVektorArray 
DVektorArray::Quicksort (int Index)
  return Result;
{
  int i, j, MinIndex = 0, MaxIndex = 0;
  double Minwert, Maxwert;

  Result = *this;
  Result.Quicksort (0, Groesse - 1, Index);

/* Neue Maxima und Minima bestimmen */
  for (i = 0; i < VektorDimension; i++) {
    Minwert = MAXDOUBLE;
    Maxwert = -MAXDOUBLE;
    for (j = 0; j < Groesse; j++) {
      if (Result.Daten[j]->Lese_i (i) < Minwert) {
	MinIndex = j;
	Minwert = Result.Daten[j]->Lese_i (i);
      }
      if (Result.Daten[j]->Lese_i (i) > Maxwert) {
	MaxIndex = j;
	Maxwert = Daten[j]->Lese_i (i);
      }
    }
    Result.Max.Setze_i (i, Maxwert);
    Result.MaxNummer.Setze_i (i, MaxIndex);
    Result.Min.Setze_i (i, Minwert);
    Result.MinNummer.Setze_i (i, MinIndex);
  }
};

void 
DVektorArray::Setze_Vektor (int i, DVektor & Damit)
{
  Setze_Vektor (i, Damit.Lese_Daten ());
  Daten[i]->Setze_Nummer (Damit.Lese_Nummer ());
};

void 
DVektorArray::Setze_Vektor (int i, double *Damit)
{
  int x;

  for (x = 0; x < VektorDimension; x++)
    Setze_Vektor (i, x, Damit[x]);
};

void 
DVektorArray::Setze_Vektor (int Vektor, int Index, double x)
{
  int i;

/*****************************************/
  /*     neuen Durchschnitt feststellen    */
/*****************************************/
  Durchschnitt[Index] = ((Lese_Durchschnitt (Index) * Lese_Groesse ()) +
		       x - Daten[Vektor]->Lese_i (Index)) / Lese_Groesse ();

/*****************************************/
  /* neues Maximum und Minimum feststellen */
/*****************************************/
  if ((Max.Lese_i (Index) == -MAXDOUBLE) && (Min.Lese_i (Index) == MAXDOUBLE)) {
    /* noch uninitialisiert */
    Max[Index] = x;
    Min[Index] = x;
  } else if (x > Max[Index]) {
    MaxNummer[Index] = Vektor;
    Max[Index] = x;