Objektorientierte Implementierung einer Fuzzygröße

class Fuzzygroesse
{
    public:
        double p[3];
        bool links_unbegrenzt, rechts_unbegrenzt;
        Fuzzygroesse(double p0, double p1, double p2, 
                     bool links_unbegrenzt=false, bool rechts_unbegrenzt=false)
        {
            this->p[0] = p0;
            this->p[1] = p1;
            this->p[2] = p2;
            this->links_unbegrenzt  = links_unbegrenzt;
            this->rechts_unbegrenzt = rechts_unbegrenzt;
            //Sinnvolle Festlegung von p0 und p2 bei teilweise unbegrenzten Funktionen,
            //damit die Fallunterscheidung unten richtig funktioniert:
            if(links_unbegrenzt == true)
                p[0]=p[1]-1.0;
            if(rechts_unbegrenzt == true)
                p[2]=p[1]+1.0;
        }
        double berechneZugehoerigkeitswert(double x)
        {
            //Behandlung der trivialen Fälle:
            if(links_unbegrenzt==true && x<=p[1])
                return 1.0;
            if(rechts_unbegrenzt==true && x>=p[1])
                return 1.0;
            if(x<=p[0])
                return 0.0;
            if(x>=p[2])
                return 0.0;
            if(x<p[1]) //steigende Gerade
                return (x-p[0])/(p[1]-p[0]);
            else       //fallende Gerade
                return (x-p[2])/(p[1]-p[2]);
        }
        double berechneSchwerpunkt(double aktivierung)
        {
            if(aktivierung==0.0)  //Division durch Null vermeiden.
                return 0.0;
            //Schnittpunkte mit y=aktivierung bestimmen:
            double x1 = p[0] + aktivierung*(p[1]-p[0]);
            double x2 = p[2] + aktivierung*(p[1]-p[2]);
            //Flächen von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double A0 = 0.5*(x1-p[0])*aktivierung;
            double A1 = (x2-x1)*aktivierung;
            double A2 = 0.5*(p[2]-x2)*aktivierung;
            //Schwerpunkte von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double s0 = p[0]+(2.0/3.0)*(x1-p[0]);
            double s1 = 0.5*(x1+x2);
            double s2 = p[2]-(2.0/3.0)*(p[2]-x2);
            return (s0*A0+s1*A1+s2*A2)/(A0+A1+A2);
        }
        double berechneFlaeche(double aktivierung)
        {
            //Schnittpunkte mit y=aktivierung bestimmen:
            double x1 = p[0] + aktivierung*(p[1]-p[0]);
            double x2 = p[2] + aktivierung*(p[1]-p[2]);
            //Flächen von erstem Dreieck, Rechteck und zweitem Dreieck bestimmen:
            double A0 = 0.5*(x1-p[0])*aktivierung;
            double A1 = (x2-x1)*aktivierung;
            double A2 = 0.5*(p[2]-x2)*aktivierung;
            return A0+A1+A2;
        }
};

Code 0-1: Quellcode der Klasse Fuzzygroesse in der Datei Fuzzygroesse.h

R=7 und T=12.5, =>
Rkalt   = 0.6
Rmittel = 0.4
Rwarm   = 0
Tkalt   = 0.5
Twarm   = 0.5
R=5 und T=7, =>
Rkalt   = 1
Rmittel = 0
Rwarm   = 0
Tkalt   = 0.866667
Twarm   = 0.133333

Code 0-2: Ihr Programm sollte obige Ausgabe liefern.