verfahren.cc

模糊聚类的算法实现程序

/********************************************************/
/*   filename: verfahren.cc                             */
/*                                                      */
/********************************************************/
/* programmed by: Oliver Wagner                         */
/* last change: 22-03-95                                */
/********************************************************/
#include "verfahren.h"

void 
Verfahren1 (Datensatz & DieDaten, Regelbasis & ResultRegeln,
	    Clustering & ResultCluster)
{
  int i;

  ResultRegeln. ~ Regelbasis ();

  printf ("\nVerfahren1\n");
/**********************************/
/**** Cluster im Output finden ****/
/**********************************/
  {
    BVektor DieseClustern (DieDaten.Lese_InputDim () + DieDaten.Lese_OutputDim (), NULL);

    for (i = DieDaten.Lese_InputDim ();
	 i < DieDaten.Lese_InputDim () + DieDaten.Lese_OutputDim ();
	 i++)
      DieseClustern.Setze_i (i, TRUE);

    ResultCluster.Setze_relevant (DieseClustern);
    ResultCluster.Clustere (DieDaten.Lese_Daten ());
  }
/**** Cluster im Output finden ****/

/****************************************/
/********** Regeln finden ***************/
/****************************************/
  {
    BVektor DieseInputs, DieseOutputs;
/*********************************************/
    /*          PARAMETER IDENTIFIKATION         */
/*********************************************/
    DieseInputs = Parameter_Identifikation (ResultCluster.Lese_Zugehoerigkeit (),
					    DieDaten.Lese_InputDim (),
					    DieDaten.Lese_OutputDim (),
					    DieDaten.Lese_Daten ());

    DieseOutputs.BVektor (DieDaten.Lese_OutputDim (), NULL);
    for (i = 0; i < DieDaten.Lese_OutputDim (); i++)
      DieseOutputs.Setze_i (i, TRUE);

    DieDaten.Setze_Relevant (DieseInputs.concat (DieseOutputs));
/*****************************************/
    /* jetzt Regeln fuer relevante Parameter */
/*****************************************/
    ResultRegeln = Finde_Regeln (ResultCluster,
				 CLUSTER_KONVEXGRENZE,
				 DieDaten,
				 DieDaten.Lese_InputDim (),
				 DieseInputs.concat (DieseOutputs),
				 Trapez);
  }
/****      Regeln finden       ****/
/*    double Test,das;
   for(Test=-9 ; Test <= 9 ; Test++)
   {
   ResultRegeln.Berechne(&Test,&das);
   printf("%f:%f\n",Test,das);
   } */

  printf ("\nO.K.\n");
  ResultRegeln.print ();
};

/********************************************************************/
/********************************************************************/
BVektor 
Parameter_Identifikation (DMatrix & Zugehoerigkeit,
			  int InputDim, int OutputDim,
			  DVektorArray & Daten)
  return Result (InputDim, NULL);
{
  int VektorNr, i, j, k, GroesseA, GroesseB, DimNr, guter_Index, aktuelleDim;
  DVektorArray VektorenA, VektorenB, OutputA, OutputB;
  DVektor VektorBuffer;
  BVektor ProjBool (InputDim, NULL), Output (OutputDim, NULL);
  double Fehler = MAXDOUBLE, FehlerBuffer = MAXDOUBLE;
  char Fertig;
  Regelbasis RegelnA, RegelnB;
  DMatrix A, B;			/* Y-Werte der Kurven */
/************TEST***************/
/**/ for(i=0;i<InputDim;i++) /**/
/**/ Result.Setze_i(i,TRUE); /**/
/**/ return(Result);	     /**/
/*******************************/
/********************************************/
/* Zunaechst einige Elemente initialisieren */
/********************************************/
  for (i = 0; i < OutputDim; i++)
    Output.Setze_i (i, TRUE);
  /* Die Zugehoerigkeiten als Zwei Matrizen */
  GroesseA = Daten.Lese_Groesse () / 2;
  GroesseB = Daten.Lese_Groesse () - GroesseA;
  A.DMatrix (Zugehoerigkeit.Lese_Dim_m (), GroesseA, NULL);
  B.DMatrix (Zugehoerigkeit.Lese_Dim_m (), GroesseB, NULL);
  for (i = 0; i < Zugehoerigkeit.Lese_Dim_m (); i++) {
    for (j = 0, k = 0; k < GroesseA; j += 2)
      A.Setze_i_j (i, k++, Zugehoerigkeit.Lese_i_j (i, j));
    for (j = 1, k = 0; k < GroesseB; j += 2)
      B.Setze_i_j (i, k++, Zugehoerigkeit.Lese_i_j (i, j));
  }
  /* Ausgaben fuer die Modelle */
  OutputA.DVektorArray (OutputDim, GroesseA, NULL);
  OutputB.DVektorArray (OutputDim, GroesseB, NULL);
  for (DimNr = 0; DimNr < OutputDim; DimNr++) {
    for (VektorNr = 0, i = 0; i < GroesseA; VektorNr += 2)
      OutputA.Setze_Vektor (i++, DimNr, Daten[VektorNr][DimNr + InputDim]);
    for (VektorNr = 1, i = 0; i < GroesseB; VektorNr += 2)
      OutputB.Setze_Vektor (i++, DimNr, Daten[VektorNr][DimNr + InputDim]);
  }
  /* Zwei Gruppen von Daten */
  VektorenA.DVektorArray (Daten.Lese_Dim (), GroesseA, NULL);
  VektorenB.DVektorArray (Daten.Lese_Dim (), GroesseB, NULL);
  for (VektorNr = 0, i = 0; i < GroesseA; VektorNr += 2)
    VektorenA.Setze_Vektor (i++, Daten[VektorNr]);
  for (VektorNr = 1, i = 0; i < GroesseB; VektorNr += 2)
    VektorenB.Setze_Vektor (i++, Daten[VektorNr]);
/**************************/
/* Jetzt geht es aber los */
/**************************/
  aktuelleDim = 0;
  do {
    aktuelleDim++;
    Fertig = TRUE;
    VektorBuffer.DVektor (aktuelleDim, 0, NULL);
    for (DimNr = 0; DimNr < InputDim; DimNr++) {
      if (Result.Lese_i (DimNr) == FALSE) {	/* Dimension soll ja um 1 hoeher werden */
	ProjBool.Setze_i (DimNr, TRUE);

/* erst einmal auslassen */

/*        RegelnA=Finde_Regeln(A,CLUSTER_KONVEXGRENZE,VektorenA,aktuelleDim,
   ProjBool.concat(Output),Trapez);
   RegelnB=Finde_Regeln(B,CLUSTER_KONVEXGRENZE,VektorenB,aktuelleDim,
   ProjBool.concat(Output),Trapez);
   FehlerBuffer=Berechne_RC(VektorenA,VektorenB,
   OutputA,OutputB,
   RegelnA,RegelnB); */
	RegelnA. ~ Regelbasis ();
	RegelnB. ~ Regelbasis ();

	if (FehlerBuffer < Fehler) {
	  Fertig = FALSE;	/* Verbesserung war moeglich */
	  guter_Index = DimNr;
	  Fehler = FehlerBuffer;
	}
	ProjBool.Setze_i (DimNr, FALSE);	/*wieder zurueck */
      }				/* if(Result->Lese_i(DimNr) == FALSE) */
    }				/* for(DimNr=0 ; DimNr < InputDim ; DimNr++) */
    if (Fertig == FALSE)
      Result.Setze_i (guter_Index, TRUE);
    VektorenA. ~ DVektorArray ();
    VektorenB. ~ DVektorArray ();
    VektorBuffer. ~ DVektor ();
  } while ((!(Fertig)) && (aktuelleDim < InputDim));	/* wieder groesserer Fehler ?? */
};


/*****************************************************************/
void 
Verfahren2 (Datensatz & DieDaten, Regelbasis & ResultRegeln,
	    Clustering & ResultCluster)
{
  int i;

  printf ("\nVerfahren2\n");
  ResultRegeln. ~ Regelbasis ();
/************************/
/**** Cluster finden ****/
/************************/
  {
    BVektor DieseClustern (DieDaten.Lese_InputDim () + DieDaten.Lese_OutputDim (), NULL);

    for (i = 0; i < DieDaten.Lese_InputDim () + DieDaten.Lese_OutputDim (); i++)
      DieseClustern.Setze_i (i, TRUE);

    ResultCluster.Setze_relevant (DieseClustern);
    ResultCluster.Clustere (DieDaten.Lese_Daten ());
  }
/**** Cluster im Output finden ****/


/*********************************/
  /*    relevante Input setzen     */
/*********************************/
  {
    BVektor DieseInputs (DieDaten.Lese_InputDim ()), DieseOutputs (DieDaten.Lese_OutputDim ());


    for (i = 0; i < DieDaten.Lese_InputDim (); i++)
      DieseInputs.Setze_i (i, TRUE);
    for (i = 0; i < DieDaten.Lese_OutputDim (); i++)
      DieseOutputs.Setze_i (i, TRUE);

    DieDaten.Setze_Relevant (DieseInputs.concat (DieseOutputs));
/*********************************/
    /*  Regeln berechnen lassen      */
/*********************************/
    ResultRegeln = Ermittle_Regeln (ResultCluster,
				    CLUSTER_KONVEXGRENZE,
				    DieDaten,
				    DieDaten.Lese_InputDim (),
				 DieseInputs.concat (DieseOutputs), Trapez);

/*    double Test,das;
   for(Test=-9 ; Test <= 9 ; Test++)
   {
   ResultRegeln.Berechne(&Test,&das);
   printf("%f:%f\n",Test,das);
   } */

  }
};