Public Member Functions | Data Fields
Q_poly Class Reference

#include <AEQ.h>

Public Member Functions

 Q_poly ()
 
 Q_poly (int, mpz_t, mpz_t *)
 
void Q_poly_reduce ()
 
void Q_poly_extend (mpz_t)
 
void Q_poly_add (const Q_poly, const Q_poly)
 
void Q_poly_add_to (const Q_poly)
 
void Q_poly_add_mon (const Q_poly, mpz_t, int)
 
void Q_poly_add_mon_to (mpz_t, int)
 
void Q_poly_add_const (Q_poly, const mpz_t)
 
void Q_poly_add_const_to (const mpz_t)
 
void Q_poly_sub (const Q_poly, const Q_poly)
 
void Q_poly_sub_to (const Q_poly)
 
void Q_poly_sub_mon (const Q_poly, mpz_t, int)
 
void Q_poly_sub_mon_to (mpz_t, int)
 
void Q_poly_sub_const (Q_poly, const mpz_t)
 
void Q_poly_sub_const_to (const mpz_t)
 
void Q_poly_mult_n (Q_poly, Q_poly)
 
void Q_poly_mult_n_to (const Q_poly)
 
void Q_poly_mult_ka (const Q_poly, const Q_poly)
 
void Q_poly_scalar_mult (const mpz_t, const Q_poly)
 
void Q_poly_scalar_mult (const Q_poly, const mpz_t)
 
void Q_poly_scalar_mult_to (const mpz_t)
 
void Q_poly_neg ()
 
void Q_poly_mon_mult (const Q_poly, const int)
 
void Q_poly_mon_mult_to (const int)
 
void Q_poly_div (Q_poly &, Q_poly &, const Q_poly, const Q_poly)
 
void Q_poly_div_to (Q_poly &, Q_poly &, const Q_poly)
 
void Q_poly_scalar_div (const Q_poly, const mpz_t)
 
void Q_poly_scalar_div_to (const mpz_t)
 
void Q_poly_div_rem (const Q_poly, const Q_poly)
 
void Q_poly_div_rem_to (const Q_poly)
 
void Q_poly_mon_div (const Q_poly, const int)
 
void Q_poly_mon_div_rem (const Q_poly, const int)
 
void Q_poly_multadd_to (const Q_poly, const Q_poly)
 
void Q_poly_multsub_to (const Q_poly, const Q_poly)
 
void Q_poly_set (const Q_poly)
 
void Q_poly_set (const mpz_t)
 
void Q_poly_set (const mpz_t, const mpz_t)
 
void Q_poly_set_zero ()
 
void Q_poly_horner (mpz_t, const mpz_t)
 
void Q_poly_horner_Q_poly (Q_poly, const Q_poly)
 
void Q_poly_gcd (Q_poly, Q_poly)
 
void Q_poly_extgcd (Q_poly &, Q_poly &, Q_poly &, Q_poly, Q_poly)
 
int is_equal (Q_poly &)
 
int is_zero () const
 
int is_one () const
 
int is_monic () const
 
void Q_poly_insert ()
 
void Q_poly_print ()
 

Data Fields

int deg
 
mpz_t denom
 
mpz_t coef [100]
 

Detailed Description

Definition at line 9 of file AEQ.h.

Constructor & Destructor Documentation

§ Q_poly() [1/2]

Q_poly::Q_poly ( )

Definition at line 14 of file AEQ.cc.

15 {
16  deg=-1;
17  mpz_init_set_ui(denom,1);
18  mpz_init_set_ui(coef[0],0);
19 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15

§ Q_poly() [2/2]

Q_poly::Q_poly ( int  n,
mpz_t  d,
mpz_t *  a 
)

Definition at line 23 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
const poly a
Definition: syzextra.cc:212
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

Member Function Documentation

§ is_equal()

int Q_poly::is_equal ( Q_poly g)

Definition at line 727 of file AEQ.cc.

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 }
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123
void Q_poly_reduce()
Definition: AEQ.cc:46

§ is_monic()

int Q_poly::is_monic ( ) const

Definition at line 768 of file AEQ.cc.

769 {
770  if (mpz_cmp(coef[deg],denom)==0)
771  return 1;
772  else
773  return 0;
774 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15

§ is_one()

int Q_poly::is_one ( ) const

Definition at line 758 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15

§ is_zero()

int Q_poly::is_zero ( ) const

Definition at line 747 of file AEQ.cc.

748 {
749  if (deg<0)
750  return 1;
751  else
752  return 0;
753 
754 }
int deg
Definition: AEQ.h:15

§ Q_poly_add()

void Q_poly::Q_poly_add ( const Q_poly  a,
const Q_poly  b 
)

Definition at line 99 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
void Q_poly_add(const Q_poly, const Q_poly)
Definition: AEQ.cc:99
int i
Definition: cfEzgcd.cc:123

§ Q_poly_add_const()

void Q_poly::Q_poly_add_const ( Q_poly  f,
const mpz_t  a 
)

Definition at line 139 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
const poly a
Definition: syzextra.cc:212
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int is_zero() const
Definition: AEQ.cc:747
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_set_zero()
Definition: AEQ.cc:719

§ Q_poly_add_const_to()

void Q_poly::Q_poly_add_const_to ( const mpz_t  a)

Definition at line 160 of file AEQ.cc.

161 {
162  this->Q_poly_add_const(*this,a);
163 }
const poly a
Definition: syzextra.cc:212
void Q_poly_add_const(Q_poly, const mpz_t)
Definition: AEQ.cc:139

§ Q_poly_add_mon()

void Q_poly::Q_poly_add_mon ( const Q_poly  f,
mpz_t  a,
int  i 
)

Definition at line 166 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
const poly a
Definition: syzextra.cc:212
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int j
Definition: myNF.cc:70
int is_zero() const
Definition: AEQ.cc:747
int i
Definition: cfEzgcd.cc:123
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_add_mon_to()

void Q_poly::Q_poly_add_mon_to ( mpz_t  a,
int  i 
)

Definition at line 205 of file AEQ.cc.

206 {
207  this->Q_poly_add_mon(*this,a,i);
208 }
const poly a
Definition: syzextra.cc:212
void Q_poly_add_mon(const Q_poly, mpz_t, int)
Definition: AEQ.cc:166
int i
Definition: cfEzgcd.cc:123

§ Q_poly_add_to()

void Q_poly::Q_poly_add_to ( const Q_poly  g)

Definition at line 133 of file AEQ.cc.

134 {
135  this->Q_poly_add(*this,g);
136 }
void Q_poly_add(const Q_poly, const Q_poly)
Definition: AEQ.cc:99

§ Q_poly_div()

void Q_poly::Q_poly_div ( Q_poly Q,
Q_poly R,
const Q_poly  A,
const Q_poly  B 
)

Definition at line 560 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
void Q_poly_scalar_mult_to(const mpz_t)
Definition: AEQ.cc:327
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
void Q_poly_add_mon_to(mpz_t, int)
Definition: AEQ.cc:205
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_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_sub_to(const Q_poly)
Definition: AEQ.cc:223
void Q_poly_set_zero()
Definition: AEQ.cc:719

§ Q_poly_div_rem()

void Q_poly::Q_poly_div_rem ( const Q_poly  A,
const Q_poly  B 
)

Definition at line 505 of file AEQ.cc.

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);
521 
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);
535  }
536  else if (e<0)
537  {
538  mpz_pow_ui(q,d,-e);
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);
548 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
void Q_poly_scalar_mult_to(const mpz_t)
Definition: AEQ.cc:327
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
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_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_sub_to(const Q_poly)
Definition: AEQ.cc:223

§ Q_poly_div_rem_to()

void Q_poly::Q_poly_div_rem_to ( const Q_poly  B)

Definition at line 553 of file AEQ.cc.

554 {
555  this->Q_poly_div_rem(*this,B);
556 }
void Q_poly_div_rem(const Q_poly, const Q_poly)
Definition: AEQ.cc:505

§ Q_poly_div_to()

void Q_poly::Q_poly_div_to ( Q_poly Q,
Q_poly R,
const Q_poly  B 
)

Definition at line 617 of file AEQ.cc.

618 {
619  this->Q_poly_div(Q,R,*this,B);
620 }
void Q_poly_div(Q_poly &, Q_poly &, const Q_poly, const Q_poly)
Definition: AEQ.cc:560

§ Q_poly_extend()

void Q_poly::Q_poly_extend ( mpz_t  b)

Definition at line 83 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123
const poly b
Definition: syzextra.cc:213

§ Q_poly_extgcd()

void Q_poly::Q_poly_extgcd ( Q_poly s,
Q_poly t,
Q_poly g,
Q_poly  A,
Q_poly  B 
)

Definition at line 809 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
void Q_poly_mult_n(Q_poly, Q_poly)
Definition: AEQ.cc:342
void Q_poly_neg()
Definition: AEQ.cc:336
void Q_poly_add_to(const Q_poly)
Definition: AEQ.cc:133
#define Q
Definition: sirandom.c:25
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
void Q_poly_extgcd(Q_poly &, Q_poly &, Q_poly &, Q_poly, Q_poly)
Definition: AEQ.cc:809
int is_zero() const
Definition: AEQ.cc:747
void Q_poly_div(Q_poly &, Q_poly &, const Q_poly, const Q_poly)
Definition: AEQ.cc:560
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_set_zero()
Definition: AEQ.cc:719

§ Q_poly_gcd()

void Q_poly::Q_poly_gcd ( Q_poly  A,
Q_poly  B 
)

Definition at line 778 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
void Q_poly_div_rem(const Q_poly, const Q_poly)
Definition: AEQ.cc:505
mpz_t coef[100]
Definition: AEQ.h:17
void Q_poly_gcd(Q_poly, Q_poly)
Definition: AEQ.cc:778
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
const ring R
Definition: DebugPrint.cc:36
int is_zero() const
Definition: AEQ.cc:747
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_horner()

void Q_poly::Q_poly_horner ( mpz_t  erg,
const mpz_t  u 
)

Definition at line 655 of file AEQ.cc.

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 }
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_horner_Q_poly()

void Q_poly::Q_poly_horner_Q_poly ( Q_poly  A,
const Q_poly  B 
)

Definition at line 670 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
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
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_insert()

void Q_poly::Q_poly_insert ( )

Definition at line 880 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_mon_div()

void Q_poly::Q_poly_mon_div ( const Q_poly  f,
const int  n 
)

Definition at line 456 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123
void Q_poly_set_zero()
Definition: AEQ.cc:719

§ Q_poly_mon_div_rem()

void Q_poly::Q_poly_mon_div_rem ( const Q_poly  f,
const int  n 
)

Definition at line 475 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_mon_mult()

void Q_poly::Q_poly_mon_mult ( const Q_poly  f,
const int  n 
)

Definition at line 274 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_mon_mult_to()

void Q_poly::Q_poly_mon_mult_to ( const int  n)

Definition at line 288 of file AEQ.cc.

289 {
290  this->Q_poly_mon_mult(*this,n);
291 }
void Q_poly_mon_mult(const Q_poly, const int)
Definition: AEQ.cc:274

§ Q_poly_mult_ka()

void Q_poly::Q_poly_mult_ka ( const Q_poly  A,
const Q_poly  B 
)

Definition at line 390 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
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
mpz_t coef[100]
Definition: AEQ.h:17
gmp_float log(const gmp_float &a)
Definition: mpr_complex.cc:345
void Q_poly_add_to(const Q_poly)
Definition: AEQ.cc:133
void Q_poly_mon_div(const Q_poly, const int)
Definition: AEQ.cc:456
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
void Q_poly_add(const Q_poly, const Q_poly)
Definition: AEQ.cc:99
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689
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
void Q_poly_sub_to(const Q_poly)
Definition: AEQ.cc:223

§ Q_poly_mult_n()

void Q_poly::Q_poly_mult_n ( Q_poly  a,
Q_poly  b 
)

Definition at line 342 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int k
Definition: cfEzgcd.cc:93
int deg
Definition: AEQ.h:15
Definition: AEQ.h:9
int is_zero() const
Definition: AEQ.cc:747
int i
Definition: cfEzgcd.cc:123
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689
void Q_poly_set_zero()
Definition: AEQ.cc:719

§ Q_poly_mult_n_to()

void Q_poly::Q_poly_mult_n_to ( const Q_poly  g)

Definition at line 384 of file AEQ.cc.

385 {
386  this->Q_poly_mult_n(*this,g);
387 }
void Q_poly_mult_n(Q_poly, Q_poly)
Definition: AEQ.cc:342

§ Q_poly_multadd_to()

void Q_poly::Q_poly_multadd_to ( const Q_poly  b,
const Q_poly  c 
)

Definition at line 626 of file AEQ.cc.

627 {
628  Q_poly_mult_n_to(b);
629  Q_poly_add_to(c);
630 }
void Q_poly_mult_n_to(const Q_poly)
Definition: AEQ.cc:384
void Q_poly_add_to(const Q_poly)
Definition: AEQ.cc:133

§ Q_poly_multsub_to()

void Q_poly::Q_poly_multsub_to ( const Q_poly  b,
const Q_poly  c 
)

Definition at line 633 of file AEQ.cc.

634 {
635  Q_poly_mult_n_to(b);
636  Q_poly_sub_to(c);
637 }
void Q_poly_mult_n_to(const Q_poly)
Definition: AEQ.cc:384
void Q_poly_sub_to(const Q_poly)
Definition: AEQ.cc:223

§ Q_poly_neg()

void Q_poly::Q_poly_neg ( )

Definition at line 336 of file AEQ.cc.

337 {
338  mpz_neg(denom,denom);
339 }
mpz_t denom
Definition: AEQ.h:16

§ Q_poly_print()

void Q_poly::Q_poly_print ( )

Definition at line 900 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int is_zero() const
Definition: AEQ.cc:747
int i
Definition: cfEzgcd.cc:123

§ Q_poly_reduce()

void Q_poly::Q_poly_reduce ( )

Definition at line 46 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int j
Definition: myNF.cc:70
int is_zero() const
Definition: AEQ.cc:747
int i
Definition: cfEzgcd.cc:123

§ Q_poly_scalar_div()

void Q_poly::Q_poly_scalar_div ( const Q_poly  g,
const mpz_t  n 
)

Definition at line 440 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_scalar_div_to()

void Q_poly::Q_poly_scalar_div_to ( const mpz_t  n)

Definition at line 450 of file AEQ.cc.

451 {
452  this->Q_poly_scalar_div(*this,n);
453 }
void Q_poly_scalar_div(const Q_poly, const mpz_t)
Definition: AEQ.cc:440

§ Q_poly_scalar_mult() [1/2]

void Q_poly::Q_poly_scalar_mult ( const mpz_t  n,
const Q_poly  g 
)

Definition at line 312 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_scalar_mult() [2/2]

void Q_poly::Q_poly_scalar_mult ( const Q_poly  g,
const mpz_t  n 
)

Definition at line 296 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_scalar_mult_to()

void Q_poly::Q_poly_scalar_mult_to ( const mpz_t  n)

Definition at line 327 of file AEQ.cc.

328 {
329  this->Q_poly_scalar_mult(*this,n);
330 }
void Q_poly_scalar_mult(const mpz_t, const Q_poly)
Definition: AEQ.cc:312

§ Q_poly_set() [1/3]

void Q_poly::Q_poly_set ( const Q_poly  b)

Definition at line 689 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
int i
Definition: cfEzgcd.cc:123

§ Q_poly_set() [2/3]

void Q_poly::Q_poly_set ( const mpz_t  b)

Definition at line 710 of file AEQ.cc.

711 {
712  deg=0;
713  mpz_init_set_ui(denom,1);
714  mpz_init_set(coef[0],b);
715 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
const poly b
Definition: syzextra.cc:213

§ Q_poly_set() [3/3]

void Q_poly::Q_poly_set ( const mpz_t  b,
const mpz_t  d 
)

Definition at line 702 of file AEQ.cc.

703 {
704  deg=0;
705  mpz_init_set(denom,d);
706  mpz_init_set(coef[0],b);
707 }
mpz_t denom
Definition: AEQ.h:16
mpz_t coef[100]
Definition: AEQ.h:17
int deg
Definition: AEQ.h:15
const poly b
Definition: syzextra.cc:213

§ Q_poly_set_zero()

void Q_poly::Q_poly_set_zero ( )

Definition at line 719 of file AEQ.cc.

720 {
721  deg = -1;
722 }
int deg
Definition: AEQ.h:15

§ Q_poly_sub()

void Q_poly::Q_poly_sub ( const Q_poly  a,
const Q_poly  b 
)

Definition at line 212 of file AEQ.cc.

213 {
214  Q_poly temp;
215  temp.Q_poly_set(b);
216  temp.Q_poly_neg();
217  Q_poly_add(a,temp);
218 }
void Q_poly_neg()
Definition: AEQ.cc:336
Definition: AEQ.h:9
void Q_poly_add(const Q_poly, const Q_poly)
Definition: AEQ.cc:99
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_sub_const()

void Q_poly::Q_poly_sub_const ( Q_poly  f,
const mpz_t  a 
)

Definition at line 229 of file AEQ.cc.

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 }
mpz_t denom
Definition: AEQ.h:16
const poly a
Definition: syzextra.cc:212
mpz_t coef[100]
Definition: AEQ.h:17
void Q_poly_neg()
Definition: AEQ.cc:336
int is_zero() const
Definition: AEQ.cc:747
void Q_poly_set(const Q_poly)
Definition: AEQ.cc:689

§ Q_poly_sub_const_to()

void Q_poly::Q_poly_sub_const_to ( const mpz_t  a)

Definition at line 249 of file AEQ.cc.

250 {
251  this->Q_poly_sub_const(*this,a);
252 }
const poly a
Definition: syzextra.cc:212
void Q_poly_sub_const(Q_poly, const mpz_t)
Definition: AEQ.cc:229

§ Q_poly_sub_mon()

void Q_poly::Q_poly_sub_mon ( const Q_poly  f,
mpz_t  a,
int  i 
)

Definition at line 256 of file AEQ.cc.

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 }
const poly a
Definition: syzextra.cc:212
void Q_poly_add_mon(const Q_poly, mpz_t, int)
Definition: AEQ.cc:166
int i
Definition: cfEzgcd.cc:123

§ Q_poly_sub_mon_to()

void Q_poly::Q_poly_sub_mon_to ( mpz_t  a,
int  i 
)

Definition at line 265 of file AEQ.cc.

266 {
267  this->Q_poly_sub_mon(*this,a,i);
268 }
const poly a
Definition: syzextra.cc:212
void Q_poly_sub_mon(const Q_poly, mpz_t, int)
Definition: AEQ.cc:256
int i
Definition: cfEzgcd.cc:123

§ Q_poly_sub_to()

void Q_poly::Q_poly_sub_to ( const Q_poly  b)

Definition at line 223 of file AEQ.cc.

224 {
225  this->Q_poly_sub(*this,b);
226 }
void Q_poly_sub(const Q_poly, const Q_poly)
Definition: AEQ.cc:212

Field Documentation

§ coef

mpz_t Q_poly::coef[100]

Definition at line 17 of file AEQ.h.

§ deg

int Q_poly::deg

Definition at line 15 of file AEQ.h.

§ denom

mpz_t Q_poly::denom

Definition at line 16 of file AEQ.h.


The documentation for this class was generated from the following files: