Figury

/*
 * BST.h
 *
 *  Created on: 25.02.2017
 *      Author: danie_000
 */

#ifndef FIGURY_H_
#define FIGURY_H_

struct punkt {
    float x, y;
};

struct kolo {
    float x, y;
    float r;
};

struct kwadrat {
    float x1, y1;
    float x2, y2;
};

enum typFig{PUNKT = 1,KWADRAT = 2, KOLO = 3};

typedef struct Fig *Figura;

//Wymagany standard c11! Anonimowe unie są fajne to dlatego :D
struct Fig {
    int typfig;
    union {
        struct punkt punkt;
        struct kolo kolo;
        struct kwadrat kwadrat;
    };
};

void narysuj(Figura f);
void przesun(Figura f, float x, float y);

int zawiera(Figura f, float x, float y);

Figura newPunkt(float x, float y);
Figura newKolo(float x, float y, float r);
Figura newKwadrat(float x1, float y1, float h);



#endif /* FIGURY_H_ */


---------------------------------------------------------------------------------------------------------------------------


/*
 * Figury.c
 *
 *  Created on: 25.02.2017
 *      Author: danie_000
 */
#include "Figury.h"
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>

void narysuj(Figura f) {
    switch (f->typfig) {
    case 1:
        printf("Rysuję punkt o wspolrzednych x=%0.1f y=%0.1f\n", f->punkt.x,
                f->punkt.y);
        break;
    case 2:
        printf(
                "Rysuję kwadrat o wspolrzednych x1=%0.1f y1=%0.1f x2=%0.1f y2=%0.1f\n",
                f->kwadrat.x1, f->kwadrat.y1, f->kwadrat.x2, f->kwadrat.y2);
        break;
    case 3:
        printf(
                "Rysuję kolo o wspolrzednych x=%0.1f y=%0.1f i promieniu r=%0.1f\n",
                f->kolo.x, f->kolo.y, f->kolo.r);
        break;
    default:
        printf("Nie znam figury o id: %d :(\n", f->typfig);
        break;
    }
}

void przesun(Figura f, float x, float y) {
    switch (f->typfig) {
    case PUNKT:
        f->punkt.x += x;
        f->punkt.x += y;
        break;
    case KWADRAT:
        f->kwadrat.x1 += x;
        f->kwadrat.y1 += y;
        f->kwadrat.x2 += x;
        f->kwadrat.y2 += y;
        break;
    case KOLO:
        f->kolo.x += x;
        f->kolo.y += y;
        break;
    default:
        printf("Nie znam figury o id: %d :(\n", f->typfig);
    }
}

int zawiera(Figura f, float x, float y) {
    switch (f->typfig) {
    case PUNKT:
        if (f->punkt.x == x && f->punkt.y == y)
            return 1;
        break;
    case KWADRAT:
        if (f->kwadrat.x1 <= x && f->kwadrat.x2 >= x && f->kwadrat.y1 <= y
                && f->kwadrat.y2 >= y)
            return 1;
        break;
    case KOLO:
        if ((f->kolo.x - x * f->kolo.x - x) + (f->kolo.y - y * f->kolo.y - y)
                <= (f->kolo.r * f->kolo.r))
            return 1;
        break;
    default:
        printf("Nie znam figury o id: %d :(\n", f->typfig);
        return 0;
    }
    return 0;
}

Figura newPunkt(float x, float y) {
    Figura f = malloc(sizeof(Figura*));
    f->typfig = 1;
    f->punkt.x = x;
    f->punkt.y = y;
    return f;
}

Figura newKolo(float x, float y, float r) {
    Figura f = malloc(sizeof(Figura*));
    f->typfig = 3;
    f->kolo.x = x;
    f->kolo.y = y;
    f->kolo.r = r;
    return f;
}

Figura newKwadrat(float x1, float y1, float h) {

    Figura f = malloc(sizeof(Figura*));
    f->typfig = 2;
    f->kwadrat.x1 = x1;
    f->kwadrat.y1 = y1;
    f->kwadrat.x2 = x1 + h;
    f->kwadrat.y2 = y1 + h;
    return f;
}
---------------------------------------------------------------------------------------------------------------------------

/*
 * Zespolone.h
 *
 *  Created on: 25.02.2017
 *      Author: danie_000
 */

#ifndef ZESPOLONE_H_
#define ZESPOLONE_H_

typedef struct zes *Number;

struct zes {
    double real;
    double imaginary;
};

Number add_new(Number a, Number b);
Number sub_new(Number a, Number b);
Number mult_new(Number a, Number b);
Number div_new(Number a, Number b);

void add(Number a, Number b);
void sub(Number a, Number b);
void mult(Number a, Number b);
void divn(Number a, Number b);
void print(Number n);

Number newNumber(int real, int imaginary);

#endif /* ZESPOLONE_H_ */

---------------------------------------------------------------------------------------------------------------------------


/*
 * Zespolone.c

 *
 *  Created on: 25.02.2017
 *      Author: danie_000
 */
#include <stdlib.h>
#include <stdio.h>
#include "Zespolone.h"

Number add_new(Number a, Number b) {
    return newNumber(a->real + b->real, a->imaginary + b->imaginary);
}

Number sub_new(Number a, Number b) {
    return newNumber(a->real - b->real, a->imaginary - b->imaginary);
}

Number mult_new(Number a, Number b) {
    return newNumber(a->real * b->real - a->imaginary * b->imaginary,
            a->imaginary * b->real + a->real * b->imaginary);
}

Number div_new(Number a, Number b) {
    if (b->real == 0 && b->imaginary == 0) {
        printf("Nie wolno dzielic przez zero!");
        return NULL;
    }
    return newNumber(
            (a->real * b->real + a->imaginary + b->imaginary)
                    / (b->real * b->real + b->imaginary * b->imaginary),
            (a->imaginary * b->real - a->real * b->imaginary)
                    / (b->real * b->real + b->imaginary * b->imaginary));
}

void add(Number a, Number b) {
    b->real += a->real;
    b->imaginary += a->imaginary;
}

void sub(Number a, Number b) {
    b->real = a->real - b->real;
    b->imaginary = a->imaginary - b->imaginary;
}

void mult(Number a, Number b) {
    int br = b->real;
    int bi = b->imaginary;
    b->real = a->real * br - a->imaginary * bi;
    b->imaginary = a->imaginary * br + bi * a->real;
}

void divn(Number a, Number b) {
    if (b->real == 0 && b->imaginary == 0) {
        printf("Nie wolno dzielic przez zero!");
        return;
    }
    int br = b->real;
    int bi = b->imaginary;
    b->real = (a->real * br + a->imaginary + bi) / (br * br + bi * bi);
    b->imaginary = (a->imaginary * br - a->real * bi) / (br * br + bi * bi);
}

void print(Number n) {
    if (n->imaginary == 0)
        printf("%0.1f\n", n->real);
    else if (n->imaginary == 1)
        printf("%0.1f + i\n", n->real);
    else
        printf("%0.1f + %0.1fi\n", n->real, n->imaginary);

}

Number newNumber(int real, int imaginary) {
    Number w = malloc(sizeof(Number*));
    w->imaginary = imaginary;
    w->real = real;
    return w;
}


---------------------------------------------------------------------------------------------------------------------------


/*
 ============================================================================
 Name        : Zespolone.c
 Author      : Daniel Dubiel
 Version     :
 Copyright   : PizzaWare licence
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h>
#include <stdlib.h>
#include "Figury.h"
#include "Zespolone.h"

void zespolone();
void figury();

int main(void) {
    zespolone();
    figury();
    puts(""); /* prints  */
    return EXIT_SUCCESS;
}

void zespolone() {
    Number n1 = newNumber(12, 10);
    Number n2 = newNumber(191, 1);
    print(n1);
    print(n2);
    mult(n1, n2);
    print(n2);
    divn(n2,n1);
    print(n1);
}

void figury() {
    Figura kolo = newKolo(9, 27, 0.5);
    Figura k = newKwadrat(5, 4, 2);
    Figura p = newPunkt(5, 5);
    narysuj(kolo);
    narysuj(k);
    narysuj(p);
    przesun(kolo, 5, 2);
    narysuj(kolo);
    if (zawiera(k, 5, 5))
        puts("Zawiera");

}