Polymetic  1.1
A c++ library for polynomial and matrix arithmetic, focused on applications in Kinematics.
 All Classes Namespaces Files Functions Variables Typedefs Friends Macros Pages
Test_Polynomial.cpp
Go to the documentation of this file.
1 // Copyright 2018 Dhruvesh Nikhilkumar Patel
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
18 #include "../include/Polynomial.ipp"
19 #include "gtest/gtest.h"
20 #include <stdexcept>
21 #include <utility>
22 #include <vector>
23 
24 
25  class PolynomialTest : public ::testing::Test{
26  public:
27 
28 
29  PolynomialTest(){
30 
31  }
32  virtual ~PolynomialTest(){
33 
34  }
35  protected:
36  //virtual void SetUp() {
37 
38  //}
39 
40  //virtual void TearDown() {
41 
42  //}
43 
44 
45  };
46 
47  TEST_F(PolynomialTest,constructor_default) {
48  Polynomial<double> f;
49  ASSERT_EQ(f.size(),0);
50  }
51  TEST_F(PolynomialTest,constructor_init_list){
52  double c0=1,c1=2,c2=3;
53  Polynomial<double> f {c0,c1,c2};
54  ASSERT_DOUBLE_EQ(f[0],c0);
55  ASSERT_DOUBLE_EQ(f[1],c1);
56  ASSERT_DOUBLE_EQ(f[2],c2);
57  }
58 
59  TEST_F(PolynomialTest,constructor_iterators){
60  double c0=1,c1=2,c2=3;
61  std::vector<double> c {c0,c1,c2};
62  Polynomial<double> f(c.begin(),c.end());
63  ASSERT_DOUBLE_EQ(f[0],c0);
64  ASSERT_DOUBLE_EQ(f[1],c1);
65  ASSERT_DOUBLE_EQ(f[2],c2);
66  }
67  TEST_F(PolynomialTest,appendTerm){
68  double c0=1,c1=2,c2=3;
69  Polynomial<double> f;
70  f.appendTerm(c0);
71  f.appendTerm(c1);
72  f.appendTerm(c2);
73  ASSERT_DOUBLE_EQ(f[0],c0);
74  ASSERT_DOUBLE_EQ(f[1],c1);
75  ASSERT_DOUBLE_EQ(f[2],c2);
76 
77  }
78  TEST_F(PolynomialTest,constructor_copy){
79  double c0=1,c1=2,c2=3;
80  Polynomial<double> p {c0,c1,c2};
81  Polynomial<double> f (p);
82  ASSERT_DOUBLE_EQ(f[0],c0);
83  ASSERT_DOUBLE_EQ(f[1],c1);
84  ASSERT_DOUBLE_EQ(f[2],c2);
85 
86  }
87  TEST_F(PolynomialTest,constructor_move){
88  double c0=1,c1=2,c2=3;
89  Polynomial<double> p {c0,c1,c2};
90  Polynomial<double> f (std::move(p));
91  ASSERT_DOUBLE_EQ(f[0],c0);
92  ASSERT_DOUBLE_EQ(f[1],c1);
93  ASSERT_DOUBLE_EQ(f[2],c2);
94  /* That the moved from object is in expected state */
95  ASSERT_EQ(p.size(),0);
96  }
97  TEST_F(PolynomialTest,assignment_move){
98  double c0=1,c1=2,c2=3;
99  Polynomial<double> p {c0,c1,c2};
100  Polynomial<double> f;
101  f=std::move(p);
102  ASSERT_DOUBLE_EQ(f[0],c0);
103  ASSERT_DOUBLE_EQ(f[1],c1);
104  ASSERT_DOUBLE_EQ(f[2],c2);
105  /* That the moved from object is in expected state */
106  ASSERT_EQ(p.size(),0);
107  }
108  TEST_F(PolynomialTest,access_operator_out_of_range_exception){
109  double c0=1,c1=2,c2=3;
110  Polynomial<double> f {c0,c1,c2};
111  ASSERT_THROW(f[3],std::out_of_range);
112  }
113 
114  TEST_F(PolynomialTest,friend_swap){
115  double c0=1,c1=2,c2=3;
116  double a0=4,a1=5,a2=6;
117  Polynomial<double> fc {c0,c1,c2};
118  Polynomial<double> fa {a0,a1,a2};
119  swap(fc,fa);
120  ASSERT_DOUBLE_EQ(fc[0],a0);
121  ASSERT_DOUBLE_EQ(fc[1],a1);
122  ASSERT_DOUBLE_EQ(fc[2],a2);
123  ASSERT_DOUBLE_EQ(fa[0],c0);
124  ASSERT_DOUBLE_EQ(fa[1],c1);
125  ASSERT_DOUBLE_EQ(fa[2],c2);
126 
127  }
128 
129  TEST_F(PolynomialTest,helper_trim){
130  double c0=1,c1=2,c2=3,c3=0;
131  double a0=4,a1=0,a2=6,a3=0;
132  Polynomial<double> fc {c0,c1,c2,c3};
133  Polynomial<double> fa {a0,a1,a2,a3};
134  ASSERT_EQ(fc.size(),3);
135  ASSERT_EQ(fa.size(),3);
136  ASSERT_DOUBLE_EQ(fc[0],c0);
137  ASSERT_DOUBLE_EQ(fc[1],c1);
138  ASSERT_DOUBLE_EQ(fc[2],c2);
139  ASSERT_DOUBLE_EQ(fa[0],a0);
140  ASSERT_DOUBLE_EQ(fa[1],a1);
141  ASSERT_DOUBLE_EQ(fa[2],a2);
142 
143  }
144 
145  TEST_F(PolynomialTest,sum_assign_operator){
146  double c0=1,c1=2,c2=3,c3=0;
147  double a0=4,a1=0,a2=6,a3=10;
148  Polynomial<double> fc {c0,c1,c2,c3};
149  Polynomial<double> fa {a0,a1,a2,a3};
150 
151  fc+=fa;
152  ASSERT_EQ(fc.size(),4);
153  ASSERT_EQ(fa.size(),4);
154 
155  ASSERT_DOUBLE_EQ(fc[0],c0+a0);
156  ASSERT_DOUBLE_EQ(fc[1],c1+a1);
157  ASSERT_DOUBLE_EQ(fc[2],c2+a2);
158  ASSERT_DOUBLE_EQ(fc[3],c3+a3);
159  ASSERT_DOUBLE_EQ(fa[0],a0);
160  ASSERT_DOUBLE_EQ(fa[1],a1);
161  ASSERT_DOUBLE_EQ(fa[2],a2);
162  ASSERT_DOUBLE_EQ(fa[3],a3);
163 
164 
165  }
166  TEST_F(PolynomialTest,sum_assign_operator_rvalue_ref){
167  double c0=1,c1=2,c2=3,c3=0;
168  double a0=4,a1=0,a2=6,a3=10;
169  Polynomial<double> fc {c0,c1,c2,c3};
170 
171  fc+=(Polynomial<double> {a0,a1,a2,a3});
172  ASSERT_EQ(fc.size(),4);
173 
174  ASSERT_DOUBLE_EQ(fc[0],c0+a0);
175  ASSERT_DOUBLE_EQ(fc[1],c1+a1);
176  ASSERT_DOUBLE_EQ(fc[2],c2+a2);
177  ASSERT_DOUBLE_EQ(fc[3],c3+a3);
178 
179  }
180  TEST_F(PolynomialTest,subtract_assign_operator){
181  double c0=1,c1=2,c2=3,c3=0;
182  double a0=4,a1=0,a2=6,a3=10;
183  Polynomial<double> fc {c0,c1,c2,c3};
184  Polynomial<double> fa {a0,a1,a2,a3};
185 
186  fc-=fa;
187  ASSERT_EQ(fc.size(),4);
188  ASSERT_EQ(fa.size(),4);
189 
190  ASSERT_DOUBLE_EQ(fc[0],c0-a0);
191  ASSERT_DOUBLE_EQ(fc[1],c1-a1);
192  ASSERT_DOUBLE_EQ(fc[2],c2-a2);
193  ASSERT_DOUBLE_EQ(fc[3],c3-a3);
194  ASSERT_DOUBLE_EQ(fa[0],a0);
195  ASSERT_DOUBLE_EQ(fa[1],a1);
196  ASSERT_DOUBLE_EQ(fa[2],a2);
197  ASSERT_DOUBLE_EQ(fa[3],a3);
198 
199 
200  }
201  TEST_F(PolynomialTest,subtract_assign_operator_rvalue_ref){
202  double c0=1,c1=2,c2=3,c3=0;
203  double a0=4,a1=0,a2=6,a3=10;
204  Polynomial<double> fc {c0,c1,c2,c3};
205 
206  fc-=(Polynomial<double> {a0,a1,a2,a3});
207  ASSERT_EQ(fc.size(),4);
208 
209  ASSERT_DOUBLE_EQ(fc[0],c0-a0);
210  ASSERT_DOUBLE_EQ(fc[1],c1-a1);
211  ASSERT_DOUBLE_EQ(fc[2],c2-a2);
212  ASSERT_DOUBLE_EQ(fc[3],c3-a3);
213 
214  }
215  TEST_F(PolynomialTest,unary_minus_operator_rvalue){
216  double a0=4,a1=0,a2=6,a3=10;
217  Polynomial<double> fa =-(Polynomial<double> {a0,a1,a2,a3});
218 
219  ASSERT_DOUBLE_EQ(fa[0],-a0);
220  ASSERT_DOUBLE_EQ(fa[1],-a1);
221  ASSERT_DOUBLE_EQ(fa[2],-a2);
222  ASSERT_DOUBLE_EQ(fa[3],-a3);
223  }
224  TEST_F(PolynomialTest,unary_minus_operator){
225  double a0=4,a1=0,a2=6,a3=10;
226  Polynomial<double> fa {a0,a1,a2,a3};
227  Polynomial<double> f =-fa;
228 
229  ASSERT_DOUBLE_EQ(f[0],-a0);
230  ASSERT_DOUBLE_EQ(f[1],-a1);
231  ASSERT_DOUBLE_EQ(f[2],-a2);
232  ASSERT_DOUBLE_EQ(f[3],-a3);
233  }
234  TEST_F(PolynomialTest,helper_minus){
235  double a0=4,a1=0,a2=6,a3=10;
236  Polynomial<double> fa {a0,a1,a2,a3};
237  fa.minus();
238  ASSERT_EQ(fa.size(),4);
239 
240  ASSERT_DOUBLE_EQ(fa[0],-a0);
241  ASSERT_DOUBLE_EQ(fa[1],-a1);
242  ASSERT_DOUBLE_EQ(fa[2],-a2);
243  ASSERT_DOUBLE_EQ(fa[3],-a3);
244 
245 
246  }
247  TEST_F(PolynomialTest,add_operator){
248  double c0=1,c1=2,c2=3,c3=0;
249  double a0=4,a1=0,a2=6,a3=10;
250  Polynomial<double> fc {c0,c1,c2,c3};
251  Polynomial<double> fa {a0,a1,a2,a3};
252 
253  Polynomial<double> f=fa+fc;
254  ASSERT_EQ(fc.size(),3);
255  ASSERT_EQ(fa.size(),4);
256  ASSERT_EQ(f.size(),4);
257 
258 
259  ASSERT_DOUBLE_EQ(f[0],c0+a0);
260  ASSERT_DOUBLE_EQ(f[1],c1+a1);
261  ASSERT_DOUBLE_EQ(f[2],c2+a2);
262  ASSERT_DOUBLE_EQ(f[3],c3+a3);
263  ASSERT_DOUBLE_EQ(fa[0],a0);
264  ASSERT_DOUBLE_EQ(fa[1],a1);
265  ASSERT_DOUBLE_EQ(fa[2],a2);
266  ASSERT_DOUBLE_EQ(fa[3],a3);
267  ASSERT_DOUBLE_EQ(fc[0],c0);
268  ASSERT_DOUBLE_EQ(fc[1],c1);
269  ASSERT_DOUBLE_EQ(fc[2],c2);
270 
271  }
272  TEST_F(PolynomialTest,add_operator_rvalue){
273  double c0=1,c1=2,c2=3,c3=0;
274  double a0=4,a1=0,a2=6,a3=10;
275 
276  Polynomial<double> fa {a0,a1,a2,a3};
277 
278  Polynomial<double> f=fa+(Polynomial<double> {c0,c1,c2,c3});
279  ASSERT_EQ(fa.size(),4);
280  ASSERT_EQ(f.size(),4);
281 
282 
283  ASSERT_DOUBLE_EQ(f[0],c0+a0);
284  ASSERT_DOUBLE_EQ(f[1],c1+a1);
285  ASSERT_DOUBLE_EQ(f[2],c2+a2);
286  ASSERT_DOUBLE_EQ(f[3],c3+a3);
287  ASSERT_DOUBLE_EQ(fa[0],a0);
288  ASSERT_DOUBLE_EQ(fa[1],a1);
289  ASSERT_DOUBLE_EQ(fa[2],a2);
290  ASSERT_DOUBLE_EQ(fa[3],a3);
291 
292  }
293  TEST_F(PolynomialTest,subtract_operator){
294  double c0=1,c1=2,c2=3,c3=10;
295  double a0=4,a1=0,a2=6,a3=10;
296  Polynomial<double> fc {c0,c1,c2,c3};
297  Polynomial<double> fa {a0,a1,a2,a3};
298 
299  Polynomial<double> f=fa-fc;
300  ASSERT_EQ(fc.size(),4);
301  ASSERT_EQ(fa.size(),4);
302  ASSERT_EQ(f.size(),3);
303 
304 
305  ASSERT_DOUBLE_EQ(f[0],a0-c0);
306  ASSERT_DOUBLE_EQ(f[1],a1-c1);
307  ASSERT_DOUBLE_EQ(f[2],a2-c2);
308  ASSERT_DOUBLE_EQ(fa[0],a0);
309  ASSERT_DOUBLE_EQ(fa[1],a1);
310  ASSERT_DOUBLE_EQ(fa[2],a2);
311  ASSERT_DOUBLE_EQ(fa[3],a3);
312  ASSERT_DOUBLE_EQ(fc[0],c0);
313  ASSERT_DOUBLE_EQ(fc[1],c1);
314  ASSERT_DOUBLE_EQ(fc[2],c2);
315 
316  }
317 
318 
319  TEST_F(PolynomialTest,multiply_operator){
320  double c0=1,c1=2,c2=3,c3=4;
321  double a0=4,a1=0,a2=6;
322  Polynomial<double> fc {c0,c1,c2,c3};
323  Polynomial<double> fa {a0,a1,a2};
324 
325  Polynomial<double> f=fa*fc;
326  ASSERT_EQ(f.size(),6);
327 
328 
329  ASSERT_DOUBLE_EQ(f[0],c0*a0);
330  ASSERT_DOUBLE_EQ(f[1],a0*c1+a1*c0);
331  ASSERT_DOUBLE_EQ(f[2],a0*c2+a1*c1+a2*c0);
332  ASSERT_DOUBLE_EQ(f[3],a0*c3+a1*c2+a2*c1);
333  ASSERT_DOUBLE_EQ(f[4],a1*c3+a2*c2);
334  ASSERT_DOUBLE_EQ(f[5],a2*c3);
335 
336  Polynomial<double> g=fa*fc;
337  ASSERT_EQ(g.size(),6);
338 
339 
340  ASSERT_DOUBLE_EQ(g[0],c0*a0);
341  ASSERT_DOUBLE_EQ(g[1],a0*c1+a1*c0);
342  ASSERT_DOUBLE_EQ(g[2],a0*c2+a1*c1+a2*c0);
343  ASSERT_DOUBLE_EQ(g[3],a0*c3+a1*c2+a2*c1);
344  ASSERT_DOUBLE_EQ(g[4],a1*c3+a2*c2);
345  ASSERT_DOUBLE_EQ(g[5],a2*c3);
346 
347  }
348 
349 int main(int argc,char **argv){
350  ::testing::InitGoogleTest(&argc,argv);
351  return RUN_ALL_TESTS();
352 }
main
int main(int argc, char **argv)
Definition: Test_Polynomial.cpp:349
Polynomial::appendTerm
void appendTerm(FieldT coeff)
Append new terms by pushing back coefficients.
Definition: Polynomial_impl.ipp:73
Polynomial::size
size_t size()
Definition: Polynomial.hpp:155
PolynomialTest::~PolynomialTest
virtual ~PolynomialTest()
Definition: Test_Polynomial.cpp:32
TEST_F
TEST_F(PolynomialTest, constructor_default)
Definition: Test_Polynomial.cpp:47
Polynomial::minus
Polynomial & minus()
Flip the sign of all coefs.
Definition: Polynomial_impl.ipp:276
Polynomial
Contains the definition for the abstract base class which will be used by different multiplication al...
Definition: Polynomial.hpp:40