/********************************************************//*   filename: daten.cc                                 *//*                                                      *//********************************************************//* programmed by: Oliver Wagner                         *//* last change: 22-03-95                                *//********************************************************/#include "daten.h"Datensatz::Datensatz (int Dim, int OutDim, int Anzahl){  int i;  Typ = Normal;  Namen = NULL;  OutputDim = OutDim;  relevant.BVektor (Dim, NULL);/******* Speicher fuer alle Daten *********/  if (Dim != 0) {    if ((Namen = (char **) malloc (sizeof (char *) * Dim)) == NULL)        Fehlermeldung ("Datensatz", SPEICHERFEHLER);    for (i = 0; i < Dim; i++)      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)	  Fehlermeldung ("Datensatz", SPEICHERFEHLER);  }  if (Anzahl != 0)    Daten.DVektorArray (Dim, Anzahl, NULL);  eindeutig.Setze_Dim (Anzahl);  eindeutig = TRUE;  for (i = 0; i < Dim; i++) {    relevant.Setze_i (i, FALSE);  }  Zugehoerigkeiten.DVektorArray (0, Anzahl, NULL);  Klassen.IVektor (0, NULL);};Datensatz::Datensatz (const Datensatz & Daraus){  int i;  Daten = (DVektorArray &) Daraus.Daten;  OutputDim = Daraus.OutputDim;  relevant = (BVektor &) Daraus.relevant;  eindeutig = (BVektor &) Daraus.eindeutig;  Typ = Daraus.Typ;  if (Daten.Lese_Dim () != 0) {    if ((Namen = (char **) malloc (sizeof (char *) * Daten.Lese_Dim ())) == NULL)        Fehlermeldung ("Datensatz::Datensatz(Datensatz& Daraus)", SPEICHERFEHLER);    for (i = 0; i < Daten.Lese_Dim (); i++) {      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)	  Fehlermeldung ("Datensatz::Datensatz(Datensatz& Daraus)", SPEICHERFEHLER);      else	strcpy (Namen[i], Daraus.Namen[i]);    }  } else    Namen = NULL;  Zugehoerigkeiten.DVektorArray (Daraus.Zugehoerigkeiten);  Klassen = (IVektor &) Daraus.Klassen;};Datensatz::~Datensatz (){  int i;  for (i = 0; i < Daten.Lese_Dim (); i++)    free (Namen[i]);  free (Namen);  Namen = NULL;  OutputDim = 0;};Datensatz & Datensatz::operator = (Datensatz & Der) {  int i;#if 0  this. ~ Datensatz ();#else  this-> ~ Datensatz ();#endif  Daten = Der.Daten;  OutputDim = Der.OutputDim;  relevant = Der.relevant;  eindeutig = Der.eindeutig;  Typ = Der.Typ;  Zugehoerigkeiten = Der.Zugehoerigkeiten;  Klassen = Der.Klassen;  if (Der.Daten.Lese_Dim () != 0) {    if ((Namen = (char **) malloc (sizeof (char *) * Der.Daten.Lese_Dim ())) == NULL)        Fehlermeldung ("Datensatz::operator=()", SPEICHERFEHLER);    for (i = 0; i < Der.Daten.Lese_Dim (); i++) {      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)	  Fehlermeldung ("Datensatz::operator=()", SPEICHERFEHLER);      else	strcpy (Namen[i], Der.Namen[i]);    }  } else    Namen = NULL;};void Datensatz::File_speichern (char *Name){  FILE *File;  int i, j;  if ((File = fopen (Name, "w")) == NULL) {    Fehlermeldung ("Datensatz::_File_speichern", DATEIOEFFNENFEHLER);  } else {    switch (Typ) {/** Typ speichern **/    case Normal:      fprintf (File, "normal\n");      break;    case Klassifiziert:      fprintf (File, "classified\n");      break;    default:      break;			/*gibt es nicht */    }    fprintf (File, "%d %d %d\n", Daten.Lese_Groesse (),	     Daten.Lese_Dim () - OutputDim, OutputDim);    for (i = 0; i < Daten.Lese_Dim (); i++)      fprintf (File, "%s ", Namen[i]);    fprintf (File, "\n");    for (j = 0; j < Daten.Lese_Groesse (); j++) {      for (i = 0; i < Daten.Lese_Dim (); i++)	fprintf (File, "%lf ", Daten[j][i]);      if (Typ == Klassifiziert)	fprintf (File, "%d\n", Daten[j].Lese_Nummer ());      else	fprintf (File, "\n");    }    fclose (File);  }};Datensatz File_einlesen (char *Name)  return Result;{  FILE *File;  int Anzahl, Dim, ODim, x, y;  char OK = TRUE, Typ_String[20];  Daten_Typ classification = Normal;  if ((File = fopen (Name, "r")) == NULL) {    Fehlermeldung ("File_einlesen", DATEIOEFFNENFEHLER);    return (Result);  }  if (!(fscanf (File, "%20s", Typ_String))) {    Fehlermeldung ("daten.Datensatz_einlesen", DATEIFORMATFEHLER);    fclose (File);    return (Result);  } else {    if (!(strcmp (Typ_String, "normal")))/** Result.Typ=Normal; **/      classification = Normal;    else if (!(strcmp (Typ_String, "classified")))/** Result.Typ=Klassifiziert; **/      classification = Klassifiziert;    else {      Fehlermeldung ("daten.Datensatz_einlesen", DATEIFORMATFEHLER);      Result. ~ Datensatz ();      fclose (File);      return (Result);    }  }  if (!(fscanf (File, "%d %d %d", &Anzahl, &Dim, &ODim))) {    Fehlermeldung ("daten.Datensatz_einlesen", DATEIFORMATFEHLER);    fclose (File);    return (Result);  }  Dim += ODim;/***** Speicher reservieren ******/  Result.Datensatz (Dim, ODim, Anzahl);  /* patch type in: */  Result.Typ = classification;  Result.eindeutig.Setze_Dim (Anzahl);  Result.eindeutig = TRUE;  Result.relevant = BVektor (Dim, NULL);  /* Namen einlesen */  for (x = 0; (x < Dim) && (OK); x++) {    if (!(fscanf (File, "%20s", Result.Namen[x]))) {      Fehlermeldung ("Datensatz:File_einlesen", DATEIFORMATFEHLER);      OK = FALSE;    }  }  /* Daten Einlesen */  for (x = 0; (x < Anzahl) && (OK); x++) {    for (y = 0; (y < Dim) && (OK); y++) {      if (!(fscanf (File, "%lf", &(Result.Daten[x][y])))) {	Fehlermeldung ("Datensatz:File_einlesen", DATEIFORMATFEHLER);	OK = FALSE;      }    }    if (OK) {      if (Result.Typ == Klassifiziert) {	if (!(fscanf (File, "%d", &(Result.Daten[x].Lese_Nummer ())))) {	  Fehlermeldung ("Datensatz:File_einlesen", DATEIFORMATFEHLER);	  OK = FALSE;	}      }    } else      Result.Daten[x].Setze_Nummer (0);  }  fclose (File);  if (OK == FALSE) {    Result. ~ Datensatz ();  } else if (Result.Typ == Klassifiziert) {    /* Zunaechst Anzahl der Klassen feststellen */    Result.Klassen.Setze_Dim (0);    for (x = 0; x < Anzahl; x++) {      if (!(Result.Klassen.Ist_drinnen (Result.Daten[x].Lese_Nummer ())))	Result.Klassen.Plus_Sortiert (Result.Daten[x].Lese_Nummer ());    }    Result.Zugehoerigkeiten. ~ DVektorArray ();    Result.Zugehoerigkeiten.DVektorArray (Result.Klassen.Lese_Dim (), Anzahl, NULL);    for (x = 0; x < Anzahl; x++) {      Result.Zugehoerigkeiten[x][Result.Klassen.Lese_Index (Result.Daten[x].Lese_Nummer ())] = 1;    }  } else {    Result.Zugehoerigkeiten.Setze_Dim (1);	/* alle in einer Klasse */    Result.Zugehoerigkeiten = 1;    Result.Klassen.Setze_Dim (1);    Result.Klassen = 0;  }  Result.Daten.Aktualisiere_Min_etc ();};void Datensatz::operator+= (DVektor & Der){  int Index;  Daten += Der;  Index = Klassen.Lese_Index (Der.Lese_Nummer ());  if (Index != -1) {		/* einfach nur dazu packen */    Zugehoerigkeiten += Zugehoerigkeiten[0];	/* den muss es geben */    Zugehoerigkeiten[Zugehoerigkeiten.Lese_Groesse () - 1] = 0;    Zugehoerigkeiten[Zugehoerigkeiten.Lese_Groesse () - 1][Index] = 1;  } else {			/* eine noch unbekannte Klasse */    BVektor Deproj (Klassen.Lese_Dim () + 1, NULL);    Deproj = TRUE;    Klassen.Plus_Sortiert (Der.Lese_Nummer ());    Index = Klassen.Lese_Index (Der.Lese_Nummer ());    Deproj.Setze_i (Index, FALSE);    Zugehoerigkeiten = Zugehoerigkeiten.Deprojiziere (Deproj);    Zugehoerigkeiten += Zugehoerigkeiten[0];	/* den muss es geben */    Zugehoerigkeiten[Zugehoerigkeiten.Lese_Groesse () - 1] = 0;    Zugehoerigkeiten[Zugehoerigkeiten.Lese_Groesse () - 1][Index] = 1;  }};void Datensatz::operator-= (DVektor & Der){  int Index, Index2, Klasse, i, j;  Klasse = Der.Lese_Nummer ();  Index = Klassen.Lese_Index (Klasse);  Index2 = Daten.Lese_Index (Der);  for (i = 0, j = 0; i < Daten.Lese_Groesse (); i++) {    if (Daten[i].Lese_Nummer () == Klasse) {      j++;      if (j == 2)	break;			/* noch einer in derselben Klasse */    }  }  Daten -= Der;  if (j != 2) {			/* die Klasse zusatzlich loeschen */    BVektor Proj (Klassen.Lese_Dim (), NULL);    Proj = 1;    Proj.Setze_i (Index, FALSE);    Klassen = Klassen.Projiziere (Proj);    Zugehoerigkeiten -= (Zugehoerigkeiten[Index2]);    Zugehoerigkeiten = Zugehoerigkeiten.Projiziere (Proj);  }};