Interpreter arbeitet mit Zugehörigkeit statt Double

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/AlgebraischesProdukt.java

@@ -27,13 +27,13 @@
 package de.bsvrz.iav.fuzzylib.fuzzylib;
 
 /**
- * Bestimmt das algebraische Produkt zweier Gleitkommazahlen.
+ * Bestimmt das algebraische Produkt zweier Zugehörigkeiten.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class AlgebraischesProdukt extends BiOperation {
+public final class AlgebraischesProdukt extends BiOperation<Zugehoerigkeit> {
 
-    public AlgebraischesProdukt(Ausdruck<Double> a, Ausdruck<Double> b) {
+    public AlgebraischesProdukt(Ausdruck<Zugehoerigkeit> a, Ausdruck<Zugehoerigkeit> b) {
         super(Funktionen::algebraischesProdukt, a, b);
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/AlgebraischesSumme.java

@@ -27,13 +27,13 @@
 package de.bsvrz.iav.fuzzylib.fuzzylib;
 
 /**
- * Bestimmt die algebraische Summe zweier Gleitkommazahlen.
+ * Bestimmt die algebraische Summe zweier Zugehörigkeiten.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class AlgebraischesSumme extends BiOperation {
+public final class AlgebraischesSumme extends BiOperation<Zugehoerigkeit> {
 
-    public AlgebraischesSumme(Ausdruck<Double> a, Ausdruck<Double> b) {
+    public AlgebraischesSumme(Ausdruck<Zugehoerigkeit> a, Ausdruck<Zugehoerigkeit> b) {
         super(Funktionen::algebraischesSumme, a, b);
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/BiOperation.java

@@ -30,32 +30,32 @@ import java.util.*;
 import java.util.function.*;
 
 /**
- * Definiert eine Operation auf zwei Gleitkommazahlen.
+ * Definiert eine Operation mit zwei Operatoren.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public class BiOperation implements Ausdruck<Double> {
+public class BiOperation<T> implements Ausdruck<T> {
 
-    private BiFunction<Double, Double, Double> operation;
-    private final Ausdruck<Double> a;
-    private final Ausdruck<Double> b;
+    private BiFunction<T, T, T> operation;
+    private final Ausdruck<T> a;
+    private final Ausdruck<T> b;
 
-    public BiOperation(BiFunction<Double, Double, Double> operation, Ausdruck<Double> a, Ausdruck<Double> b) {
+    public BiOperation(BiFunction<T, T, T> operation, Ausdruck<T> a, Ausdruck<T> b) {
         this.operation = Objects.requireNonNull(operation, "operation");
         this.a = Objects.requireNonNull(a, "a");
         this.b = Objects.requireNonNull(b, "b");
     }
 
-    public Ausdruck<Double> getA() {
+    public Ausdruck<T> getA() {
         return a;
     }
 
-    public Ausdruck<Double> getB() {
+    public Ausdruck<T> getB() {
         return b;
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public T interpretiere(Map<String, ?> kontext) {
         return operation.apply(a.interpretiere(kontext), b.interpretiere(kontext));
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Funktionen.java

@@ -26,10 +26,11 @@
 
 package de.bsvrz.iav.fuzzylib.fuzzylib;
 
+import java.util.*;
 import java.util.function.*;
 
 /**
- * Definiert mathematische Funktionen.
+ * Definiert mathematische Funktionen auf Zugehörigkeiten.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
@@ -39,64 +40,81 @@ public final class Funktionen {
         // utility class
     }
 
-    public static Double minimum(Double a, Double b) {
-        if (a == null || b == null) {
-            return null;
+    public static Zugehoerigkeit minimum(Zugehoerigkeit a, Zugehoerigkeit b) {
+        Objects.requireNonNull(a, "a");
+        Objects.requireNonNull(b, "b");
+        if (a.isNull() || b.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return Math.min(a, b);
+        return Zugehoerigkeit.von(Math.min(a.getWert(), b.getWert()));
     }
 
-    public static Double maximum(Double a, Double b) {
-        if (a == null || b == null) {
-            return null;
+    public static Zugehoerigkeit maximum(Zugehoerigkeit a, Zugehoerigkeit b) {
+        Objects.requireNonNull(a, "a");
+        Objects.requireNonNull(b, "b");
+        if (a.isNull() || b.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return Math.max(a, b);
+        return Zugehoerigkeit.von(Math.max(a.getWert(), b.getWert()));
     }
 
-    public static Double komplement(Double a) {
-        if (a == null) {
-            return null;
+    public static Zugehoerigkeit komplement(Zugehoerigkeit a) {
+        Objects.requireNonNull(a, "a");
+        if (a.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return 1.0 - a;
+        return Zugehoerigkeit.von(1.0 - a.getWert());
     }
 
-    public static Double implikation(Double a, Double b) {
+    public static Zugehoerigkeit implikation(Zugehoerigkeit a, Zugehoerigkeit b) {
         return maximum(komplement(a), b);
     }
 
-    public static Double algebraischesProdukt(Double a, Double b) {
-        if (a == null || b == null) {
-            return null;
+    public static Zugehoerigkeit algebraischesProdukt(Zugehoerigkeit a, Zugehoerigkeit b) {
+        Objects.requireNonNull(a, "a");
+        Objects.requireNonNull(b, "b");
+        if (a.isNull() || b.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return a * b;
+        return Zugehoerigkeit.von(a.getWert() * b.getWert());
     }
 
-    public static Double algebraischesSumme(Double a, Double b) {
-        if (a == null || b == null) {
-            return null;
+    public static Zugehoerigkeit algebraischesSumme(Zugehoerigkeit a, Zugehoerigkeit b) {
+        Objects.requireNonNull(a, "a");
+        Objects.requireNonNull(b, "b");
+        if (a.isNull() || b.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return (a + b) - (a * b);
+        return Zugehoerigkeit.von(a.getWert() + b.getWert() - (a.getWert() * b.getWert()));
     }
 
-    public static Double gammaOperator(Double a, Double b, Double gamma) {
-        if (a == null || b == null || gamma == null) {
-            return null;
+    public static Zugehoerigkeit gammaOperator(Zugehoerigkeit a, Zugehoerigkeit b, Zugehoerigkeit gamma) {
+        Objects.requireNonNull(a, "a");
+        Objects.requireNonNull(b, "b");
+        Objects.requireNonNull(gamma, "gamma");
+        if (a.isNull() || b.isNull() || gamma.isNull()) {
+            return Zugehoerigkeit.NULL;
         }
 
-        return Math.pow(a * b, 1 - gamma) * Math.pow((a + b) - (a * b), gamma);
+        double a1 = a.getWert();
+        double b1 = b.getWert();
+        double gamma1 = gamma.getWert();
+        double z1 = Math.pow(a1 * b1, 1 - gamma1) * Math.pow((a1 + b1) - (a1 * b1), gamma1);
+        return Zugehoerigkeit.von(z1);
     }
 
-    public static BiFunction<Double, Double, Double> gammaOperator(Double gamma) {
-        if (gamma == null) {
-            return (a, b) -> null;
+    public static BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> gammaOperator(Zugehoerigkeit gamma) {
+        Objects.requireNonNull(gamma, "gamma");
+        if (gamma.isNull()) {
+            return (a, b) -> Zugehoerigkeit.NULL;
         }
 
-        return (a, b) -> Math.pow(a * b, 1 - gamma) * Math.pow((a + b) - (a * b), gamma);
+        return (a, b) -> gammaOperator(a, b, gamma);
     }
 
 }

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/GammaOperator.java

@@ -29,32 +29,36 @@ package de.bsvrz.iav.fuzzylib.fuzzylib;
 import java.util.*;
 
 /**
- * Bestimmt das Ergebnis des Gammaoperators zweier Gleitkommazahlen.
+ * Bestimmt das Ergebnis des Gammaoperators zweier Zugehörigkeiten.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class GammaOperator implements Ausdruck<Double> {
+public final class GammaOperator implements Ausdruck<Zugehoerigkeit> {
 
-    private final Ausdruck<Double> a;
-    private final Ausdruck<Double> b;
-    private final Ausdruck<Double> gamma;
+    private final Ausdruck<Zugehoerigkeit> a;
+    private final Ausdruck<Zugehoerigkeit> b;
+    private final Ausdruck<Zugehoerigkeit> gamma;
 
-    public GammaOperator(Ausdruck<Double> a, Ausdruck<Double> b, Ausdruck<Double> gamma) {
+    public GammaOperator(Ausdruck<Zugehoerigkeit> a, Ausdruck<Zugehoerigkeit> b, Ausdruck<Zugehoerigkeit> gamma) {
         this.a = Objects.requireNonNull(a, "a");
         this.b = Objects.requireNonNull(b, "b");
         this.gamma = Objects.requireNonNull(gamma, "gamma");
     }
 
-    public Ausdruck<Double> getA() {
+    public Ausdruck<Zugehoerigkeit> getA() {
         return a;
     }
 
-    public Ausdruck<Double> getB() {
+    public Ausdruck<Zugehoerigkeit> getB() {
         return b;
     }
 
+    public Ausdruck<Zugehoerigkeit> getGamma() {
+        return gamma;
+    }
+
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public Zugehoerigkeit interpretiere(Map<String, ?> kontext) {
         return Funktionen.gammaOperator(
                 a.interpretiere(kontext),
                 b.interpretiere(kontext),

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Implikation.java

@@ -27,13 +27,13 @@
 package de.bsvrz.iav.fuzzylib.fuzzylib;
 
 /**
- * Bestimmt die Implikation zweier Gleitkommazahlen.
+ * Bestimmt die Implikation zweier Zugehörigkeiten.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class Implikation extends BiOperation {
+public final class Implikation extends BiOperation<Zugehoerigkeit> {
 
-    public Implikation(Ausdruck<Double> a, Ausdruck<Double> b) {
+    public Implikation(Ausdruck<Zugehoerigkeit> a, Ausdruck<Zugehoerigkeit> b) {
         super(Funktionen::implikation, a, b);
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/InterpreterException.java

-/*
- * Segment 5 Intelligente Analyseverfahren, SWE 5.4 Funktionen Fuzzy
- * Copyright (C) 2007-2015 BitCtrl Systems GmbH
- *
- * This library is free software; you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
- * any later version.
- *
- * This library is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
- *
- * Contact Information:
- * BitCtrl Systems GmbH
- * Weißenfelser Straße 67
- * 04229 Leipzig
- * Phone: +49 341-490670
- * mailto: info@bitctrl.de
- */
-
-package de.bsvrz.iav.fuzzylib.fuzzylib;
-
-public class InterpreterException extends RuntimeException {
-
-    public InterpreterException(String message) {
-        super(message);
-    }
-
-    public InterpreterException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-}

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Komplement.java

@@ -27,13 +27,13 @@
 package de.bsvrz.iav.fuzzylib.fuzzylib;
 
 /**
- * Bestimmt das Komplement einer Zahl.
+ * Bestimmt das Komplement einer Zugehörigkeit.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class Komplement extends Operation {
+public final class Komplement extends Operation<Zugehoerigkeit> {
 
-    public Komplement(Ausdruck<Double> a) {
+    public Komplement(Ausdruck<Zugehoerigkeit> a) {
         super(Funktionen::komplement, a);
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Maximum.java

@@ -33,29 +33,29 @@ import java.util.*;
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class Maximum implements Ausdruck<Double> {
+public final class Maximum implements Ausdruck<Zugehoerigkeit> {
 
-    private final List<? extends Ausdruck<Double>> operanden;
+    private final List<? extends Ausdruck<Zugehoerigkeit>> operanden;
 
-    public Maximum(List<? extends Ausdruck<Double>> operanden) {
+    public Maximum(List<? extends Ausdruck<Zugehoerigkeit>> operanden) {
         Objects.requireNonNull(operanden, "operanden");
         this.operanden = Collections.unmodifiableList(new ArrayList<>(operanden));
     }
 
-    public List<? extends Ausdruck<Double>> getOperanden() {
+    public List<? extends Ausdruck<Zugehoerigkeit>> getOperanden() {
         return operanden;
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public Zugehoerigkeit interpretiere(Map<String, ?> kontext) {
         if (operanden.stream().anyMatch(Objects::isNull)) {
-            return null;
+            return Zugehoerigkeit.NULL;
         }
 
         return operanden.stream()
                 .map(o -> o.interpretiere(kontext))
                 .reduce(Funktionen::maximum)
-                .orElseThrow(() -> new InterpreterException("Für die Bestimmung des Maximums wird mindestens ein Operand benötigt."));
+                .orElseThrow(() -> new IllegalStateException("Für die Bestimmung des Maximums wird mindestens ein Operand benötigt."));
     }
 
     @Override

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Minimum.java

@@ -33,29 +33,29 @@ import java.util.*;
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class Minimum implements Ausdruck<Double> {
+public final class Minimum implements Ausdruck<Zugehoerigkeit> {
 
-    private final List<? extends Ausdruck<Double>> operanden;
+    private final List<? extends Ausdruck<Zugehoerigkeit>> operanden;
 
-    public Minimum(List<? extends Ausdruck<Double>> operanden) {
+    public Minimum(List<? extends Ausdruck<Zugehoerigkeit>> operanden) {
         Objects.requireNonNull(operanden, "operanden");
         this.operanden = Collections.unmodifiableList(new ArrayList<>(operanden));
     }
 
-    public List<? extends Ausdruck<Double>> getOperanden() {
+    public List<? extends Ausdruck<Zugehoerigkeit>> getOperanden() {
         return operanden;
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public Zugehoerigkeit interpretiere(Map<String, ?> kontext) {
         if (operanden.stream().anyMatch(Objects::isNull)) {
-            return null;
+            return Zugehoerigkeit.NULL;
         }
 
         return operanden.stream()
                 .map(o -> o.interpretiere(kontext))
                 .reduce(Funktionen::minimum)
-                .orElseThrow(() -> new InterpreterException("Für die Bestimmung des Minimums wird mindestens ein Operand benötigt."));
+                .orElseThrow(() -> new IllegalStateException("Für die Bestimmung des Minimums wird mindestens ein Operand benötigt."));
     }
 
     @Override

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Operation.java

@@ -30,26 +30,26 @@ import java.util.*;
 import java.util.function.*;
 
 /**
- * Definiert eine Operation auf einer Gleitkommazahl.
+ * Definiert eine Operation mit einem Operator.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public class Operation implements Ausdruck<Double> {
+public class Operation<T> implements Ausdruck<T> {
 
-    private Function<Double, Double> operation;
-    private final Ausdruck<Double> a;
+    private Function<T, T> operation;
+    private final Ausdruck<T> a;
 
-    public Operation(Function<Double, Double> operation, Ausdruck<Double> a) {
+    public Operation(Function<T, T> operation, Ausdruck<T> a) {
         this.operation = Objects.requireNonNull(operation, "operation");
         this.a = Objects.requireNonNull(a, "a");
     }
 
-    public Ausdruck<Double> getA() {
+    public Ausdruck<T> getA() {
         return a;
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public T interpretiere(Map<String, ?> kontext) {
         return operation.apply(a.interpretiere(kontext));
     }
 

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Regel.java

@@ -42,23 +42,23 @@ import java.util.function.*;
  */
 public final class Regel implements Ausdruck<TermLiteral> {
 
-    private final Ausdruck<Double> praemisse;
+    private final Ausdruck<Zugehoerigkeit> praemisse;
     private final TermVariable konklusion;
     private final Sicherheitsgrad sicherheitsgrad;
-    private final BiFunction<Double, Double, Double> implikation;
+    private final BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> implikation;
 
-    public static RegelBuilder wenn(Ausdruck<Double> praemisse) {
+    public static RegelBuilder wenn(Ausdruck<Zugehoerigkeit> praemisse) {
         return new RegelBuilder(praemisse);
     }
 
-    private Regel(Ausdruck<Double> praemisse, TermVariable konklusion, Sicherheitsgrad sicherheitsgrad, BiFunction<Double, Double, Double> implikation) {
+    private Regel(Ausdruck<Zugehoerigkeit> praemisse, TermVariable konklusion, Sicherheitsgrad sicherheitsgrad, BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> implikation) {
         this.praemisse = praemisse;
         this.konklusion = konklusion;
         this.sicherheitsgrad = sicherheitsgrad;
         this.implikation = implikation;
     }
 
-    public Ausdruck<Double> getPraemisse() {
+    public Ausdruck<Zugehoerigkeit> getPraemisse() {
         return praemisse;
     }
 
@@ -72,14 +72,12 @@ public final class Regel implements Ausdruck<TermLiteral> {
 
     @Override
     public TermLiteral interpretiere(Map<String, ?> kontext) {
-        Term term = new Term(konklusion.getTerm(), Zugehoerigkeit.NULL);
+        Zugehoerigkeit z = Zugehoerigkeit.NULL;
         try {
-            Double z = implikation.apply(praemisse.interpretiere(kontext), sicherheitsgrad.getWert());
-            if (z != null) {
-                term = new Term(konklusion.getTerm(), Zugehoerigkeit.von(z));
-            }
-        } catch (VariableNichtDefiniertException ignored) {
+            z = implikation.apply(praemisse.interpretiere(kontext), Zugehoerigkeit.von(sicherheitsgrad.getWert()));
+        } catch (RuntimeException ignored) {
         }
+        Term term = new Term(konklusion.getTerm(), z);
         return new TermLiteral(konklusion.getFuzzyVariable(), term);
     }
 
@@ -95,12 +93,12 @@ public final class Regel implements Ausdruck<TermLiteral> {
      */
     public static class RegelBuilder {
 
-        private final Ausdruck<Double> praemisse;
+        private final Ausdruck<Zugehoerigkeit> praemisse;
         private TermVariable konklusion;
         private Sicherheitsgrad sicherheitsgrad = Sicherheitsgrad.DEFAULT;
-        private BiFunction<Double, Double, Double> operator = Funktionen::minimum;
+        private BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> operator = Funktionen::minimum;
 
-        RegelBuilder(Ausdruck<Double> praemisse) {
+        RegelBuilder(Ausdruck<Zugehoerigkeit> praemisse) {
             this.praemisse = Objects.requireNonNull(praemisse, "praemisse");
         }
 
@@ -114,7 +112,7 @@ public final class Regel implements Ausdruck<TermLiteral> {
             return this;
         }
 
-        public RegelBuilder benutzeFuerImplikation(BiFunction<Double, Double, Double> operator) {
+        public RegelBuilder benutzeFuerImplikation(BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> operator) {
             this.operator = Objects.requireNonNull(operator, "operator");
             return this;
         }

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/Regelbasis.java

@@ -47,7 +47,7 @@ public final class Regelbasis implements Ausdruck<Collection<FuzzyVariable>> {
     public static final Regelbasis NULL = new Regelbasis();
 
     private final List<Regel> regeln;
-    private final BiFunction<Double, Double, Double> akkumulation;
+    private final BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> akkumulation;
 
     public Regelbasis(Regel... regeln) {
         this(Arrays.asList(regeln));
@@ -57,11 +57,11 @@ public final class Regelbasis implements Ausdruck<Collection<FuzzyVariable>> {
         this(Funktionen::maximum, regeln);
     }
 
-    public Regelbasis(BiFunction<Double, Double, Double> akkumulation, Regel... regeln) {
+    public Regelbasis(BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> akkumulation, Regel... regeln) {
         this(akkumulation, Arrays.asList(regeln));
     }
 
-    public Regelbasis(BiFunction<Double, Double, Double> akkumulation, List<Regel> regeln) {
+    public Regelbasis(BiFunction<Zugehoerigkeit, Zugehoerigkeit, Zugehoerigkeit> akkumulation, List<Regel> regeln) {
         Objects.requireNonNull(regeln, "regeln");
         this.regeln = Collections.unmodifiableList(new ArrayList<>(regeln));
 
@@ -111,12 +111,8 @@ public final class Regelbasis implements Ausdruck<Collection<FuzzyVariable>> {
                 } else {
                     Zugehoerigkeit z1 = terme.get(index).getZugehoerigkeit();
                     Zugehoerigkeit z2 = term.getZugehoerigkeit();
-                    if (z1.nonNull() && z2.nonNull()) {
-                        Double z = akkumulation.apply(z1.getWert(), z2.getWert());
-                        term = new Term(term.getName(), Zugehoerigkeit.von(z));
-                    } else {
-                        term = new Term(term.getName(), Zugehoerigkeit.NULL);
-                    }
+                    Zugehoerigkeit z = akkumulation.apply(z1, z2);
+                    term = new Term(term.getName(), z);
                     terme.set(index, term);
                 }
             } else {

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/TermLiteral.java

@@ -29,12 +29,12 @@ package de.bsvrz.iav.fuzzylib.fuzzylib;
 import java.util.*;
 
 /**
- * Stellt einen definierten Term in einem Ausdruck dar, das Ergebnis die
- * Zugehörigkeit des Terms als Gleitkommazahl.
+ * Stellt einen Term in einem Ausdruck dar, das Ergebnis ist die Zugehörigkeit
+ * des Terms.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class TermLiteral implements Ausdruck<Double> {
+public final class TermLiteral implements Ausdruck<Zugehoerigkeit> {
 
     private final String fuzzyVariable;
     private final Term term;
@@ -53,12 +53,8 @@ public final class TermLiteral implements Ausdruck<Double> {
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
-        if (term.getZugehoerigkeit().nonNull()) {
-            return term.getZugehoerigkeit().getWert();
-        } else {
-            return null;
-        }
+    public Zugehoerigkeit interpretiere(Map<String, ?> kontext) {
+        return term.getZugehoerigkeit();
     }
 
     @Override

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/TermVariable.java

@@ -29,12 +29,12 @@ package de.bsvrz.iav.fuzzylib.fuzzylib;
 import java.util.*;
 
 /**
- * Stellt eine Variable eines Terms in einem Ausdruck dar, das Ergebnis die
- * Zugehörigkeit des Terms als Gleitkommazahl.
+ * Stellt eine Variable eines Terms in einem Ausdruck dar, das Ergebnis ist die
+ * Zugehörigkeit des Terms.
  *
  * @author BitCtrl Systems GmbH, Falko Schumann
  */
-public final class TermVariable implements Ausdruck<Double> {
+public final class TermVariable implements Ausdruck<Zugehoerigkeit> {
 
     private final String fuzzyVariable;
     private final String term;
@@ -53,21 +53,18 @@ public final class TermVariable implements Ausdruck<Double> {
     }
 
     @Override
-    public Double interpretiere(Map<String, ?> kontext) {
+    public Zugehoerigkeit interpretiere(Map<String, ?> kontext) {
         Object variable = kontext.get(fuzzyVariable);
         if (variable == null) {
-            throw new VariableNichtDefiniertException("Die Variable \"" + fuzzyVariable + "\" ist nicht definiert.");
-        } else if (!(variable instanceof FuzzyVariable)) {
-            throw new InterpreterException("Die Variable \"" + fuzzyVariable + "\" muss eine Fuzzy-Variable sein.");
+            throw new IllegalStateException("Die Variable \"" + fuzzyVariable + "\" ist nicht definiert.");
+        }
+        if (!(variable instanceof FuzzyVariable)) {
+            throw new IllegalStateException("Die Variable \"" + fuzzyVariable + "\" muss eine Fuzzy-Variable sein.");
         }
 
         FuzzyVariable fuzzyVariable = (FuzzyVariable) variable;
         Term t = fuzzyVariable.gibTerm(term);
-        if (t.getZugehoerigkeit().nonNull()) {
-            return t.getZugehoerigkeit().getWert();
-        } else {
-            return null;
-        }
+        return t.getZugehoerigkeit();
     }
 
     @Override

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/VariableNichtDefiniertException.java

-/*
- * Segment 5 Intelligente Analyseverfahren, SWE 5.4 Funktionen Fuzzy
- * Copyright (C) 2007-2015 BitCtrl Systems GmbH
- *
- * This library is free software; you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
- * any later version.
- *
- * This library is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
- * details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this library; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
- *
- * Contact Information:
- * BitCtrl Systems GmbH
- * Weißenfelser Straße 67
- * 04229 Leipzig
- * Phone: +49 341-490670
- * mailto: info@bitctrl.de
- */
-
-package de.bsvrz.iav.fuzzylib.fuzzylib;
-
-public class VariableNichtDefiniertException extends RuntimeException {
-
-    public VariableNichtDefiniertException(String message) {
-        super(message);
-    }
-
-    public VariableNichtDefiniertException(String message, Throwable cause) {
-        super(message, cause);
-    }
-
-}

src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/DoubleLiteral.java → src/main/java/de/bsvrz/iav/fuzzylib/fuzzylib/ZugehoerigkeitLiteral.java

@@ -29,26 +29,31 @@ package de.bsvrz.iav.fuzzylib.fuzzylib;
 import java.util.*;
 
 /**
- * Stellt eine definierte Gleitkommazahl in einem Ausdruck dar.
+ * Stellt eine Zugehörigkeit in einem Ausdruck dar, das Ergebnis ist die
+ * Zugehörigkeit selbst.
  *