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