Reorganised projects

1 files changed, 0 insertions, 189 deletions

diff --git a/Week7/src/polynomial/Polynomial.java b/Week7/src/polynomial/Polynomial.java
deleted file mode 100644
index c87b96a..0000000
--- a/Week7/src/polynomial/Polynomial.java
+++ /dev/null
@@ -1,189 +0,0 @@
-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;
-    }
-
-}