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;
}
}
RationalNumber rnDivide(RationalNumber n, RationalNumber n1) {
RationalNumber reziprok = { n1.denominator, n1.numerator };
if(!rnIsValid(n) || !rnIsValid(n1) || !rnIsValid(reziprok)) {
RationalNumber tmp = { 0, 0};
return tmp;
}
return rnNormalize(rnMultiply(n, reziprok));
}
RationalNumber rnMultiply(RationalNumber n1, RationalNumber n2){
printf("rnMultiply \n");
if( (rnIsValid(n1) && rnIsValid(n2)) && !(rnIsNotNull(n1) && rnIsNotNull(n2)) ){
RationalNumber rNew;
rNew.nominator = n1.nominator * n2.nominator;
rNew.denominator = n1.denominator * n2.denominator;
return rNew;
}else{
return rnNaN;
}
}
/*
adds a new rational number to the collection or raises
the count by one
*/
void rncAdd(RationalNumberCollection* c, RationalNumber r){
if(!rnIsValid(r)) {
return;
}
RationalNumber rnOne = { 1, 1 };
RationalNumber rnZero = { 0, 1 };
if(c->totalUniqueCount == 0){
c->rnList[0] = r;
c->rnList[1]= rnOne;
rncAdded(c, r, true);
}else{
int index = rncExists(c, r);
if(index != -1){
if (rnEqual(r,rnZero) && rncCount(c,r) == 0) {
rncAddSorted(c,r);
rncAdded(c, r, true);
} else {
c->rnList[index+1] = rnAdd(c->rnList[index+1],rnOne);
rncAdded(c, r, false);
}
} else {
if (c->totalUniqueCount == 1000) {
return;
}
//c->rnList[(c->totalUniqueCount)*2] = r;
//c->rnList[(c->totalUniqueCount)*2+1] = rnOne;
rncAddSorted(c,r);
rncAdded(c, r, true);
}
return;
}
}
int rncCount(RationalNumberCollection *c, RationalNumber rn) {
// Wenn rn ungültig -> return 0
if (!rnIsValid(rn)) {
return 0;
}
// Länge der Collection bestimmen
int len = rncTotalUniqueCount(*(&c));
// Wenn Collection leer ist -> return 0
if (len == 0) {
return 0;
}
// Zeiger auf Collection
RationalNumber (*ptr)[2] = c->rn;
// rn kürzen
rn = rnShorten(rn);
// Falls Bruch bereits vorhanden, ermittel Vorkommen des Bruchs
int i = rncSearch(*(&c), rn, 0, len-1);
if (i >= 0) {
return ptr[i][1].numerator;
}
return 0;
}
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;
}
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;
}
}
RationalNumber rnDivide(RationalNumber n1, RationalNumber n2){
printf("rnDivide \n");
if( (rnIsValid(n1) && rnIsValid(n2)) && !(rnIsNotNull(n1) && rnIsNotNull(n2)) ){
RationalNumber rNew;
RationalNumber swap;
swap.nominator = n2.denominator;
swap.denominator = n2.nominator;
n2.nominator = swap.nominator;
n2.denominator = swap.denominator;
rNew.nominator = n1.nominator * n2.nominator;
rNew.denominator = n1.denominator * n2.denominator;
return rNew;
}else{
return rnNaN;
}
}
void rncAdd(RationalNumberCollection *c, RationalNumber rn) {
// Wenn rn ungültig -> return
if (!rnIsValid(rn)) {
return;
}
// Länge der Collection ermitteln
int len = rncTotalUniqueCount(*(&c));
// rn kürzen
rn = rnShorten(rn);
// Zeiger auf Collection
RationalNumber (*ptr)[2] = c->rn;
// Falls Bruch bereits vorhanden
int i = rncSearch(*(&c), rn, 0, len-1);
if (i >= 0) {
// Erhöhe Counter des Bruchs
ptr[i][1].numerator++;
// Erhöhe totalCount der Collection
c->totalCount++;
// Erhöhe sum der Collection
c->sum = rnShorten(rnAdd(c->sum,rn));
// Berechne average der Collection
rncCalcAverage(*(&c));
return;
}
// Falls nocht nicht alle Elemente des Arrays belegt sind
if (len < MAXSIZE) {
// Trage den Bruch ein und erhöhe den Counter des Bruchs
ptr[len][0] = rn;
ptr[len][1].numerator++;
// Erhöhe totalUniqueCount der Collection
c->totalUniqueCount++;
// Erhöhe totalCount der Collection
c->totalCount++;
// Erhöhe sum der Collection
c->sum = rnShorten(rnAdd(c->sum,rn));
// Berechne average der Collection
rncCalcAverage(*(&c));
}
// Collection sortieren wenn Länge der Collection > 0
if (len > 0) {
rncSort(*(&c), len+1);
}
// Berechne median der Collection
rncCalcMedian(*(&c));
}
int main()
{
printf("Performing unit tests for RationalNumber...");
fflush(stdout);
/* Part 1 - RationalNumber data type */
RationalNumber n1 = { 3, 4 },
n2 = { 6, 4 },
n3 = { 3, 2 },
n4 = { -9, -6 },
n5 = { 9, -6 },
n6 = { 9, 4 },
n0 = { 0, 4 },
nn = { 4, 0 };
assert( rnIsValid(n0) );
assert( !rnIsValid(nn) );
assert( rnEqual( n2, n3) );
assert( rnEqual( rnAdd(n1,n1), n2) );
assert( rnEqual( n2,n4) );
assert( !rnEqual( n4,n5) );
assert( rnLessThan( n5,n3) );
RationalNumber t1 = rnAdd(n1,n2);
RationalNumber t2 = rnDivide(n3,n3);
RationalNumber t3 = rnDivide(n2,n2);
RationalNumber t4 = rnDivide(n6,n0);
assert( rnEqual(t1, n6) );
assert( rnEqual(t2, t3) );
assert( !rnIsValid(t4) );
printf(" successful!\n");
return 0;
}
void rncRemove(RationalNumberCollection *c, RationalNumber rn) {
// Wenn rn ungültig -> return
if (!rnIsValid(rn)) {
return;
}
// Länge der Collection ermitteln
int len = rncTotalUniqueCount(*(&c));
// Wenn Collection leer -> return
if (len == 0) {
return;
}
// rn kürzen
rn = rnShorten(rn);
// Zeiger auf Collection
RationalNumber (*ptr)[2] = c->rn;
// Falls Bruch bereits vorhanden
int i = rncSearch(*(&c), rn, 0, len-1);
if (i >= 0) {
// Veringere Counter des Bruchs
ptr[i][1].numerator--;
// Veringere totalCount der Collection
c->totalCount--;
// Verringere sum der Collection
c->sum = rnShorten(rnSubtract(c->sum,rn));
// Wenn Counter anschließend == 0, entferne Bruch aus Collection
if (ptr[i][1].numerator == 0) {
ptr[i][0].numerator = 0;
ptr[i][0].denominator = 0;
// Verringere totalUniqueCount der Collection
c->totalUniqueCount--;
// Collection sortieren wenn Bruch nicht letzter Bruch in der Collection war
if (len > 1) {
rncSort(*(&c), len);
}
// Berechne median der Collection
rncCalcMedian(*(&c));
}
// Berechne average der Collection
rncCalcAverage(*(&c));
}
}
/*
reduce the count of the given rational number by one and removes
the rational number if the count reaches zero
*/
void rncRemove(RationalNumberCollection* c, RationalNumber r){
if(!rnIsValid(r) || c->totalUniqueCount==0){
return;
}else{
int index = rncExists(c, r);
if(index == -1){
return;
}else{
RationalNumber rnOne = { 1,1 };
c->rnList[index+1] = rnSubtract(c->rnList[index+1], rnOne);
if(c->rnList[index+1].numerator == 0){
rncCleanUp(c,index);
rncRemoved(c, r, true);
}else{
rncRemoved(c, r, false);
}
}
return;
}
}
