Hi 
Ein Kollege und ich haben unser erstes Fuzzy-Programm geschrieben. Es gibt 3 Temperaturkurven (temperatureFuncs) und 3 Kurven zum Dosieren eines Medikaments (doseFuncs). Aufgrund einer gemessenen Temperatur wird dann eine bestimmte Dosis berechnet.
Als Vorlage diente ein Programm aus dem Buch "Programmierung naturanaloger Verfahren", ISBN 978-3-8348-0822-6
Uns würde interessieren, ob uns noch Fehler unterlaufen sind oder man irgendetwas noch besser programmieren kann. Das Programm sollte perfekt sein. Wenn euch irgendetwas nicht gefällt, egal was, dann würde uns das interessieren.
Ein Kollege und ich haben unser erstes Fuzzy-Programm geschrieben. Es gibt 3 Temperaturkurven (temperatureFuncs) und 3 Kurven zum Dosieren eines Medikaments (doseFuncs). Aufgrund einer gemessenen Temperatur wird dann eine bestimmte Dosis berechnet.
Als Vorlage diente ein Programm aus dem Buch "Programmierung naturanaloger Verfahren", ISBN 978-3-8348-0822-6
Uns würde interessieren, ob uns noch Fehler unterlaufen sind oder man irgendetwas noch besser programmieren kann. Das Programm sollte perfekt sein. Wenn euch irgendetwas nicht gefällt, egal was, dann würde uns das interessieren.
Java:
class Fuzzy
{
private double[][] inputFuncs;
private double[][] outputFuncs;
private double[][] trpzs; // Trapez-Parameter
/**
* Für inputFuncs und outputsFuncs gilt:
* - inputFuncs und outputsFuncs müssen die gleiche Anzahl an Kurven (Elementen) haben.
* - Für alle Kurven gelten:
* - Die Anzahl der x-Werte müssen bei allen Kurven gleich sein.
* - Je Kurve muss jeder x-Wert mindestens gleichgroß dem vorhergehenden x-Wert sein.
* - Negative x-Werte sind erlaubt.
* @param double[][] inputFuncs Messwert-Kurvensets
* @param double[][] outputFuncs Ausgangs-Funktionen
*/
public Fuzzy(double[][] inputFuncs, double[][] outputFuncs)
{
this.inputFuncs = inputFuncs;
this.outputFuncs = outputFuncs;
// Trapez-Breitenangaben für die Ausgabe-Kurven:
trpzs();
}
/**
* Erzeugt die Trapez-Parameter.
*/
private void trpzs()
{
trpzs = new double[outputFuncs.length][3];
for(int i = 0; i < outputFuncs.length; ++i)
{
double[] xs = outputFuncs[i];
double[] params = // Trapez-Parameter b bis d (a ergibt sich aus b, c und d)
{
xs[3] - xs[0], // b
xs[1] - xs[0], // c
xs[3] - xs[2] // d
};
trpzs[i] = params;
}
}
/**
* Schneidet eine Kurve mit einem bestimmten x-Wert.
* @param double[] xs 4 x-Werte der Trapez-Kurve (ev. mit senkrechten Flanken, oder ein Dreieck)
* @param double x
* @return double y-Wert [0, 1]
*/
private static double y(double[] xs, double x)
{
if(x < xs[3])
{
if(x <= xs[2])
{
if(x < xs[1])
{
if(x <= xs[0])
{
return 0.0;
}
// steigende Flanke:
if(xs[1] == xs[0])
{
// Beginnt eine Kurve ganz links oben, dann beginnt sie gleich bei 1.
return 1.0;
}
return (x - xs[0]) / (xs[1] - xs[0]);
}
return 1.0;
}
// fallende Fanke:
if(xs[3] == xs[2])
{
// Endet eine Kurve ganz rechts oben, dann endet sie noch bei 1.
return 1.0;
}
return (xs[3] - x) / (xs[3] - xs[2]);
}
return 0.0;
}
/**
* Liefert die x-Koordinate des Schwerpunkts einer um y geköpften Kurve.
* @param double[] params Trapez-Parameter
* @param double y Erfüllungsgrad [0, 1]
* @return double x-Wert
*/
private static double x(double[] params, double y)
{
double d = params[2] * y;
double c = params[1] * y;
double b = params[0];
double a = b - c - d;
return
(
2.0 * a * c +
a * a +
a * b +
b * b +
b * c
) /
(3.0 * (a + b));
}
/**
* Schneidet die Kurve mit den Messwerten.
* @param double x Messwert
* @return double[] Erfüllungsgrade
*/
private double[] fuzzy(double x)
{
// Kurven mit den Messwerten schneiden:
double[] ys = new double[inputFuncs.length]; // Schnittpunkte mit Kurven (y-Werte)
for(int i = 0; i < inputFuncs.length; ++i) // je unscharfe Menge (ZGF)
{
ys[i] = y(inputFuncs[i], x);
}
return ys;
}
/**
* Liefert die x-Koordinate des Schwerpunkts über alle geköpften Kurve.
* @param double[] ys Erfüllungsgrade, ein Erfüllungsgrad liegt im Bereich [0, 1]
* @return double x-Wert
*/
private double defuzzy(double[] ys)
{
double sum0 = 0;
double sum1 = 0;
for(int i = 0; i < outputFuncs.length; ++i)
{
sum0 += ys[i] * (outputFuncs[i][0] + x(trpzs[i], ys[i]));
sum1 += ys[i];
}
return sum0 / sum1;
}
/**
* Liefert den zu den Messwerten zugehörigen Ergebniswert.
* @param double x Messwert im Bereich [kleinster inputFuncs-x-Wert, größter inputFuncs-x-Wert]
* @return double
*/
public double calc(double x)
{
// Fuzzyfizierung:
double[] ys = fuzzy(x);
// Defuzzyfizierung:
return defuzzy(ys);
}
}
class Main1
{
public static void main(String[] args)
{
// Kurven für "Temperatur" á 3 unscharfen Mengen (Trapez-x-Werte):
double[][] temperatureFuncs = // unscharfe Menge (ZGFs)
{
{37.0, 37.0, 37.5, 38.5}, // "leicht"
{37.5, 38.5, 38.5, 39.5}, // "mäßig"
{38.5, 39.5, 41.5, 41.5} // "hoch"
};
// Kurven für "Dosis" á 3 unscharfen Mengen (Trapez-x-Werte):
double[][] doseFuncs = // unscharfe Menge (ZGFs)
{
{ 0.0, 0.0, 200.0, 600.0}, // "klein"
{200.0, 600.0, 600.0, 1000.0}, // "mittel"
{600.0, 1000.0, 1000.0, 1000.0} // "hoch"
};
// Regeln:
// - leichtes Fieber -> kleine Dosis
// - mäßiges Fieber -> mittlere Dosis
// - hohes Fieber -> hohe Dosis
Fuzzy fuzzy = new Fuzzy(temperatureFuncs, doseFuncs);
double temperature = 37.9; // Temperatur (in Grad Celsius)
double dose = fuzzy.calc(temperature); // Dosis (in mg)
System.out.println(dose);
}
}
Zuletzt bearbeitet:
