daten.cc

模糊聚类分析的源程序！

/********************************************************/
/*   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);
  }
};