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_gmpz.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.hpp"
19 #include "../include/gmpsupport.hpp"
20 #include "gtest/gtest.h"
21 #include <stdexcept>
22 #include <utility>
23 
24 
25  class PolynomialMPZTest : public ::testing::Test{
26  public:
27 
28 
29  PolynomialMPZTest(){
30 
31  }
32  virtual ~PolynomialMPZTest(){
33 
34  }
35  protected:
36  //virtual void SetUp() {
37 
38  //}
39 
40  //virtual void TearDown() {
41 
42  //}
43 
44 
45  };
46 
47 
48  TEST_F(PolynomialMPZTest,constructor_init_list){
49  mpz_class c0=1,c1=2,c2=3;
50  Polynomial<mpz_class> f {c0,c1,c2};
51  ASSERT_EQ(f[0],c0);
52  ASSERT_EQ(f[1],c1);
53  ASSERT_EQ(f[2],c2);
54 
55  }
56  TEST_F(PolynomialMPZTest,appendTerm){
57  mpz_class c0=1,c1=2,c2=3;
58  Polynomial<mpz_class> f;
59  f.appendTerm(c0);
60  f.appendTerm(c1);
61  f.appendTerm(c2);
62  ASSERT_EQ(f[0],c0);
63  ASSERT_EQ(f[1],c1);
64  ASSERT_EQ(f[2],c2);
65 
66  }
67  TEST_F(PolynomialMPZTest,constructor_copy){
68  mpz_class c0=1,c1=2,c2=3;
69  Polynomial<mpz_class> p {c0,c1,c2};
70  Polynomial<mpz_class> f (p);
71  ASSERT_EQ(f[0],c0);
72  ASSERT_EQ(f[1],c1);
73  ASSERT_EQ(f[2],c2);
74 
75  }
76  TEST_F(PolynomialMPZTest,constructor_move){
77  mpz_class c0=1,c1=2,c2=3;
78  Polynomial<mpz_class> p {c0,c1,c2};
79  Polynomial<mpz_class> f (std::move(p));
80  ASSERT_EQ(f[0],c0);
81  ASSERT_EQ(f[1],c1);
82  ASSERT_EQ(f[2],c2);
83  /* That the moved from object is in expected state */
84  ASSERT_EQ(p.size(),0);
85  }
86  TEST_F(PolynomialMPZTest,assignment_move){
87  mpz_class c0=1,c1=2,c2=3;
88  Polynomial<mpz_class> p {c0,c1,c2};
89  Polynomial<mpz_class> f;
90  f=std::move(p);
91  ASSERT_EQ(f[0],c0);
92  ASSERT_EQ(f[1],c1);
93  ASSERT_EQ(f[2],c2);
94  /* That the moved from object is in expected state */
95  ASSERT_EQ(p.size(),0);
96  }
97  TEST_F(PolynomialMPZTest,access_operator_out_of_range_exception){
98  mpz_class c0=1,c1=2,c2=3;
99  Polynomial<mpz_class> f {c0,c1,c2};
100  ASSERT_THROW(f[3],std::out_of_range);
101  }
102 
103  TEST_F(PolynomialMPZTest,friend_swap){
104  mpz_class c0=1,c1=2,c2=3;
105  mpz_class a0=4,a1=5,a2=6;
106  Polynomial<mpz_class> fc {c0,c1,c2};
107  Polynomial<mpz_class> fa {a0,a1,a2};
108  swap(fc,fa);
109  ASSERT_EQ(fc[0],a0);
110  ASSERT_EQ(fc[1],a1);
111  ASSERT_EQ(fc[2],a2);
112  ASSERT_EQ(fa[0],c0);
113  ASSERT_EQ(fa[1],c1);
114  ASSERT_EQ(fa[2],c2);
115 
116  }
117 
118  TEST_F(PolynomialMPZTest,helper_trim){
119  mpz_class c0=1,c1=2,c2=3,c3=0;
120  mpz_class a0=4,a1=0,a2=6,a3=0;
121  Polynomial<mpz_class> fc {c0,c1,c2,c3};
122  Polynomial<mpz_class> fa {a0,a1,a2,a3};
123  ASSERT_EQ(fc.size(),3);
124  ASSERT_EQ(fa.size(),3);
125  ASSERT_EQ(fc[0],c0);
126  ASSERT_EQ(fc[1],c1);
127  ASSERT_EQ(fc[2],c2);
128  ASSERT_EQ(fa[0],a0);
129  ASSERT_EQ(fa[1],a1);
130  ASSERT_EQ(fa[2],a2);
131 
132  }
133 
134  TEST_F(PolynomialMPZTest,sum_assign_operator){
135  mpz_class c0=1,c1=2,c2=3,c3=0;
136  mpz_class a0=4,a1=0,a2=6,a3=10;
137  Polynomial<mpz_class> fc {c0,c1,c2,c3};
138  Polynomial<mpz_class> fa {a0,a1,a2,a3};
139 
140  fc+=fa;
141  ASSERT_EQ(fc.size(),4);
142  ASSERT_EQ(fa.size(),4);
143 
144  ASSERT_EQ(fc[0],c0+a0);
145  ASSERT_EQ(fc[1],c1+a1);
146  ASSERT_EQ(fc[2],c2+a2);
147  ASSERT_EQ(fc[3],c3+a3);
148  ASSERT_EQ(fa[0],a0);
149  ASSERT_EQ(fa[1],a1);
150  ASSERT_EQ(fa[2],a2);
151  ASSERT_EQ(fa[3],a3);
152 
153 
154  }
155  TEST_F(PolynomialMPZTest,sum_assign_operator_rvalue_ref){
156  mpz_class c0=1,c1=2,c2=3,c3=0;
157  mpz_class a0=4,a1=0,a2=6,a3=10;
158  Polynomial<mpz_class> fc {c0,c1,c2,c3};
159 
160  fc+=(Polynomial<mpz_class> {a0,a1,a2,a3});
161  ASSERT_EQ(fc.size(),4);
162 
163  ASSERT_EQ(fc[0],c0+a0);
164  ASSERT_EQ(fc[1],c1+a1);
165  ASSERT_EQ(fc[2],c2+a2);
166  ASSERT_EQ(fc[3],c3+a3);
167 
168  }
169  TEST_F(PolynomialMPZTest,subtract_assign_operator){
170  mpz_class c0=1,c1=2,c2=3,c3=0;
171  mpz_class a0=4,a1=0,a2=6,a3=10;
172  Polynomial<mpz_class> fc {c0,c1,c2,c3};
173  Polynomial<mpz_class> fa {a0,a1,a2,a3};
174 
175  fc-=fa;
176  ASSERT_EQ(fc.size(),4);
177  ASSERT_EQ(fa.size(),4);
178 
179  ASSERT_EQ(fc[0],c0-a0);
180  ASSERT_EQ(fc[1],c1-a1);
181  ASSERT_EQ(fc[2],c2-a2);
182  ASSERT_EQ(fc[3],c3-a3);
183  ASSERT_EQ(fa[0],a0);
184  ASSERT_EQ(fa[1],a1);
185  ASSERT_EQ(fa[2],a2);
186  ASSERT_EQ(fa[3],a3);
187 
188 
189  }
190  TEST_F(PolynomialMPZTest,subtract_assign_operator_rvalue_ref){
191  mpz_class c0=1,c1=2,c2=3,c3=0;
192  mpz_class a0=4,a1=0,a2=6,a3=10;
193  Polynomial<mpz_class> fc {c0,c1,c2,c3};
194 
195  fc-=(Polynomial<mpz_class> {a0,a1,a2,a3});
196  ASSERT_EQ(fc.size(),4);
197 
198  ASSERT_EQ(fc[0],c0-a0);
199  ASSERT_EQ(fc[1],c1-a1);
200  ASSERT_EQ(fc[2],c2-a2);
201  ASSERT_EQ(fc[3],c3-a3);
202 
203  }
204  TEST_F(PolynomialMPZTest,unary_minus_operator_rvalue){
205  mpz_class a0=4,a1=0,a2=6,a3=10;
206  Polynomial<mpz_class> fa =-(Polynomial<mpz_class> {a0,a1,a2,a3});
207 
208  ASSERT_EQ(fa[0],-a0);
209  ASSERT_EQ(fa[1],-a1);
210  ASSERT_EQ(fa[2],-a2);
211  ASSERT_EQ(fa[3],-a3);
212  }
213  TEST_F(PolynomialMPZTest,unary_minus_operator){
214  mpz_class a0=4,a1=0,a2=6,a3=10;
215  Polynomial<mpz_class> fa {a0,a1,a2,a3};
216  Polynomial<mpz_class> f =-fa;
217 
218  ASSERT_EQ(f[0],-a0);
219  ASSERT_EQ(f[1],-a1);
220  ASSERT_EQ(f[2],-a2);
221  ASSERT_EQ(f[3],-a3);
222  }
223  TEST_F(PolynomialMPZTest,helper_minus){
224  mpz_class a0=4,a1=0,a2=6,a3=10;
225  Polynomial<mpz_class> fa {a0,a1,a2,a3};
226  fa.minus();
227  ASSERT_EQ(fa.size(),4);
228 
229  ASSERT_EQ(fa[0],-a0);
230  ASSERT_EQ(fa[1],-a1);
231  ASSERT_EQ(fa[2],-a2);
232  ASSERT_EQ(fa[3],-a3);
233 
234 
235  }
236  TEST_F(PolynomialMPZTest,add_operator){
237  mpz_class c0=1,c1=2,c2=3,c3=0;
238  mpz_class a0=4,a1=0,a2=6,a3=10;
239  Polynomial<mpz_class> fc {c0,c1,c2,c3};
240  Polynomial<mpz_class> fa {a0,a1,a2,a3};
241 
242  Polynomial<mpz_class> f=fa+fc;
243  ASSERT_EQ(fc.size(),3);
244  ASSERT_EQ(fa.size(),4);
245  ASSERT_EQ(f.size(),4);
246 
247 
248  ASSERT_EQ(f[0],c0+a0);
249  ASSERT_EQ(f[1],c1+a1);
250  ASSERT_EQ(f[2],c2+a2);
251  ASSERT_EQ(f[3],c3+a3);
252  ASSERT_EQ(fa[0],a0);
253  ASSERT_EQ(fa[1],a1);
254  ASSERT_EQ(fa[2],a2);
255  ASSERT_EQ(fa[3],a3);
256  ASSERT_EQ(fc[0],c0);
257  ASSERT_EQ(fc[1],c1);
258  ASSERT_EQ(fc[2],c2);
259 
260  }
261  TEST_F(PolynomialMPZTest,add_operator_rvalue){
262  mpz_class c0=1,c1=2,c2=3,c3=0;
263  mpz_class a0=4,a1=0,a2=6,a3=10;
264 
265  Polynomial<mpz_class> fa {a0,a1,a2,a3};
266 
267  Polynomial<mpz_class> f=fa+(Polynomial<mpz_class> {c0,c1,c2,c3});
268  ASSERT_EQ(fa.size(),4);
269  ASSERT_EQ(f.size(),4);
270 
271 
272  ASSERT_EQ(f[0],c0+a0);
273  ASSERT_EQ(f[1],c1+a1);
274  ASSERT_EQ(f[2],c2+a2);
275  ASSERT_EQ(f[3],c3+a3);
276  ASSERT_EQ(fa[0],a0);
277  ASSERT_EQ(fa[1],a1);
278  ASSERT_EQ(fa[2],a2);
279  ASSERT_EQ(fa[3],a3);
280 
281  }
282  TEST_F(PolynomialMPZTest,subtract_operator){
283  mpz_class c0=1,c1=2,c2=3,c3=10;
284  mpz_class a0=4,a1=0,a2=6,a3=10;
285  Polynomial<mpz_class> fc {c0,c1,c2,c3};
286  Polynomial<mpz_class> fa {a0,a1,a2,a3};
287 
288  Polynomial<mpz_class> f=fa-fc;
289  ASSERT_EQ(fc.size(),4);
290  ASSERT_EQ(fa.size(),4);
291  ASSERT_EQ(f.size(),3);
292 
293 
294  ASSERT_EQ(f[0],a0-c0);
295  ASSERT_EQ(f[1],a1-c1);
296  ASSERT_EQ(f[2],a2-c2);
297  ASSERT_EQ(fa[0],a0);
298  ASSERT_EQ(fa[1],a1);
299  ASSERT_EQ(fa[2],a2);
300  ASSERT_EQ(fa[3],a3);
301  ASSERT_EQ(fc[0],c0);
302  ASSERT_EQ(fc[1],c1);
303  ASSERT_EQ(fc[2],c2);
304 
305  }
306 
307 
308  TEST_F(PolynomialMPZTest,multiply_operator){
309  mpz_class c0=1,c1=2,c2=3,c3=4;
310  mpz_class a0=4,a1=0,a2=6;
311  Polynomial<mpz_class> fc {c0,c1,c2,c3};
312  Polynomial<mpz_class> fa {a0,a1,a2};
313 
314  Polynomial<mpz_class> f=fa*fc;
315  ASSERT_EQ(f.size(),6);
316 
317 
318  ASSERT_EQ(f[0],c0*a0);
319  ASSERT_EQ(f[1],a0*c1+a1*c0);
320  ASSERT_EQ(f[2],a0*c2+a1*c1+a2*c0);
321  ASSERT_EQ(f[3],a0*c3+a1*c2+a2*c1);
322  ASSERT_EQ(f[4],a1*c3+a2*c2);
323  ASSERT_EQ(f[5],a2*c3);
324 
325  Polynomial<mpz_class> g=fa*fc;
326  ASSERT_EQ(g.size(),6);
327 
328 
329  ASSERT_EQ(g[0],c0*a0);
330  ASSERT_EQ(g[1],a0*c1+a1*c0);
331  ASSERT_EQ(g[2],a0*c2+a1*c1+a2*c0);
332  ASSERT_EQ(g[3],a0*c3+a1*c2+a2*c1);
333  ASSERT_EQ(g[4],a1*c3+a2*c2);
334  ASSERT_EQ(g[5],a2*c3);
335 
336  }
337 
338 int main(int argc,char **argv){
339  ::testing::InitGoogleTest(&argc,argv);
340  return RUN_ALL_TESTS();
341 }
Polynomial::appendTerm
void appendTerm(FieldT coeff)
Append new terms by pushing back coefficients.
Definition: Polynomial_impl.ipp:73
TEST_F
TEST_F(PolynomialMPZTest, constructor_init_list)
Definition: Test_Polynomial_gmpz.cpp:48
main
int main(int argc, char **argv)
Definition: Test_Polynomial_gmpz.cpp:338
Polynomial::size
size_t size()
Definition: Polynomial.hpp:155
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