From d8cd813ddc54c455eb3071795038b97b72dc1ee9 Mon Sep 17 00:00:00 2001 From: Stefan Suhren Date: Tue, 9 Jun 2015 09:13:55 +0200 Subject: Add working version of UpnFx --- src/de/fhswf/in/inf/upnfx/util/Addition.java | 34 +++++++ src/de/fhswf/in/inf/upnfx/util/BinaryOperator.java | 50 ++++++++++ src/de/fhswf/in/inf/upnfx/util/BinaryTemplate.java | 87 ++++++++++++++++ src/de/fhswf/in/inf/upnfx/util/Division.java | 39 ++++++++ src/de/fhswf/in/inf/upnfx/util/Modulo.java | 39 ++++++++ src/de/fhswf/in/inf/upnfx/util/Multiplication.java | 34 +++++++ .../in/inf/upnfx/util/ObservableDoubleStack.java | 40 ++++++++ src/de/fhswf/in/inf/upnfx/util/Operator.java | 23 +++++ src/de/fhswf/in/inf/upnfx/util/Subtraction.java | 34 +++++++ src/de/fhswf/in/inf/upnfx/util/UPN.java | 110 +++++++++++++++++++++ src/de/fhswf/in/inf/upnfx/util/UnaryOperator.java | 47 +++++++++ src/de/fhswf/in/inf/upnfx/util/UnaryTemplate.java | 86 ++++++++++++++++ 12 files changed, 623 insertions(+) create mode 100644 src/de/fhswf/in/inf/upnfx/util/Addition.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/BinaryOperator.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/BinaryTemplate.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/Division.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/Modulo.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/Multiplication.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/ObservableDoubleStack.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/Operator.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/Subtraction.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/UPN.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/UnaryOperator.java create mode 100644 src/de/fhswf/in/inf/upnfx/util/UnaryTemplate.java (limited to 'src/de/fhswf/in/inf/upnfx/util') diff --git a/src/de/fhswf/in/inf/upnfx/util/Addition.java b/src/de/fhswf/in/inf/upnfx/util/Addition.java new file mode 100644 index 0000000..f01ee1f --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Addition.java @@ -0,0 +1,34 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +/** + * Adds two double values. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class Addition extends BinaryOperator +{ + + /** + * Intentionally empty. + * + */ + public Addition() + { + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.BinaryOperator#eval(double, double) + */ + @Override + final double eval(double d1, double d2) + { + return d1 + d2; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/BinaryOperator.java b/src/de/fhswf/in/inf/upnfx/util/BinaryOperator.java new file mode 100644 index 0000000..4f704ee --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/BinaryOperator.java @@ -0,0 +1,50 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + + +/** + * An abstract class for calculations with unary operators. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public abstract class BinaryOperator implements Operator +{ + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.Operator#eval(java.util.Stack) + */ + @Override + public final void eval(ObservableDoubleStack stack) + { + if (stack == null) + { + throw new IllegalArgumentException("Stack must not be null."); + } + + if (stack.size() < 2) + { + throw new IllegalArgumentException( + "Binary operation requires two operand."); + } + + double d2 = stack.pop(); + double d1 = stack.pop(); + + stack.push(eval(d1, d2)); + } + + /** + * This method implements the calculation. + * + * @param d1 + * The first operator. + * @param d2 + * The second operator. + * @return The result of the calculation. + */ + abstract double eval(double d1, double d2); +} diff --git a/src/de/fhswf/in/inf/upnfx/util/BinaryTemplate.java b/src/de/fhswf/in/inf/upnfx/util/BinaryTemplate.java new file mode 100644 index 0000000..6f77dc4 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/BinaryTemplate.java @@ -0,0 +1,87 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * Uses Reflection API to get the method for calculation. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class BinaryTemplate extends BinaryOperator +{ + + private Method operator; + + /** + * Gets the operator function from the Math class. + * + * @param mathFunction + * The name of the operation. + */ + public BinaryTemplate(String mathFunction) + { + if (mathFunction == null) + { + throw new IllegalArgumentException("Operation can't be null."); + } + + if (mathFunction.isEmpty()) + { + throw new IllegalArgumentException("Operations can't be empty."); + } + + try + { + operator = Math.class.getMethod(mathFunction, Double.TYPE, + Double.TYPE); + } + catch (NoSuchMethodException e) + { + throw new IllegalArgumentException("Not a valid Operator.", e); + } + catch (SecurityException e) + { + throw new IllegalArgumentException("Security violation.", e); + } + + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.UnaryOperator#eval(double) + */ + @Override + final double eval(double d1, double d2) + { + Object tmp = null; + try + { + tmp = operator.invoke(null, d1, d2); + } + catch (IllegalAccessException e) + { + throw new IllegalStateException("Can't access method.", e); + } + catch (IllegalArgumentException e) + { + throw new IllegalStateException( + "Argument for Math function is not double.", e); + } + catch (InvocationTargetException e) + { + if (e.getCause() instanceof IllegalArgumentException) + { + throw new IllegalArgumentException("Illegal Argument.", e); + } + throw new IllegalStateException("Unexpected exception.", e); + } + return (double) tmp; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/Division.java b/src/de/fhswf/in/inf/upnfx/util/Division.java new file mode 100644 index 0000000..1bcd9fb --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Division.java @@ -0,0 +1,39 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +/** + * Divides two double values. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class Division extends BinaryOperator +{ + + /** + * Intentionally empty. + * + */ + public Division() + { + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.BinaryOperator#eval(double, double) + */ + @Override + final double eval(double d1, double d2) + { + if (d2 == 0.0) + { + throw new IllegalArgumentException("Divisor can't be 0."); + } + + return d1 / d2; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/Modulo.java b/src/de/fhswf/in/inf/upnfx/util/Modulo.java new file mode 100644 index 0000000..c285d74 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Modulo.java @@ -0,0 +1,39 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +/** + * Divides two double values and returns the remainder. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class Modulo extends BinaryOperator +{ + + /** + * Intentionally empty. + * + */ + public Modulo() + { + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.BinaryOperator#eval(double, double) + */ + @Override + final double eval(double d1, double d2) + { + if (d2 == 0.0) + { + throw new IllegalArgumentException("Divisor can't be 0."); + } + + return d1 % d2; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/Multiplication.java b/src/de/fhswf/in/inf/upnfx/util/Multiplication.java new file mode 100644 index 0000000..59148ea --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Multiplication.java @@ -0,0 +1,34 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +/** + * Multiplies two double values. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class Multiplication extends BinaryOperator +{ + + /** + * Intentionally empty. + * + */ + public Multiplication() + { + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.BinaryOperator#eval(double, double) + */ + @Override + final double eval(double d1, double d2) + { + return d1 * d2; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/ObservableDoubleStack.java b/src/de/fhswf/in/inf/upnfx/util/ObservableDoubleStack.java new file mode 100644 index 0000000..8fbcc6d --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/ObservableDoubleStack.java @@ -0,0 +1,40 @@ +/** + * + */ + +package de.fhswf.in.inf.upnfx.util; + +import javafx.beans.property.SimpleListProperty; +import javafx.collections.FXCollections; + +/** + * An observable list that has the Stack methods. + * + * @author Stefan Suhren + * @version 1.0 + */ +public class ObservableDoubleStack extends SimpleListProperty +{ + public ObservableDoubleStack() + { + super(FXCollections.observableArrayList()); + } + + public Double peek() + { + return get(size() - 1); + } + + public Double pop() + { + Double ret = get(size() - 1); + remove(size() - 1); + return ret; + } + + public void push(Double item) + { + add(item); + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/Operator.java b/src/de/fhswf/in/inf/upnfx/util/Operator.java new file mode 100644 index 0000000..4d1a8c6 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Operator.java @@ -0,0 +1,23 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + + +/** + * An interface for on UPN operator. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public interface Operator +{ + /** + * Gets a stack of doubles and calculates a new value to be put on the + * stack. + * + * @param upnStack + * The UPN stack of the calculator. + */ + void eval(ObservableDoubleStack upnStack); +} diff --git a/src/de/fhswf/in/inf/upnfx/util/Subtraction.java b/src/de/fhswf/in/inf/upnfx/util/Subtraction.java new file mode 100644 index 0000000..a4c8677 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/Subtraction.java @@ -0,0 +1,34 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +/** + * Subtracts two double values. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class Subtraction extends BinaryOperator +{ + + /** + * Intentionally empty. + * + */ + public Subtraction() + { + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.BinaryOperator#eval(double, double) + */ + @Override + final double eval(double d1, double d2) + { + return d1 - d2; + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/UPN.java b/src/de/fhswf/in/inf/upnfx/util/UPN.java new file mode 100644 index 0000000..bc773d5 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/UPN.java @@ -0,0 +1,110 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + + +/** + * A class that calculates in UPN. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class UPN +{ + + private ObservableDoubleStack upnStack = new ObservableDoubleStack(); + + private Double lastX; + + /** + * Empty constructor. + * + */ + public UPN() + { + } + + /** + * Reads a string and puts it on the UPN upnStack. + * + * @param upnString + * A space delimited string in UPN notation. + */ + public final void calculate(Operator operator) + { + if (operator == null) + { + throw new IllegalArgumentException("Operator can't be null."); + } + + System.out.println(operator); + + lastX = upnStack.peek(); + + operator.eval(upnStack); + + } + + public final void addDouble(Double newVal) + { + if (newVal == null) + { + throw new IllegalArgumentException("newVal can't be null."); + } + upnStack.push(newVal); + } + + /** + * Get the result of a calculation done before. + * + * @return The top most value on the UPN stack. + */ + public final double getResult() + { + if (upnStack.isEmpty()) + { + throw new IllegalArgumentException("UPN stack is empty."); + } + return upnStack.peek(); + } + + /** + * Return the ObservableDoubleStack to tie it to the view. + * + * @return The ObservableDoubleStack with the operands. + */ + public final ObservableDoubleStack getStack() + { + return upnStack; + } + + /** + * Pushes the previous x onto the stack. + * + */ + public final void setLastX() + { + if(lastX != null) + { + upnStack.push(lastX); + } + } + + /** + * Swap x and y on the stack. + * + */ + public final void swapXY() + { + if(upnStack.size() > 1) + { + double f1 = upnStack.pop(); + double f2 = upnStack.pop(); + + upnStack.push(f1); + upnStack.push(f2); + } + } + +} diff --git a/src/de/fhswf/in/inf/upnfx/util/UnaryOperator.java b/src/de/fhswf/in/inf/upnfx/util/UnaryOperator.java new file mode 100644 index 0000000..be44b16 --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/UnaryOperator.java @@ -0,0 +1,47 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + + +/** + * An abstract class for calculations with unary operators. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public abstract class UnaryOperator implements Operator +{ + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.Operator#eval(java.util.Stack) + */ + @Override + public final void eval(ObservableDoubleStack stack) + { + if (stack == null) + { + throw new IllegalArgumentException("Stack must not be null."); + } + + if (stack.size() < 1) + { + throw new IllegalArgumentException( + "Unary operation requires one operand."); + } + + double d = stack.pop(); + + stack.push(eval(d)); + } + + /** + * This class implements the calculation. + * + * @param d + * The unary operator. + * @return The result of the calculation. + */ + abstract double eval(double d); +} diff --git a/src/de/fhswf/in/inf/upnfx/util/UnaryTemplate.java b/src/de/fhswf/in/inf/upnfx/util/UnaryTemplate.java new file mode 100644 index 0000000..671707a --- /dev/null +++ b/src/de/fhswf/in/inf/upnfx/util/UnaryTemplate.java @@ -0,0 +1,86 @@ +/** + * + */ +package de.fhswf.in.inf.upnfx.util; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; + +/** + * Uses Reflection API to get the method for calculation. + * + * @author $Author: $ + * @version $Revision: $, $Date: $ UTC + */ +public class UnaryTemplate extends UnaryOperator +{ + + private Method operator; + + /** + * Gets the operator function from the Math class. + * + * @param mathFunction + * The name of the operation. + */ + public UnaryTemplate(String mathFunction) + { + if (mathFunction == null) + { + throw new IllegalArgumentException("Operation can't be null."); + } + + if (mathFunction.isEmpty()) + { + throw new IllegalArgumentException("Operations can't be empty."); + } + + try + { + operator = Math.class.getMethod(mathFunction, Double.TYPE); + } + catch (NoSuchMethodException e) + { + throw new IllegalArgumentException("Not a valid Operator.", e); + } + catch (SecurityException e) + { + throw new IllegalArgumentException("Security violation.", e); + } + + } + + /* + * (non-Javadoc) + * + * @see de.fhswf.in.inf.java1.aufgabe12.UnaryOperator#eval(double) + */ + @Override + final double eval(double d) + { + Object tmp = null; + try + { + tmp = operator.invoke(null, d); + } + catch (IllegalAccessException e) + { + throw new IllegalStateException("Can't access method.", e); + } + catch (IllegalArgumentException e) + { + throw new IllegalStateException( + "Argument for Math function is not double.", e); + } + catch (InvocationTargetException e) + { + if (e.getCause() instanceof IllegalArgumentException) + { + throw new IllegalArgumentException("Illegal Argument.", e); + } + throw new IllegalStateException("Unexpected exception.", e); + } + return (double) tmp; + } + +} -- cgit v1.2.3-70-g09d2