RationalNumber rnSubtract(RationalNumber n1, RationalNumber n2){
printf("rsSubtract \n");
if( (rnIsValid(n1) && rnIsValid(n2)) && !(rnIsNotNull(n1) && rnIsNotNull(n2)) ){
RationalNumber rNew;
int fn = n1.nominator * n2.denominator;
int fd = n1.denominator * n2.denominator;
int sn = n2.nominator * n1.denominator;
int sd = fd;
rNew.nominator = fn - sn;
rNew.denominator = sd;
int max_ = max(rNew.nominator,rNew.denominator);
int min_ = min(rNew.nominator,rNew.denominator);
int ggT_ = ggT(max_,min_);
rNew.nominator = rNew.nominator / ggT_;
rNew.denominator = rNew.denominator / ggT_;
return rNew;
}else{
return rnNaN;
}
}
int ggT(int i, int j){
if( i % j == 0){
return j;
}else{
return ggT(j, i%j);
}
}
bool rnEqual(RationalNumber n1, RationalNumber n2){
printf("rnEqual \n");
if(rnIsNotNull(n1) || rnIsNotNull(n2)) return false;
if(!rnIsValid(n1) && !rnIsValid(n2))return false;
int ggT1 = ggT(max(n1.nominator,n1.denominator),min(n1.nominator,n1.denominator));
int ggT2 = ggT(max(n2.nominator,n2.denominator),min(n2.nominator,n2.denominator));
RationalNumber rnEqual1 = { n1.nominator / ggT1 , n1.denominator / ggT1 };
RationalNumber rnEqual2 = { n2.nominator / ggT2 , n2.denominator / ggT2 };
if(rnEqual1.nominator == rnEqual2.nominator && rnEqual1.denominator == rnEqual2.denominator){
return true;
}
return false;
}
int ggT(int a, int b){
//returns the greatest common divisor
if(b == 0)
return a;
else return ggT(b, a % b);
}
int mui(int d, int m){
int k=1;
if(ggT(d,m)!=1)
return -1;
while(1){
if((m*k+1)%d==0)
return ((m*k+1)/d);
k++;
}
}
bool rnLessThan(RationalNumber n1, RationalNumber n2){
printf("rnLessThan \n");
if(!rnIsValid(n1) && !rnIsValid(n2))return false;
if(rnIsNotNull(n1) || rnIsNotNull(n2)) return false;
if(rnEqual(n1,n2)) return false;
int ggT1 = ggT(max(n1.nominator,n1.denominator),min(n1.nominator,n1.denominator));
int ggT2 = ggT(max(n2.nominator,n2.denominator),min(n2.nominator,n2.denominator));
RationalNumber rnLess1 = { n1.nominator / ggT1 , n1.denominator / ggT1 };
RationalNumber rnLess2 = { n2.nominator / ggT2 , n2.denominator / ggT2 };
if( rnLess1.denominator > 1 && rnLess1.nominator <= rnLess2.nominator && rnLess1.denominator >= rnLess2.denominator ) {
return true;
}else if(rnLess1.denominator < 1 && rnLess1.denominator < rnLess2.denominator){
return true;
}else{
return false;
}
}
int A1(void)
{
int a, b, c, s;
bool invalid;
printf("Berechnung des ggT von 3 Zahlen\n");
invalid = true;
do
{
printf("Zahl 1 (>0) eingeben> ");
scanf("%d", &a);
fflush(stdin);
if (a > 0)
invalid = false;
else
printf("Ungültige eingabe!\n");
} while (invalid);
invalid = true;
do
{
printf("Zahl 2 (>0) eingeben> ");
scanf("%d", &b);
fflush(stdin);
if (b > 0)
invalid = false;
else
printf("Ungültige eingabe!\n");
} while (invalid);
invalid = true;
do
{
printf("Zahl 3 (>0) eingeben> ");
scanf("%d", &c);
fflush(stdin);
if (c > 0)
invalid = false;
else
printf("Ungültige eingabe!\n");
} while (invalid);
s = ggT(a, b, c);
printf("ggT von %d,%d,%d ist %d", a, b, c, s);
return 0;
}
polynom& minpoly(matrix const& A, basis const& V, gaussinfo const& U,
polynom& m, vektor& v, vector<K>& f)
{
unsigned int dim_V = V.size(),i;//Die Anzahl der Vektoren, die V aufspannen. V kann auch
// ein Untervektorraum sein.
unsigned int dim_U = U.A.size(); //Anzal der Vektoren, die U ( <= V) aufspannen.
vector<polynom> ordpol(dim_V);//Vektor mit Ordnungspolynomen
// zu den Vektoren der Basis V
polynom c,d,C,D,D2,t,T;//Diese Polynome werden für der Algorithmus weiter unten benötigt.
vektor ret,ret2; // Dies sind lediglich Dummy Variablen, die für die
// Funktion mult unten benutzt werden.
// Einige Tests
if( A[0].size() != A.size() ) {//Matrix quadraisch ?
cout << "Fehler in minpoly(...):\nDie Matrix A ist"
<< " nicht quadratisch.\n";
exit(1);
}
if( V[0].size() != A.size() ) {//sind die Dimensionen der Matrix und der
// Vektoren gleich?
cout << "Fehler in minpoly(...):\nDie Matrix A und die Vektoren "
<< "der Basis V haben nicht die gleiche Dimension.\n" ;
exit(1);
}
//Vorarbeit: Erzeuge das Ordnungspolynom für die
// Vektoren einer Basis V
for(i=0; i<dim_V ; i++ ) {
ordpoly(A,V[i],U,ordpol[i],f);
}
//Initialisierung für den Algorithmus
m = ordpol[0];
v = V[0];
//Dies ist der eigentliche Algorithmus um aus den
//Ordnungspolynomen das Minimalpolynom zu berechnen.
//Der Algorithmus könnte viel einfacher sein, wenn man
//keinen Vektor v haben wollte, der das Minimalpolynom
//als Ordnungspolynom hat.
for( i=1; i<dim_V ; i++ ) {
if( deg(ordpol[i]) == 0 ) continue;
c=m;
d=ordpol[i];
t = ggT(c,d);
algo_r(c,d/t,C);
algo_r(d,c/t,D);
T = ggT(C,D);
D2=D/T;
m=C*D2;
v = mult(c/C,A,v,ret) + mult(d/D2,A,V[i],ret2);
if( deg(m) == dim_V - dim_U ) break; // Minimalpolynom kann nicht grösser werden
}
normiere_poly(m);
if( U.A.size() > 0 )
ordpoly(A,v,U,ordpol[0],f);
//Dieser Aufruf geschieht um f zu berechnen.
//Dies macht nur Sinn, wenn U.A nicht leer ist.
//ordpol[0] ist hier lediglich ein dummy.
return m;
}
int kgV(int a, int b) {
return a * (b / ggT(a, b));
}
void updateQR(Matrix & Q, Matrix & R, int NUM_TX, int NUM_RX,int i)
{
int ni = NUM_RX - i;
int ti = NUM_TX - i;
Matrix Rtemp(ni,ti);
Matrix Qtemp(ni,ni);
Matrix Atemp(ni,ti);
Matrix Itemp(ni,ni);
int k,l;
for(k = i; k < NUM_RX; k++)
{
for(l = i ; l < NUM_TX; l++)
{
Atemp(k-i , l-i) = R(k,l);
}
}
for(k = 0; k < ni; k++)
{
for(l = 0; l < ni; l++)
{
if(k == l) Itemp(k,l) = 1;
else Itemp(k,l) = 0;
}
}
Matrix x(ni,1);
for(k = 0; k < ni; k++)
x(k,0) = Atemp(k,0);
double xSize = eSize(x,ni);
int sign;
if ( x(0,0) >= 0 ) sign = 1;
else sign = -1;
Matrix g(ni,1);
g(0,0) = x(0,0) + sign * xSize;
for(k = 1; k < ni; k++)
g(k,0) = x(k,0);
double gSize = eSize(g,ni);
double Qscale = 2/(gSize * gSize);
Matrix ggT(ni,ni);
ggT = g * (~g);
for(k = 0; k < ni; k++)
for(l = 0; l < ni; l++)
ggT(k,l) = Qscale * ggT(k,l);
Qtemp = Itemp - ggT;
Rtemp = Qtemp * Atemp;
Matrix Qeff(NUM_RX,NUM_RX);
for(k = 0; k < NUM_RX; k++)
for(l = 0; l < NUM_RX; l++)
Qeff(k,l) = 0;
for(k = 0; k < i; k++) Qeff(k,k) = 1;
for(k = i; k < NUM_RX; k++)
{
for(l = i; l < NUM_TX; l++)
R(k,l) = Rtemp(k-i,l-i);
for(l = i; l < NUM_RX; l++)
Qeff(k,l) = Qtemp(k-i,l-i);
}
Q = Q * Qeff;
}
