Complex

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>

enum regard {
    Like, Dislike
};
typedef enum regard regard_t;

typedef struct Frac {
    int num;
    int denom;
    char sign;
} Frac;

typedef struct Complex {
    Frac re;
    Frac im;
} Complex;

Complex complex_create(int re_n, int re_d, int im_n, int im_d);

Complex complex_sum(const Complex *first, const Complex *second);

Complex complex_sub(const Complex *first, const Complex *second);

Complex complex_mult(const Complex *first, const Complex *second);

regard_t complex_div(const Complex *first, const Complex *second, Complex *result);

void complex_print(const Complex *my_complex);

Frac frac_create(int num, int denom);

Frac frac_sum(const Frac *f1, const Frac *f2);

Frac frac_sub(const Frac *f1, const Frac *f2);

Frac frac_mult(const Frac *f1, const Frac *f2);

regard_t frac_div(const Frac *f1, const Frac *f2, Frac *res);

void frac_print(const Frac *f);

int NoD(int left, int right);

void normalize_frac(Frac *my_Frac);

void complex_input(Complex *my_num);

int main() {
    Frac f1, f2;
    int num = 0;
    int denom = 0;
    /*scanf("%d%d", &num, &denom);
    f1 = frac_create(num, denom);

    scanf("%d%d", &num, &denom);
    f2 = frac_create(num, denom);

    Frac sum = frac_sum(&f1, &f2);
    frac_print(&sum);

    Frac sub = frac_sub(&f1, &f2);
    frac_print(&sub);*/

    Complex com_1, com_2;
    complex_input(&com_1);
    complex_input(&com_2);

    Complex sum = complex_sum(&com_1, &com_2);
    complex_print(&sum);

    Complex sub = complex_sub(&com_1, &com_2);
    complex_print(&sub);

    Complex mult = complex_mult(&com_1, &com_2);
    complex_print(&mult);

    Complex div;
    regard_t R = complex_div(&com_1, &com_2, &div);
    R == Like ? complex_print(&div) : printf("There is zero division in div, I can not calculate result :(");

    return 0;
}

Frac frac_create(int num, int denom) {
    char sign = (char) (num > 0 ? 1 : - 1);
    Frac result = {.num = num * sign, .denom = denom, .sign = sign};
    return result;
}

Frac frac_sum(const Frac *f1, const Frac *f2) {
    int denom = f1->denom * f2->denom;
    int num = f1->sign * f1->num * f2->denom + f2->sign * f2->num * f1->denom;
    char sign = (char) (num > 0 ? 1 : - 1);
    num = num * sign;
    Frac result = {.num = num, .denom = denom, .sign = sign};
    normalize_frac(&result);
    return result;
}

Frac frac_sub(const Frac *f1, const Frac *f2) {
    Frac f3 = *f2;
    f3.sign = (char) (f3.sign * (- 1));
    Frac res = frac_sum(f1, &f3);
    normalize_frac(&res);
    return res;
}

Frac frac_mult(const Frac *f1, const Frac *f2) {
    Frac result = {.sign = f1->sign * f2->sign, .num = f1->num * f2->num, .denom = f1->denom * f2->denom};
    normalize_frac(&result);
    return result;
}

regard_t flip_frac(Frac *f) {
    int temp = f->num;
    f->num = f->denom;
    f->denom = temp;
    return temp == 0 ? Dislike : Like;
}

regard_t frac_div(const Frac *f1, const Frac *f2, Frac *res) {
    Frac f22 = *f2;
    regard_t nruter = flip_frac(&f22);
    *res = frac_mult(f1, &f22);
    return nruter;
}

void frac_print(const Frac *f) {
    printf(" Frac :  %d / %d \n", f->num * f->sign, f->denom);
}

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int NoD(int left, int right) {
    if (left < right) {
        swap(&left, &right);
    }
    while (left * right > 0) {
        left = left % right;
        swap(&left, &right);
    }
    return left + right;
}

void normalize_frac(Frac *my_Frac) {
    int nod = NoD(my_Frac->num, my_Frac->denom);
    my_Frac->num = my_Frac->num / nod;
    my_Frac->denom = my_Frac->denom / nod;
}

Complex complex_create(int re_n, int re_d, int im_n, int im_d) {
    Complex result = {.re = frac_create(re_n, re_d), .im = frac_create(im_n, im_d)};
    return result;
}

Complex complex_sum(const Complex *first, const Complex *second) {
    Complex result = {.re = frac_sum(&first->re, &second->re), .im = frac_sum(&first->im, &second->im)};
    return result;
}

Complex complex_sub(const Complex *first, const Complex *second) {
    Complex third = *second;
    third.re.sign = (char) (third.re.sign * (- 1));
    third.im.sign = (char) (third.im.sign * (- 1));
    Complex result = complex_sum(first, &third);
    return result;
}

Complex complex_mult(const Complex *first, const Complex *second) {
    Frac res_of_mults[] = {frac_mult(&first->re, &second->re), frac_mult(&first->re, &second->im),
                           frac_mult(&first->im, &second->re), frac_mult(&first->im, &second->im)};
    Complex result = {.re = frac_sub(&res_of_mults[0], &res_of_mults[3]), .im = frac_sum(&res_of_mults[1],
                                                                                         &res_of_mults[2])};
    return result;
}

regard_t complex_div(const Complex *first, const Complex *second, Complex *result) {
    regard_t nruter;
    Complex conjugated = *second;
    conjugated.im.sign = (char) (conjugated.im.sign * (- 1));
    Frac mults[] = {frac_mult(&conjugated.re, &conjugated.re), frac_mult(&conjugated.im, &conjugated.im)};
    Frac denom = frac_sum(&mults[0], &mults[1]);
    Complex res = complex_mult(first, &conjugated);
    nruter = frac_div(&res.re, &denom, &result->re);
    if (nruter == Dislike) {
        return nruter;
    }
    nruter = frac_div(&res.im, &denom, &result->im);
    return nruter;
}

void complex_print(const Complex *my_complex) {
    printf("%d / %d  +  %d * i / %d\n", my_complex->re.num * my_complex->re.sign, my_complex->re.denom,
           my_complex->im.num * my_complex->im.sign, my_complex->im.denom);
}

regard_t problems(Complex *c) {
    if ((c->re.denom == 0) || (c->im.denom == 0)) {
        return Dislike;
    } else {
        return Like;
    }
}

void complex_input(Complex *my_num) {
    regard_t r = Dislike;
    int input[4] = {0};
    while (r == Dislike) {
        printf("Enter the number : \n");
        scanf("%d%d%d%d", &input[0], &input[1], &input[2], &input[3]);
        *my_num = complex_create(input[0], input[1], input[2], input[3]);
        r = problems(my_num);
        if (r == Dislike) {
            printf("Something wrong :/ Your zero feels bad. Try again...\n");
        }
    }
}