Reorganised projects

1 files changed, 189 insertions, 0 deletions

diff --git a/Week7 Polynomials/src/polynomial/Polynomial.java b/Week7 Polynomials/src/polynomial/Polynomial.java
new file mode 100644
index 0000000..c87b96a
--- /dev/null
+++ b/Week7 Polynomials/src/polynomial/Polynomial.java
@@ -0,0 +1,189 @@
+package polynomial;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * A class for representing Polynomials
+ *
+ * @author Sjaak Smetsers
+ * @date 10-03-2015
+ * 
+ * @author Camil Staps, s4498062
+ * @date 17-03-2015
+ */
+public class Polynomial {
+
+    /**
+     * A polynomial is a sequence of terms here kept in an List.
+     * The assignment tells us 'it's handy' when terms are ordered by exponent.
+     * We don't seem to need that though, so there's no need to implement it.
+     */
+    List<Term> terms;
+
+    /**
+     * A constructor for creating the zero Polynomial zero is presented as an
+     * empty list of terms and not as a single term with 0 as a coefficient
+     */
+    public Polynomial() {
+        terms = new ArrayList<>();
+    }
+
+    /**
+     * A Constructor creating a polynomial from the argument string.
+     * 
+     * This implementation, in contrast to the given implementation, allows for 
+     * entering polynomials with two or more terms with the same exponent. Even 
+     * though this is strictly not necessary and these inputs aren't legit, this
+     * behaviour is always better than the behaviour of the given implementation 
+     * which would happily add two terms with the same exponent to our list.
+     * 
+     * This implementation also directly checks that the coefficient unequals 0,
+     * which is also not need-to-have, but still nice-to-have.
+     * 
+     * Both changes to the given implementation do not change the behaviour on
+     * legit input but do allow a user to mess up in some cases.
+     *
+     * @param s a String representing a list of terms which is converted to a
+     * scanner and passed to scanTerm for reading each individual term
+     */
+    public Polynomial( String s ) {
+        terms = new ArrayList<>();
+        Scanner scan = new Scanner(s);
+
+        for (Term t = Term.scanTerm(scan); t != null; t = Term.scanTerm(scan))
+            if (t.getCoef() != 0)
+                plus(t);
+    }
+
+    /**
+     * The copy constructor for making a deep copy
+     *
+     * @param p the copied polynomial
+     */
+    public Polynomial( Polynomial p ) {
+        terms = new ArrayList<>(p.terms.size());
+        for (Term t : p.terms) {
+            terms.add(new Term(t));
+        }
+    }
+    
+    /**
+     * A straightforward conversion of a Polynomial into a string based on the
+     * toString for terms
+     *
+     * @return a readable string representation of this
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        boolean not_first = false;
+        for (Term t : terms) {
+            if (not_first && t.getCoef() >= 0) 
+                sb.append("+");
+            sb.append(t);
+            not_first = true;
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Add a polynomial to this polynomial
+     * @param b the polynomial to add
+     */
+    public void plus(Polynomial b) {
+        for (Term t : b.terms)
+            plus(t);
+    }
+    
+    /**
+     * Add a term
+     * @param t the term to add
+     */
+    private void plus(Term t) {
+        if (t.getCoef() == 0)
+            return;
+        
+        Iterator<Term> iter = terms.iterator();
+        while (iter.hasNext()) {
+            Term this_t = iter.next();
+            if (this_t.getExp() == t.getExp()) {
+                this_t.plus(t);
+                if (this_t.getCoef() == 0)
+                    iter.remove();
+                return;
+            }
+        }
+        terms.add(new Term(t));
+    }
+
+    /**
+     * Subtract a polynomial from this polynomial
+     * @param p the polynomial to subtract
+     */
+    public void minus(Polynomial p) {
+        Polynomial temp = new Polynomial(p);
+        temp.times(new Polynomial("-1 0"));
+        plus(temp);
+    }
+
+    /**
+     * Multiply a polynomial with this polynomial
+     * @param p the polynomial to multiply with
+     */
+    public void times(Polynomial p) {
+        Polynomial result = new Polynomial();
+        for (Term that_t : p.terms) 
+            for (Term this_t : terms)
+                result.plus(new Term(that_t.getCoef() * this_t.getCoef(), that_t.getExp() + this_t.getExp()));
+        terms = result.terms;
+    }
+
+    public void divide(Polynomial b) {
+    }
+
+    /**
+     * Check equality
+     * @param other_poly the object to check with
+     * @return true iff other_poly represents the same polynomial as this instance
+     */
+    @Override
+    public boolean equals(Object other_poly) {
+        if (other_poly == null || other_poly.getClass() != getClass())
+            return false;
+        
+        Polynomial that = new Polynomial((Polynomial) other_poly);      // We need to copy because later we'll remove elements
+        if (terms.size() != that.terms.size()) 
+            return false;
+        for (Term this_t : terms) {
+            Iterator<Term> that_iter = that.terms.iterator();
+            boolean found = false;
+            while (that_iter.hasNext()) {
+                if (this_t.equals(that_iter.next())) {
+                    found = true;
+                    that_iter.remove();
+                    break;
+                }
+            }
+            if (!found) {
+                return false;
+            }
+        }
+        return true;
+    }
+    
+    /**
+     * Apply the polynomial to a concrete variable
+     * @param x the variable
+     * @return the result of the polynomial applied on x
+     */
+    public double apply(double x) {
+        double result = 0;
+        for (Term t : terms)
+            result += t.apply(x);
+        return result;
+    }
+
+}