Übung 1

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "bruch.h"
 
static char __error = 0;
 
struct bruch_s {
    int _z, _n;
};
 
static int ggt(int p, int q) {
    int r;
    do {
        r = p % q;
        p = q;
        q = r;
    } while (r != 0);
    return p;
}
 
static void reduce(bruch_t *q) {
    int t = ggt(q->_z, q->_n);
    q->_z /= t;
    q->_n /= t;
}
 
bruch_t * getRational(int z, int n) {
    if (n == 0) {
        __error = 1;
        return NULL;
    }
 
    bruch_t *r = (bruch_t *) malloc(sizeof(bruch_t));
    if (r == NULL) {
        __error = 3;
    return NULL;
    }
    r->_z = z;
    r->_n = n;
    return r;
}
 
void cleanRational(bruch_t *q) {
    if (q != NULL)
        free(q);
}
 
char getError(void) {
    return __error;
}
 
void addR(bruch_t *r, bruch_t *a, bruch_t *b) {
    __error = 0;
    r->_z = a->_z * b->_n + b->_z * a->_n;
    r->_n = a->_n * b->_n;
    reduce(r);
}
 
void subR(bruch_t *r, bruch_t *a, bruch_t *b) {
    __error = 0;
    r->_z = a->_z * b->_n - b->_z * a->_n;
    r->_n = a->_n * b->_n;
    reduce(r);
}
 
void mulR(bruch_t *r, bruch_t *a, bruch_t *b) {
    __error = 0;
    r->_z = a->_z * b->_z;
    r->_n = a->_n * b->_n;
    reduce(r);
}
 
void divR(bruch_t *r, bruch_t *a, bruch_t *b) {
    if (b->_z == 0) {
        __error = 2;
        return;
    }
    __error = 0;
    r->_z = a->_z * b->_n;
    r->_n = a->_n * b->_z;
    reduce(r);
}
 
void valueOf(bruch_t *r, double x) {
    double z = x;
    int n = 1;
 
    double d = z - (int) z;
 
    // printf("%lf / %d = %lf\n", z, n, d);
    for (int i = 0; i < 20 && d >= 1e-4; i++) {
        z *= 2;
        n *= 2;
        d = z - (int) z;
        // printf("%lf / %d = %lf\n", z, n, d);
    }
    r->_z = z;
    r->_n = n;
    reduce(r);
}
 
double toDouble(bruch_t *q) {
    if (q == NULL) {
        __error = 4;
        return 0.0;
    }
    __error = 0;
    return (double) q->_z / q->_n;
}
 
void output(bruch_t *q) {
    printf("(%d/%d)\n", q->_z, q->_n);
}
 
char * btos(bruch_t *q, char *s, int n) {
    snprintf(s, n, "(%d/%d)", q->_z, q->_n);
    return s;
}
 
void summe(bruch_t **r, bruch_t **values, int n) {
    memcpy(*r, values[0], sizeof(bruch_t));
 
    for (int i = 1; i < n; i++)
        addR(*r, *r, values[i]);
}