AEQ.cc
Go to the documentation of this file.
1 #include <misc/auxiliary.h>
2 #include <omalloc/omalloc.h>
3 
4 #include "AEQ.h"
5 
6 #include <stdio.h>
7 #include <math.h>
8 #ifdef SINGULAR_4_1
9 
10 using namespace std;
11 
12 //Konstruktoren
13 
15 {
16  deg=-1;
17  mpz_init_set_ui(denom,1);
18  mpz_init_set_ui(coef[0],0);
19 }
20 
21 
22 
23 Q_poly::Q_poly(int n,mpz_t d, mpz_t *a)
24 {
25  deg=n;
26 
27  mpz_init_set(denom,d);
28 
29  for ( int i=0;i<=n;i++)
30  {
31  mpz_init_set(coef[i], a[i]);
32  }
33 }
34 
35 /*
36 //Destruktor
37 
38 Q_poly::~Q_poly()
39 {
40  delete[] coef;
41 }
42 
43 */
44 
45 // Kürzen -- MACHT NOCH MIST!
47 {
48  if (is_zero()==1)
49  {
50  mpz_init_set_ui(denom,1);
51  }
52  else
53  {
54  mpz_t d;
55  mpz_init_set(d,denom);
56  int i=0;
57  while (mpz_cmp_ui(d,1)!=0 && i<=deg)
58  {
59  mpz_gcd(d,d,coef[i]);
60  i++;
61  }
62  if (mpz_sgn(denom)==-1)
63  {
64  mpz_neg(d,d);
65  }
66  if (mpz_cmp_ui(d,1)!=0)
67  {
68  mpz_div(denom,denom,d);
69  for (int j=0;j<=deg;j++)
70  {
71  mpz_div(coef[j],coef[j],d);
72  }
73  }
74  }
75  // Grad-Korrektur
76  int j;
77  j=deg;
78  while(mpz_sgn(coef[j])==0 && j>=0)
79  {deg--;j--;}
80 }
81 
82 // Koeffizienten mit b erweitern
84 {
85  mpz_mul(denom,denom,b);
86  for (int i=0;i<=deg;i++)
87  {
88  mpz_mul(coef[i],coef[i],b);
89  }
90 }
91 
92 
93 // Arithmetik
94 
95 
96 //Additionen
97 
98 //Standard - Addition
99 void Q_poly::Q_poly_add(const Q_poly a, const Q_poly b)
100 {
101  if (a.deg >= b.deg)
102  {
103  deg=a.deg;
104  mpz_t atemp, btemp;
105  mpz_init_set_ui(atemp,0);
106  mpz_init_set_ui(btemp,0);
107 
108  for (int i=0;i<=b.deg;i++)
109  {
110  mpz_mul(atemp,a.coef[i],b.denom);
111  mpz_mul(btemp,b.coef[i],a.denom);
112  mpz_add(coef[i],atemp,btemp);
113  }
114 
115  for ( int i=b.deg+1;i<=a.deg;i++)
116  {
117  mpz_mul(coef[i],a.coef[i],b.denom);
118  }
119  mpz_mul(denom,a.denom,b.denom);
120 
121  // Grad-Korrektur
122  int i=deg;
123  while(mpz_sgn(coef[i])==0 && i>=0)
124  {deg--;i--;}
125  }
126 
127  else {Q_poly_add(b,a);}
128 
129 }
130 
131 //Überschreibende Addition
132 
134 {
135  this->Q_poly_add(*this,g);
136 }
137 
138 //Addition einer Konstanten
139 void Q_poly::Q_poly_add_const(Q_poly f, const mpz_t a)
140 {
141  if (f.is_zero()==1)
142  {
143  Q_poly_set(a,f.denom);
144  }
145  else
146  {
147  Q_poly_set(f);
148  mpz_t atemp;
149  mpz_mul(atemp,a,f.denom);
150  mpz_add(coef[0],coef[0],atemp);
151  // Grad Korrektur
152  if (deg==0 && mpz_sgn(coef[0])==0)
153  Q_poly_set_zero();
154  }
155 }
156 
157 
158 //To Variante Addition einer Konstanten
159 
161 {
162  this->Q_poly_add_const(*this,a);
163 }
164 
165 //Monom Addition
166 void Q_poly::Q_poly_add_mon(const Q_poly f, mpz_t a, int i)
167 {
168  Q_poly_set(f);
169  if (i<=deg && is_zero()==0)
170  {
171  mpz_t atemp;
172  mpz_init_set_ui(atemp,0);
173  mpz_mul(atemp,a,f.denom);
174  mpz_add(coef[i],coef[i],atemp);
175 
176  // Grad Korrektur
177 
178  if (deg==i && mpz_sgn(coef[i])==0)
179  {deg--;}
180  }
181  else if (is_zero()==1)
182  {
183  deg=i;
184  for(int j=0;j<i;j++)
185  {
186  mpz_init_set_ui(coef[j],0);
187  }
188  mpz_init_set(coef[i],a);
189  mpz_init_set_ui(denom,1);
190  }
191  else if(i>deg)
192  {
193  deg=i;
194  for(int j=i-1;j>deg;j--)
195  {
196  mpz_init_set_ui(coef[j],0);
197  }
198  mpz_t atemp;
199  mpz_mul(atemp,a,f.denom);
200  mpz_init_set(coef[i],atemp);
201  }
202 }
203 
204 //To Variante Monomaddition
205 void Q_poly::Q_poly_add_mon_to(mpz_t a, int i)
206 {
207  this->Q_poly_add_mon(*this,a,i);
208 }
209 
210 //Subtraktionen
211 
212 void Q_poly::Q_poly_sub(const Q_poly a, const Q_poly b)
213 {
214  Q_poly temp;
215  temp.Q_poly_set(b);
216  temp.Q_poly_neg();
217  Q_poly_add(a,temp);
218 }
219 
220 
221 //Überschreibende Subtraktion
222 
224 {
225  this->Q_poly_sub(*this,b);
226 }
227 
228 //Subtraktion einer Konstanten
230 {
231  if (f.is_zero()==1)
232  {
233  Q_poly_set(a);
234  Q_poly_neg();
235  }
236  else
237  {
238  Q_poly_set(f);
239  mpz_t atemp;
240  mpz_init_set_ui(atemp,1);
241  mpz_mul(atemp,a,f.denom);
242  mpz_sub(coef[0],coef[0],atemp);
243  }
244 }
245 
246 
247 //To Variante Subtraktion einer Konstanten
248 
250 {
251  this->Q_poly_sub_const(*this,a);
252 }
253 
254 
255 //Monom Subtraktion
256 void Q_poly::Q_poly_sub_mon(const Q_poly f , mpz_t a, int i)
257 {
258  mpz_t temp;
259  mpz_init_set_ui(temp,0);
260  mpz_neg(temp,a);
261  Q_poly_add_mon(f,temp,i);
262 }
263 
264 //To Variante Monomsubtraktion
265 void Q_poly::Q_poly_sub_mon_to(mpz_t a, int i)
266 {
267  this->Q_poly_sub_mon(*this,a,i);
268 }
269 
270 
271 //Multiplikationen
272 
273 //Multiplikation mit Monom
275 {
276  deg=f.deg+n;
277  mpz_init_set(denom,f.denom);
278  for (int i=deg;i>=n;i--)
279  {
280  mpz_init_set(coef[i],f.coef[i-n]);
281  }
282  for (int i=n-1;i>=0;i--)
283  {
284  mpz_init_set_ui(coef[i],0);
285  }
286 }
287 
289 {
290  this->Q_poly_mon_mult(*this,n);
291 }
292 
293 
294 //Multiplikation mit Skalar
295 
296 void Q_poly::Q_poly_scalar_mult(const Q_poly g, const mpz_t n)
297 {
298  deg=g.deg;
299  mpz_init_set(denom,g.denom);
300 
301  mpz_t temp;
302  mpz_init_set_ui(temp,0);
303  for(int i=0;i<=deg;i++)
304  {
305  mpz_mul(temp,n,g.coef[i]);
306  mpz_init_set(coef[i],temp);
307  }
308 }
309 
310 
311 
312 void Q_poly::Q_poly_scalar_mult(const mpz_t n, const Q_poly g)
313 {
314  deg=g.deg;
315  mpz_init_set(denom,g.denom);
316 
317  mpz_t temp;
318  mpz_init_set_ui(temp,0);
319  for(int i=0;i<=deg;i++)
320  {
321  mpz_mul(temp,n,g.coef[i]);
322  mpz_init_set(coef[i],temp);
323  }
324 }
325 
326 
328 {
329  this->Q_poly_scalar_mult(*this,n);
330 }
331 
332 
333 
334 // Negation
335 
337 {
338  mpz_neg(denom,denom);
339 }
340 
341 // Naive Multiplikation
343 {
344 
345  if (a.is_zero()==1 || b.is_zero()==1)
346  Q_poly_set_zero();
347  else
348  {
349  mpz_t temp;
350  mpz_init_set_ui(temp,0);
351  deg = a.deg + b.deg;
352 
353  // Kopien atemp und btemp von a bzw. b, mit Nullen aufgefüllt
354  Q_poly atemp, btemp;
355  atemp.Q_poly_set(a);
356  btemp.Q_poly_set(b);
357  for(int i=a.deg+1;i<=deg;i++)
358  {
359  mpz_init_set_ui(atemp.coef[i],0);
360  }
361  for(int i=b.deg+1;i<=deg;i++)
362  {
363  mpz_init_set_ui(btemp.coef[i],0);
364  }
365  atemp.deg = deg;
366  btemp.deg = deg;
367 
368  // Multiplikationsalgorithmus
369  for (int k=0; k<=deg; k++)
370  {
371  mpz_init_set_ui(coef[k],0); // k-ter Koeffizient zunächst 0
372  for (int i=0; i<=k; i++) // dann schrittweise Summe der a[i]*b[k-i]/
373  {
374  mpz_mul(temp,atemp.coef[i],btemp.coef[k-i]);
375  mpz_add(coef[k],coef[k],temp);
376  }
377  }
378  mpz_mul(denom,a.denom,b.denom);
379  }
380 }
381 
382 //Überschreibende Multiplikation
383 
385 {
386  this->Q_poly_mult_n(*this,g);
387 }
388 
389 // Karatsuba-Multiplikation (Weimerskirch/Paar Alg. 1), ACHTUNG VORLÄUFIGE VERSION, macht noch Fehler beim Grad und ist unelegant !!!
391 {
392  // Größeren Grad feststellen
393  int n;
394  if(A.deg>=B.deg){n=A.deg+1;}
395  else{n=B.deg+1;}
396  // n auf nächste 2er-Potenz setzen (VORLÄUFIG!)
397  n = static_cast<int>(ceil(log(n)/log(2)));
398  n = static_cast<int>(pow(2,n));
399 
400  if (n==1)
401  {
402  mpz_t AB;
403  mpz_mul(AB,A.coef[0],B.coef[0]);
404  Q_poly_set(AB,A.denom);
405  }
406  else
407  {
408  // Q_polynome A und B aufspalten
409  Q_poly Au, Al, Bu, Bl;
410  Au.Q_poly_mon_div(A,n/2);
411  Al.Q_poly_mon_div_rem(A,n/2);
412  Bu.Q_poly_mon_div(B,n/2);
413  Bl.Q_poly_mon_div_rem(B,n/2);
414  Q_poly Alu,Blu;
415  Alu.Q_poly_add(Al,Au);
416  Blu.Q_poly_add(Bl,Bu);
417 
418  // Teile rekursiv multiplizieren
419  Q_poly D0, D1, D01;
420  D0.Q_poly_mult_ka(Al,Bl);
421  D1.Q_poly_mult_ka(Au,Bu);
422  D01.Q_poly_mult_ka(Alu,Blu);
423 
424  // Ergebnis zusammensetzen
425  Q_poly temp;
426  D01.Q_poly_sub_to(D0);
427  D01.Q_poly_sub_to(D1);
428  D01.Q_poly_mon_mult_to(n/2);
429  D1.Q_poly_mon_mult_to(n);
430  D1.Q_poly_add_to(D01);
431  D1.Q_poly_add_to(D0);
432  Q_poly_set(D1);
433  }
434 }
435 
436 
437 
438 //Skalare Divisionen
439 
440 void Q_poly::Q_poly_scalar_div(const Q_poly g, const mpz_t n)
441 {
442  if (mpz_sgn(n)!=0) // überprüft Teilung durch 0
443  {
444  Q_poly_set(g);
445  mpz_mul(denom,g.denom,n);
446  }
447 }
448 
449 
451 {
452  this->Q_poly_scalar_div(*this,n);
453 }
454 
455 // Division durch Monom - Quotient
456 void Q_poly::Q_poly_mon_div(const Q_poly f, const int n)
457 {
458  if (f.deg<n)
459  {
460  Q_poly_set_zero();
461  }
462  else
463  {
464  deg=f.deg-n;
465  mpz_init_set(denom,f.denom);
466 
467  for (int i=0;i<=f.deg-n;i++)
468  {
469  mpz_init_set(coef[i],f.coef[n+i]);
470  }
471  }
472 }
473 
474 // Division durch Monom - Rest
475 void Q_poly::Q_poly_mon_div_rem(const Q_poly f, const int n)
476 {
477  if (f.deg<n)
478  {
479  Q_poly_set(f);
480  }
481  else
482  {
483  // Grad-Korrektur ist inklusive
484  deg=n-1;
485  int j=deg;
486  while(mpz_sgn(f.coef[j])==0 && j>=0)
487  {
488  deg--;
489  j--;
490  mpz_init_set_ui(coef[j],0);
491  }
492  for (int i=j;i>=0;i--)
493  {
494  mpz_init_set(coef[i],f.coef[i]);
495  }
496  mpz_init_set(denom,f.denom);
497  }
498 }
499 
500 
501 
502 
503 // Euklidische Division nach Cohen Algo 3.1.1 (degA muss größer gleich deg B sein)!!
504 
506 {
507 
508  // Initialisierungen: Vergiss zunächst die Hauptnenner von A und B (--> R bzw. Bint)
509  Q_poly temp, Bint;
510  Q_poly_set(A);
511  mpz_init_set_ui(denom,1);
512  Bint.Q_poly_set(B);
513  mpz_init_set_ui(Bint.denom,1);
514  int e = A.deg - B.deg + 1;
515 
516  // Algorithmus
517  while (deg>=B.deg)
518  {
519  temp.Q_poly_mon_mult(Bint,deg-B.deg);
520  temp.Q_poly_scalar_mult_to(coef[deg]);
521 
522  Q_poly_scalar_mult_to(B.coef[B.deg]);
523  Q_poly_sub_to(temp);
524 
525  e--;
526  }
527 
528  // Terminierung
529  mpz_t d,q;
530  mpz_init_set(d,B.coef[B.deg]);
531  if (e>0)
532  {
533  mpz_pow_ui(q,d,e);
534  Q_poly_scalar_mult_to(q);
535  }
536  else if (e<0)
537  {
538  mpz_pow_ui(q,d,-e);
539  Q_poly_scalar_div_to(q);
540  }
541 
542  mpz_pow_ui(d,d,A.deg-B.deg+1);
543  mpz_mul(denom,denom,d);
544 
545  // Hauptnenner von A und B berücksichtigen
546  mpz_mul(denom,denom,A.denom);
547  Q_poly_scalar_mult_to(B.denom);
548 }
549 
550 
551 //To Variante von Algo 3.1.1 im Cohen
552 
554 {
555  this->Q_poly_div_rem(*this,B);
556 }
557 
558 
559 // Division nach Cohen 3.1.2 (gibt R und Q aus) --> Führt Pseudo-Division durch, korrigiert den Faktor aber im Nenner
561 {
562 
563  // Initialisierungen: Vergiss zunächst die Hauptnenner von A und B (--> R bzw. Bint)
564  Q_poly temp, Bint;
565  R.Q_poly_set(A);
566  mpz_init_set_ui(R.denom,1);
567  Q.Q_poly_set_zero();
568  Bint.Q_poly_set(B);
569  mpz_init_set_ui(Bint.denom,1);
570  int e = A.deg - B.deg + 1;
571 
572  // Algorithmus
573  while (R.deg>=B.deg)
574  {
575  temp.Q_poly_mon_mult(Bint,R.deg-B.deg);
576  temp.Q_poly_scalar_mult_to(R.coef[R.deg]);
577 
579  Q.Q_poly_add_mon_to(R.coef[R.deg],R.deg-B.deg);
580 
582  R.Q_poly_sub_to(temp);
583 
584  e--;
585  }
586 
587  // Terminierung
588  mpz_t d,q;
589  mpz_init_set(d,B.coef[B.deg]);
590  if (e>0)
591  {
592  mpz_pow_ui(q,d,e);
595  }
596  else if (e<0)
597  {
598  mpz_pow_ui(q,d,-e);
601  }
602 
603  mpz_pow_ui(d,d,A.deg-B.deg+1);
604  mpz_mul(R.denom,R.denom,d);
605  mpz_mul(Q.denom,Q.denom,d);
606 
607  // Hauptnenner von A und B berücksichtigen
608  mpz_mul(R.denom,R.denom,A.denom);
609  mpz_mul(Q.denom,Q.denom,A.denom);
612 }
613 
614 
615 //To Variante der exakten Division
616 
618 {
619  this->Q_poly_div(Q,R,*this,B);
620 }
621 
622 
623 // Kombinationen
624 
625 // a := a*b + c
627 {
628  Q_poly_mult_n_to(b);
629  Q_poly_add_to(c);
630 }
631 
632 //a=a*b-c
634 {
635  Q_poly_mult_n_to(b);
636  Q_poly_sub_to(c);
637 }
638 
639 
640 
641 /*
642 // a := (a+b)* c
643 void Q_poly::poly_addmult_to(const Q_poly b, const Q_poly c)
644 {
645  Q_poly a(deg,coef);
646  a.poly_add_to(b);
647  a.poly_mult_n_to(c);
648  poly_set(a);
649 }
650 */
651 
652 
653 
654 //Sonstiges
655 void Q_poly::Q_poly_horner(mpz_t erg, const mpz_t u)
656 {
657  mpz_init_set(erg,coef[deg]);
658  for (int i=deg;i>=1;i--)
659  {
660  mpz_mul(erg,erg,u);
661  mpz_add(erg,erg,coef[i-1]);
662  }
663 
664 // erg noch durch denom dividieren
665 
666 }
667 
668 // Q_polynom in Q_polynom einsetzen(Horner-Schema) KRITISCHE EINGABE x^2, x^2 ....
669 
671 {
672  Q_poly_set(A.coef[A.deg],A.denom);
673  for (int i=A.deg;i>=1;i--)
674  {
675  Q_poly_mult_n_to(B);
676  Q_poly_add_const_to(A.coef[i-1]);
677  }
678 
679  // Nenner anpassen
680 
681 }
682 
683 
684 
685 //Hilfsfunktionen
686 
687 
688 //setze Q_polynom auf Q_polynom b
690 {
691  deg=b.deg;
692  mpz_init_set(denom,b.denom);
693 
694  for(int i=0;i<=deg;i++)
695  {
696  mpz_init_set(coef[i],b.coef[i]); // Hier wird init set dringendst benötigt
697  }
698 }
699 
700 
701 // setze Q_polynom auf konstantes Q_polynom b/d
702 void Q_poly::Q_poly_set(const mpz_t b, const mpz_t d)
703 {
704  deg=0;
705  mpz_init_set(denom,d);
706  mpz_init_set(coef[0],b);
707 }
708 
709 // setze Q_polynom auf konstantes Z_polynom b
710 void Q_poly::Q_poly_set(const mpz_t b)
711 {
712  deg=0;
713  mpz_init_set_ui(denom,1);
714  mpz_init_set(coef[0],b);
715 }
716 
717 
718 //setze Q_polynom auf Nullpolynom
720 {
721  deg = -1;
722 }
723 
724 
725 // Vergleiche ob zwei Q_polynome gleich --> return 1 falls ja sont 0
726 
728 {
729  if (deg!=g.deg)
730  {
731  return 0;
732  }
733  else
734  {
735  g.Q_poly_reduce();
736  Q_poly_reduce();
737  for (int i=deg;i>=0; i--)
738  {
739  if (mpz_cmp(coef[i],g.coef[i])!=0)
740  {return 0;}
741  }
742  return 1;
743  }
744 }
745 
746 //Überprüft ob das Q_polynom 0 ist
747 int Q_poly::is_zero() const
748 {
749  if (deg<0)
750  return 1;
751  else
752  return 0;
753 
754 }
755 
756 
757 //Überprüft ob das Q_polynom 1 ist
758 int Q_poly::is_one() const
759 {
760  if (deg==0)
761  {
762  if (mpz_cmp(coef[0],denom)==0) { return 1; }
763  else { return 0; }
764  }
765  else { return 0; }
766 }
767 
768 int Q_poly::is_monic() const
769 {
770  if (mpz_cmp(coef[deg],denom)==0)
771  return 1;
772  else
773  return 0;
774 }
775 
776 // klassischer GGT nach Cohen 3.2.1
777 
779 {
780 
781  if (A.deg<B.deg)
782  Q_poly_gcd(B,A);
783  else if (B.is_zero()==1)
784  Q_poly_set(A);
785  else
786  {
787  Q_poly App;
788  Q_poly Bpp;
789  Q_poly R;
790  App.Q_poly_set(A);
791  Bpp.Q_poly_set(B);
792  mpz_init_set_ui(App.denom,1);
793  mpz_init_set_ui(Bpp.denom,1);
794 
795  while (Bpp.is_zero()==0)
796  {
797  R.Q_poly_div_rem(App,Bpp);
798  App.Q_poly_set(Bpp);
799  Bpp.Q_poly_set(R);
800  }
801  mpz_init_set(App.denom,App.coef[App.deg]);
802  Q_poly_set(App);
803  }
804 }
805 
806 
807 // Nach nach Fieker 2.12 Symbolisches Rechnen (2012) MACHT PROBLEME
808 // gibt g=s*A+t*B aus
810 {
811  if (A.deg<B.deg)
812  Q_poly_extgcd(t,s,g,B,A);
813  else if (B.is_zero()==1)
814  {
815  g.Q_poly_set(A);
816  t.Q_poly_set_zero();
817 
818  mpz_t temp;
819  mpz_init_set_ui(temp,1);
820  s.Q_poly_set(temp,A.denom);
821  }
822 
823  else
824  {
825  mpz_t temp;
826  mpz_init_set_ui(temp,1);
827 
828  Q_poly R1;
829  R1.Q_poly_set(A);
830  Q_poly R2;
831  R2.Q_poly_set(B);
832  Q_poly R3;
833 
834  Q_poly S1;
835  S1.Q_poly_set(temp,A.denom);
836  Q_poly S2;
837  S2.Q_poly_set_zero();
838  Q_poly S3;
839 
840  Q_poly T1;
841  T1.Q_poly_set_zero();
842  Q_poly T2;
843  T2.Q_poly_set(temp,A.denom);
844  Q_poly T3;
845 
846  Q_poly Q;
847 
848  while (R2.is_zero()!=1)
849  {
850  Q_poly_div(Q,R3,R1,R2);
851 
852  S3.Q_poly_mult_n(Q,S2);
853  S3.Q_poly_neg();
854  S3.Q_poly_add_to(S1);
855 
856  T3.Q_poly_mult_n(Q,T2);
857  T3.Q_poly_neg();
858  T3.Q_poly_add_to(T1);
859 
860  R1.Q_poly_set(R2);
861  R2.Q_poly_set(R3);
862 
863  S1.Q_poly_set(S2);
864  S2.Q_poly_set(S3);
865 
866  T1.Q_poly_set(T2);
867  T2.Q_poly_set(T3);
868  }
869  t.Q_poly_set(T1);
870  s.Q_poly_set(S1);
871  g.Q_poly_set(R1);
872  }
873 }
874 
875 
876 //Ein & Ausgabe
877 
878 //Eingabe
879 
881 {
882 #if 0
883  cout << "Bitte geben Sie ein Q_polynom ein! Zunächst den Grad: " << endl;
884  cin >> deg;
885  mpz_init_set_ui(denom,1);
886  cout << "Jetzt den Hauptnenner: " << endl;
887  mpz_inp_str(denom,stdin, 10);
888 
889  for ( int i=0; i<=deg;i++)
890  {
891  mpz_init_set_ui(coef[i],0);
892  printf("Geben Sie nun f[%i] ein:",i);
893  mpz_inp_str(coef[i],stdin, 10);
894  }
895 #endif
896 }
897 
898 
899 //Ausgabe
901 {
902 #if 0
903  if (is_zero()==1)
904  cout << "0" << "\n" <<endl;
905  else
906  {
907  printf("(");
908  for (int i=deg;i>=1;i--)
909  {
910  mpz_out_str(stdout,10,coef[i]);
911  printf("X%i+",i);
912  }
913  mpz_out_str(stdout,10,coef[0]);
914  printf(")/");
915  mpz_out_str(stdout,10,denom);
916  printf("\n");
917  }
918 #endif
919 }
920 
921 #endif
void Q_poly_scalar_mult(const mpz_t, const Q_poly)
Definition: AEQ.cc:312
const CanonicalForm int s
Definition: facAbsFact.cc:55
mpz_t denom
Definition: AEQ.h:16
const poly a
Definition: syzextra.cc:212
void Q_poly_mult_ka(const Q_poly, const Q_poly)
Definition: AEQ.cc:390
void Q_poly_mon_mult_to(const int)
Definition: AEQ.cc:288
void Q_poly_div_rem(const Q_poly, const Q_poly)
Definition: AEQ.cc:505
int is_zero() const
Definition: AEQ.cc:747
mpz_t coef[100]
Definition: AEQ.h:17
void Q_poly_scalar_div(const Q_poly, const mpz_t)
Definition: AEQ.cc:440
void Q_poly_multsub_to(const Q_poly, const Q_poly)
Definition: AEQ.cc:633
void Q_poly_add_mon(const Q_poly, mpz_t, int)
Definition: AEQ.cc:166
const CanonicalForm CFMap CFMap int &both_non_zero int n
Definition: cfEzgcd.cc:52
void Q_poly_sub_mon(const Q_poly, mpz_t, int)
Definition: AEQ.cc:256
void Q_poly_mult_n(Q_poly, Q_poly)
Definition: AEQ.cc:342
void Q_poly_gcd(Q_poly, Q_poly)
Definition: AEQ.cc:778
gmp_float log(const gmp_float &a)
Definition: mpr_complex.cc:345
STL namespace.
void Q_poly_sub(const Q_poly, const Q_poly)
Definition: AEQ.cc:212
void Q_poly_mult_n_to(const Q_poly)
Definition: AEQ.cc:384
void Q_poly_add_const_to(const mpz_t)
Definition: AEQ.cc:160
void Q_poly_sub_mon_to(mpz_t, int)
Definition: AEQ.cc:265
void Q_poly_neg()
Definition: AEQ.cc:336
g
Definition: cfModGcd.cc:4031
int k
Definition: cfEzgcd.cc:93
void Q_poly_add_to(const Q_poly)
Definition: AEQ.cc:133
int is_one() const
Definition: AEQ.cc:758
#define Q
Definition: sirandom.c:25
void Q_poly_print()
Definition: AEQ.cc:900
void Q_poly_mon_div(const Q_poly, const int)
Definition: AEQ.cc:456
int is_monic() const
Definition: AEQ.cc:768
void Q_poly_scalar_mult_to(const mpz_t)
Definition: AEQ.cc:327
void Q_poly_horner_Q_poly(Q_poly, const Q_poly)
Definition: AEQ.cc:670
void Q_poly_div_to(Q_poly &, Q_poly &, const Q_poly)
Definition: AEQ.cc:617
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
void Q_poly_extend(mpz_t)
Definition: AEQ.cc:83
int j
Definition: myNF.cc:70
void Q_poly_extgcd(Q_poly &, Q_poly &, Q_poly &, Q_poly, Q_poly)
Definition: AEQ.cc:809
void Q_poly_horner(mpz_t, const mpz_t)
Definition: AEQ.cc:655
#define A
Definition: sirandom.c:23
void Q_poly_add(const Q_poly, const Q_poly)
Definition: AEQ.cc:99
void Q_poly_insert()
Definition: AEQ.cc:880
All the auxiliary stuff.
FILE * f
Definition: checklibs.c:7
int i
Definition: cfEzgcd.cc:123
void Q_poly_add_mon_to(mpz_t, int)
Definition: AEQ.cc:205
void Q_poly_multadd_to(const Q_poly, const Q_poly)
Definition: AEQ.cc:626
void Q_poly_div(Q_poly &, Q_poly &, const Q_poly, const Q_poly)
Definition: AEQ.cc:560
b *CanonicalForm B
Definition: facBivar.cc:51
#define R
Definition: sirandom.c:26
void Q_poly_mon_mult(const Q_poly, const int)
Definition: AEQ.cc:274
void Q_poly_scalar_div_to(const mpz_t)
Definition: AEQ.cc:450
void Q_poly_sub_const(Q_poly, const mpz_t)
Definition: AEQ.cc:229
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_div_rem_to(const Q_poly)
Definition: AEQ.cc:553
int is_equal(Q_poly &)
Definition: AEQ.cc:727
void Q_poly_reduce()
Definition: AEQ.cc:46
Q_poly()
Definition: AEQ.cc:14
void Q_poly_sub_const_to(const mpz_t)
Definition: AEQ.cc:249
void Q_poly_mon_div_rem(const Q_poly, const int)
Definition: AEQ.cc:475
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:418
const poly b
Definition: syzextra.cc:213
void Q_poly_sub_to(const Q_poly)
Definition: AEQ.cc:223
void Q_poly_add_const(Q_poly, const mpz_t)
Definition: AEQ.cc:139
void Q_poly_set_zero()
Definition: AEQ.cc:719