blob: c87b96a3b3c2cb025415b5ce5887ec1b0774e297 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
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;
}
}
|
