Commit 457a6126 authored by Falko Schumann's avatar Falko Schumann

Interpreter arbeitet mit Zugehörigkeit statt Double

parent ac2e53d1
......@@ -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);
}
......
......@@ -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);
}
......
......@@ -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));
}
......
......@@ -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);
}
}
......@@ -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),
......
......@@ -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);
}
......
/*
* 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);
}
}
......@@ -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);
}
......
......@@ -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
......
......@@ -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
......
......@@ -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));
}
......
......@@ -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;
}
......
......@@ -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 {
......
......@@ -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
......
......@@ -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
......
/*
* 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);
}
}
......@@ -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.
*