regel.cc

模糊聚类的算法实现程序

	/* Schnittpunkt bestimmen */
	xtemp[i] = Daten[0][i - 1] + (Daten[0][i] - Daten[0][i - 1]) *
	  (Hoehe - Daten[1][i - 1]) / (Daten[1][i] - Daten[1][i - 1]);
      }
      i++;
      break;
    }
  }

  /* jetzt oberhalb bis zum Schnitt suchen */
  for ( /* i bleibt */ ; i < Daten.Lese_Dim (); i++) {
    if (Daten[1][i] < Hoehe) {	/* wieder drunter */
      xtemp[soviel] = Daten[0][i - 1] + (Daten[0][i] - Daten[0][i - 1]) *
	(Hoehe - Daten[1][i - 1]) / (Daten[1][i] - Daten[1][i - 1]);
      ytemp[soviel++] = Hoehe;
      xtemp[soviel] = Daten[0][i];
      ytemp[soviel++] = Daten[1][i];
      i++;
      break;
    }
  }

  /* jetzt der Rest */
  if ((i == Daten.Lese_Dim ()) && (Hoehe <= Daten[1][i - 1])) {		/* keiner mehr unterhalb */
    xtemp[soviel] = Daten[0][i - 1];
    ytemp[soviel++] = Hoehe;
  } else {
    /* den Rest uebernehmen */
    for ( /* i bleibt */ ; i < Daten.Lese_Dim (); i++) {
      xtemp[soviel] = Daten[0][i];
      ytemp[soviel++] = Daten[1][i];
    }
  }
  /* jetzt noch uebergeben */
  x = xtemp.Projiziere (0, soviel - 1);
  y = ytemp.Projiziere (0, soviel - 1);
};

Konvex_Parameter 
Konvex_einlesen (FILE * File)
return Result ();
{
  int i, Anzahl;

  if (!(fscanf (File, "%d", &Anzahl))) {
    Fehlermeldung ("Konvex_Parameter Konvex_einlesen", DATEIFORMATFEHLER);
  } else {
    Result.Daten.DVektorArray (Anzahl, 2, NULL);
    for (i = 0; i < Anzahl; i++) {
      if (2 != fscanf (File, "%lf %lf",
		       &(Result.Daten[0][i]), &(Result.Daten[1][i]))) {
	Fehlermeldung ("Konvex_Parameter Konvex_einlesen", DATEIFORMATFEHLER);
	Result. ~ Konvex_Parameter ();
	break;
      }
    }
  }
};

/***********************************************************/
/*              Die Oberklasse der Regeln                  */
/***********************************************************/
Dummy_Regel::Dummy_Regel (int xDimension = 0, int yDimension = 0,
	     Parameter_Typ PT = Trapez)
{
  int i;

  xDim = xDimension;
  yDim = yDimension;

  if (xDim + yDim != 0) {
    if ((Namen = (char **) malloc (sizeof (char *) * (xDim + yDim))) == NULL)
        Fehlermeldung ("Dummy_Regel::Dummy_Regel", SPEICHERFEHLER);
    for (i = 0; i < xDim + yDim; i++) {
      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	  Fehlermeldung ("Dummy_Regel::Dummy_Regel", SPEICHERFEHLER);
    }
  }
  if ((xDim != 0) || (yDim != 0)) {
    if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * (xDim + yDim))) == NULL)
      Fehlermeldung ("Dummy_Regel::Dummy_Regel", SPEICHERFEHLER);
    /* Auffuellen */
    switch (PT) {
    case Trapez:
      for (i = 0; i < xDim + yDim; i++)
	Daten[i] = new Trapez_Parameter;
      break;
    case Konvex:
      for (i = 0; i < xDim + yDim; i++)
	Daten[i] = new Konvex_Parameter;
      break;
    default:
      break;
    }
  } else {
    Daten = NULL;
    Namen = NULL;
  }
};

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

  xDim = Das.xDim;
  yDim = Das.yDim;

  if ((xDim + yDim) != 0) {
    if ((Namen = (char **) malloc (sizeof (char *) * (xDim + yDim))) == NULL)
        Fehlermeldung ("Dummy_Regel::Dummy_Regel(const Dummy_Regel& Das)", SPEICHERFEHLER);
    for (i = 0; i < xDim + yDim; i++) {
      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	  Fehlermeldung ("Dummy_Regel::Dummy_Regel(const Dummy_Regel& Das)", SPEICHERFEHLER);
      strcpy (Namen[i], Das.Namen[i]);
    }
    if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * (xDim + yDim))) == NULL)
      Fehlermeldung ("Dummy_Regel::Dummy_Regel(const Dummy_Regel& Das)", SPEICHERFEHLER);
  } else {
    Daten = NULL;
    Namen = NULL;
  }

  for (i = 0; i < xDim + yDim; i++) {
    if (Das.Daten[i] == NULL)
      Daten[i] = NULL;
    else {
      switch (Das.Daten[i]->Lese_Parameter_Typ ()) {
      case Trapez:
	Daten[i] = new Trapez_Parameter (*(Das.Daten[i]));
	break;
      case Konvex:
	Daten[i] = new Konvex_Parameter (*(Das.Daten[i]));
      default:
	break;
      }
    }
  }
  Nummer = Das.Nummer;
};

Dummy_Regel::~Dummy_Regel ()
{
  int i;

  if ((xDim != 0) || (yDim != 0)) {
    for (i = 0; i < xDim + yDim; i++) {
      delete Daten[i];
      free (Namen[i]);
    }
    free (Namen);
    free (Daten);
    Namen = NULL;
    Daten = NULL;
    xDim = yDim = 0;
  }
};

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

  if (this->Lese_Typ () == Typ_Klasse)
    fprintf (File, "%d\n", Lese_Nummer ());
  for (i = 0; i < (xDim + yDim); i++) {
    fprintf (File, "%s ", Namen[i]);
    switch (Daten[i]->Lese_Parameter_Typ ()) {
    case Trapez:
      fprintf (File, "%s ", "trapezoid");
      break;
    case Konvex:
      fprintf (File, "%s ", "convex");
      break;
    }
    Daten[i]->Speichern (File);
  }

  fprintf (File, "\n");
};

void 
Dummy_Regel::Setze_Parameter (int Index, Parameter & Damit)
{
  int i = 0;

  if (Daten[i]->Lese_Parameter_Typ () != Damit.Lese_Parameter_Typ ()) {
    delete Daten[i];
    switch (Damit.Lese_Parameter_Typ ()) {
    case Trapez:
      Daten[i] = new Trapez_Parameter (Damit);
      break;
    case Konvex:
      Daten[i] = new Konvex_Parameter (Damit);
      break;
    default:
      break;
    }
  } else {
    *(Daten[i]) = Damit;
  }
};

Dummy_Regel & Dummy_Regel::operator = (const Dummy_Regel & Das) {
  int i;
  char **cBuffer;
  Parameter **PBuffer;

  if ((xDim + yDim) != (Das.xDim + Das.yDim)) {		/* Speicher groessenmaeszig anpassen */
    if ((Das.xDim + Das.yDim) != 0) {
      cBuffer = Namen;
      PBuffer = Daten;
      if ((Namen = (char **) malloc (sizeof (char *) * (Das.xDim + Das.yDim))) == NULL)
	  Fehlermeldung ("Dummy_Regel::operator=(Dummy_Regel& Das)", SPEICHERFEHLER);
      if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * (Das.xDim + Das.yDim))) == NULL)
	Fehlermeldung ("Dummy_Regel::operator=(Dummy_Regel& Das)", SPEICHERFEHLER);

      for (i = 0; (i < (xDim + yDim)) && (i < (Das.xDim + Das.yDim)); i++) {	/* noch zu verwendene Speicher-Belegung */
	Namen[i] = cBuffer[i];
	Daten[i] = PBuffer[i];
      }
      for (; i < (xDim + yDim); i++) {	/*ueberfluessiges loeschen */
	free (cBuffer[i]);
	delete PBuffer;
      }
      for (; i < (Das.xDim + Das.yDim); i++) {
	if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	    Fehlermeldung ("Dummy_Regel::operator=(Dummy_Regel& Das)", SPEICHERFEHLER);
	switch (Das.Daten[i]->Lese_Parameter_Typ ()) {
	case Trapez:
	  Daten[i] = new Trapez_Parameter (*(Das.Daten[i]));
	  break;
	case Konvex:
	  Daten[i] = new Konvex_Parameter (*(Das.Daten[i]));
	  break;
	}
      }
      free (cBuffer);
      free (PBuffer);
    } else {
      Daten = NULL;
      Namen = NULL;
    }
  }
  for (i = 0; i < (Das.xDim + Das.yDim); i++) {
    strcpy (Namen[i], Das.Namen[i]);
  }

  for (i = 0; i < (xDim + yDim); i++) {		/* nur die alten Dimensionen aendern, die anderen sind schon neu */
#if 0
    if (Daten[i].Lese_Parameter_Typ () != Das.Daten[i].Lese_Parameter_Typ ())
#else
    if (Daten[i]->Lese_Parameter_Typ () != Das.Daten[i]->Lese_Parameter_Typ ())
#endif
    {
      delete Daten[i];
      switch (Das.Daten[i]->Lese_Parameter_Typ ()) {
      case Trapez:
	Daten[i] = new Trapez_Parameter (*(Das.Daten[i]));
	break;
      case Konvex:
	Daten[i] = new Konvex_Parameter (*(Das.Daten[i]));
      default:
	break;
      }
    } else {
      (*(Daten[i])) = (*(Das.Daten[i]));
    }
  }

  xDim = Das.xDim;
  yDim = Das.yDim;
  Nummer = Das.Nummer;
};

void 
Dummy_Regel::File_einlesen (FILE * File, int x, int y)
{
  int i, j;
  char Buffer[NAMENLAENGE];

  xDim = x;
  yDim = y;
  if (x + y != 0) {
    if ((Namen = (char **) malloc (sizeof (char *) * (x + y))) == NULL)
        Fehlermeldung ("Dummy_Regel::File_einlesen(FILE* File,int x, int y)", SPEICHERFEHLER);
    for (i = 0; i < x + y; i++) {
      if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	  Fehlermeldung ("Dummy_Regel::File_einlesen(FILE* File,int x, int y)", SPEICHERFEHLER);
    }
    if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * (x + y))) == NULL)
      Fehlermeldung ("Dummy_Regel::File_einlesen(FILE* File,int x, int y)", SPEICHERFEHLER);

    for (i = 0; i < x + y; i++) {
      /* Auffuellen */
      if (2 != fscanf (File, "%20s %20s", Namen[i], Buffer)) {
	Fehlermeldung ("Dummy_Regel::File_einlesen", DATEIFORMATFEHLER);
	break;
      }
      if (Lese_Fehlerstatus () == KEINFEHLER) {
	if (!(strcmp (Buffer, "trapezoid"))) {
	  Daten[i] = new Trapez_Parameter (Trapez_einlesen (File));
	} else if (!(strcmp (Buffer, "convex"))) {
	  Daten[i] = new Konvex_Parameter (Konvex_einlesen (File));
	} else {
	  Fehlermeldung ("Dummy_Regel::File_einlesen", DATEIFORMATFEHLER);
	}
      }
      if (Lese_Fehlerstatus () != KEINFEHLER) {
	for (j = 0; j < i; j++)
	  delete (Daten[j]);
	for (i++; i < x + y; i++)	/* auffuellen */
	  Daten[i] = NULL;
	xDim = 0;
	yDim = 0;
	free (Daten);
	for (i = 0; i < x + y; i++)
	  free (Namen[i]);
	free (Namen);
	break;
      }
    }
  } else {
    Daten = NULL;
    Namen = NULL;
  }
};

/********************************************************/
/*              Alles zur Klasse Regel                  */
/********************************************************/
Regel::Regel (int xDimension, int yDimension, Parameter_Typ PT = Trapez)
{
  ((Dummy_Regel *) (this))->Dummy_Regel (xDimension, yDimension, PT);
};

Regel::Regel (const Regel & Das)
{
  (*((Dummy_Regel *) this)) = ((const Dummy_Regel &) Das);
};

Regel::~Regel ()
{
};

void 
Regel::print ()
{
  int i;

  printf ("Falls ");
  for (i = 0; i < xDim; i++) {
    printf ("%s", Namen[i]);
    Daten[i]->print ();
    if (i + 1 != xDim)
      printf ("und   ");
  }

  printf ("dann ");
  for (i = 0; i < yDim; i++) {
    printf ("%s", Namen[i + xDim]);
    Daten[i + xDim]->print ();
    if (i + 1 != xDim)
      printf ("und  ");
  }
}

void 
Regel::Setze_Dimensionen (int In, int Out)
{
  int i;
  Parameter_Typ PT = Trapez;

  if (xDim + yDim != 0)
    PT = Daten[0]->Lese_Parameter_Typ ();

  if ((In + Out) != (xDim + yDim)) {
    for (i = 0; i < xDim + yDim; i++) {
      free (Namen[i]);
      delete Daten[i];
    }
    free (Namen);
    free (Daten);
    Namen = NULL;
    Daten = NULL;
    if ((In + Out) != 0) {
      if ((Namen = (char **) malloc (sizeof (char *) * (In + Out))) == NULL)
	  Fehlermeldung ("Regel::Setze_Dimensionen", SPEICHERFEHLER);
      for (i = 0; i < xDim + yDim; i++) {
	if ((Namen[i] = (char *) malloc (sizeof (char) * NAMENLAENGE)) == NULL)
	    Fehlermeldung ("Regel::Setze_Dimensionen", SPEICHERFEHLER);
      }
      if ((Daten = (Parameter **) malloc (sizeof (Parameter *) * (In + Out))) == NULL)
	Fehlermeldung ("Regel::Setze_Dimensionen", SPEICHERFEHLER);
      switch (PT) {
      case Trapez:
	for (i = 0; i < In + Out; i++)
	  Daten[i] = new Trapez_Parameter ();
	break;
      case Konvex:
	for (i = 0; i < In + Out; i++)
	  Daten[i] = new Konvex_Parameter ();
	break;
      default:
	break;
      }
    } else
      Daten = NULL;
  }
  xDim = In;
  yDim = Out;
};

void 
Regel::Setze_xDimension (int i)
{
  yDim = yDim + xDim - i;
  xDim = i;
};

void 
Regel::Setze_yDimension (int i)
{
  xDim = xDim + yDim - i;
  yDim = i;
};

void 
Regel::Berechne (DVektor & Eingabe, Regel_Ausgabe & Ausgabe)
{
  int i;

  Ausgabe.Setze_Dim (xDim, yDim);
  Ausgabe.Uebereinstimmung = 1;
  /* zunaechst die Hoehe berechnen */
  for (i = 0; i < xDim; i++) {
    Ausgabe.InputHoehen[i] = Daten[i]->Berechne_Hoehe (Eingabe[i]);
    if (Ausgabe.InputHoehen[i] < Ausgabe.Uebereinstimmung)
      Ausgabe.Uebereinstimmung = Ausgabe.InputHoehen[i];
  }

  /* Jetzt Schwerpunkt bestimmen */
  for (i = xDim; i < xDim + yDim; i++) {	/* alle Ausgaben */
    Ausgabe.Ergebnisse[i - xDim] =
      Daten[i]->Berechne_Schwerpunkt (Ausgabe.Uebereinstimmung,
				      Ausgabe.X_OutputKurve[i - xDim],
				      Ausgabe.Y_OutputKurve[i - xDim]);
  }
};

void 
Regel::Berechne (DVektor & Eingabe, BVektor & Diese_Eingaben,
		 BVektor & Diese_Ausgaben, Regel_Ausgabe & Ausgabe)
{
  int i;

  /* zunaechst die Hoehe berechnen */
  Ausgabe.Setze_Dim (xDim, yDim);
  if (Diese_Eingaben.Anzahl_gesetzt () != 0) {
    Ausgabe.Uebereinstimmung = 1;
    for (i = 0; i < xDim; i++) {
      if (Diese_Eingaben[i]) {
	Ausgabe.InputHoehen[i] = Daten[i]->Berechne_Hoehe (Eingabe[i]);
	if (Ausgabe.InputHoehen[i] < Ausgabe.Uebereinstimmung)
	  Ausgabe.Uebereinstimmung = Ausgabe.InputHoehen[i];
      } else
	Ausgabe.InputHoehen[i] = 0;
    }
  } else
    Ausgabe.Uebereinstimmung = 0;

  /* Jetzt Schwerpunkt bestimmen */
  for (i = xDim; i < xDim + yDim; i++) {	/* alle Ausgaben */
    if (Diese_Ausgaben[i - xDim]) {
      Ausgabe.Ergebnisse[i - xDim] =
	Daten[i]->Berechne_Schwerpunkt (Ausgabe.Uebereinstimmung,
					Ausgabe.X_OutputKurve[i - xDim],
					Ausgabe.Y_OutputKurve[i - xDim]);
    } else {
      Ausgabe.Ergebnisse[i - xDim] = 0;
      Ausgabe.X_OutputKurve[i - xDim]. ~ DVektor ();