Esempio n. 1
0
/*
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;
    }
}
Esempio n. 2
0
int bin_search(RationalNumberCollection *c, RationalNumber n){

 int mitte;
 int links = 0;
 int rechts = c->unique -1;

if(c->unique == 0){
    return -1;
}

for(;;){

    mitte = ((rechts+links)/2); //bereich wird halbiert

    if(rechts < links){
        return -1;
    }

    // n gefunden ?
    if(rnEqual(c->liste[mitte].bruch,n)){
        return mitte;
    }

    if(rnLessThan(n,c->liste[mitte].bruch)){
        rechts = mitte-1;

    } else {

        links = mitte+1;
    }

}
    return -1;
}
Esempio n. 3
0
/*
returns the index of the given rational number in the collection
or returns -1 if it's not in the collection
*/
int rncExists(RationalNumberCollection* c, RationalNumber r){
    for (int i = 0; i < c->length; i = i+2){
        if(rnEqual(r, c->rnList[i])){
            return i;
        }
    }
    return -1;
}
int rncFindPosition(RationalNumberCollection* c, RationalNumber n) {
    for(int i = 0; i < c->size; i++) {
        if(c->collection[i].count != 0) {
            if(rnEqual(c->collection[i].rn, n)) {
                return i;
            }
        }
    }
    return -1;
}
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 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;
}