/* Body Prototype type point */

#include "point.h"

const float pi = 3.14;

/* Body Prototype */

POINT MakePoint(float x, float y) {
/*  membentuk sebuah point dari komponen-komponennya */
/*  Kamus Lokal  */
    POINT p;
/*  Algoritma */
        GetAbsis(p) = x;
        GetOrdinat(p) = y;
        return (p);
    }

//interaksi dengan I/O device baca/tulis
void BacaPoint(POINT *p) {
/*  Makepoint(x,y,P) membentuk P dari x dan y yang dibaca */
/*  Kamus Lokal  */
    float x,y;
/*  Algoritma */
        scanf("%f", &x);
        scanf("%f", &y);
        *p = MakePoint(x,y);
    }

void TulisPoint(POINT p) {
/*  nilai p ditulis ke layar dengan format "(X,Y)"
    harap menggunakan presisi 2 angka dibelakang koma

    Silahkan gunakan line berikut ini
    printf("(%.2f, %.2f)\n",GetAbsis(p),GetOrdinat(p));
*/
/*  Kamus Lokal  */
/*  Algoritma */
        printf("(%.2f, %.2f)\n", GetAbsis(p),GetOrdinat(p));
    }

//kelompok operasi aritmatika terhadap type
POINT Tambah(POINT p1, POINT p2) {
/*  menghasilkan point yang bernilai p1 + p2
    melakukan operasi penjumlahan vektor
*/
/*  Kamus Lokal  */
    POINT hasil;
/*  Algoritma */
        GetAbsis(hasil) = (GetAbsis(p1) + GetAbsis(p2));
        GetOrdinat(hasil) = (GetOrdinat(p1) + GetOrdinat(p2));

        return(hasil);
    }

POINT Kurang(POINT p1, POINT p2) {
/*  menghasilkan point bernilai p1-p2
    buatlah spesifikasi pengurangan dua buah point
*/
/*  Kamus Lokal  */
    POINT hasil;
/*  Algoritma */
        GetAbsis(hasil) = (GetAbsis(p1) - GetAbsis(p2));
        GetOrdinat(hasil) = (GetOrdinat(p1) - GetOrdinat(p2));

        return(hasil);
    }


float DotProduct(POINT p1, POINT p2) {
/*  operasi perkalian p1.p2 melakukan operasi dot */
/*  Kamus Lokal  */
    float hasil;
/*  Algoritma */
        hasil= (GetAbsis(p1)*GetOrdinat(p2)) + (GetAbsis(p2)*GetOrdinat(p2));

        return(hasil);
    }


//kelompok operasi relasional terhadap point
boolean EQ(POINT p1, POINT p2) {
/*  mengirimkan true jika p1=p2 absis dan ordinatnya sama */
/*  Kamus Lokal  */
    boolean same;
/*  Algoritma */
        if (GetAbsis(p1) && GetAbsis(p2) && GetOrdinat(p1) && GetOrdinat(p2)) {
            same = true;
        } else
            same = false;

        return(same);
    }

boolean NEQ(POINT p1, POINT p2) {
/*  mengirimkan true jika p1 tidak sama dengan p2 */
/*  Kamus Lokal  */
    boolean same;
/*  Algoritma */
        if ((GetAbsis(p1) != GetAbsis(p2)) && (GetOrdinat(p1) != GetOrdinat(p2)) {
            same = true;
        } else
            same = false;

        return(same);
    }

boolean KurangDari(POINT p1, POINT p2) {
/*  mengirimkan true jika p1<p2. definisi lebih kecil : lebih kiri bawah
    dalam bidang kartesian
*/
/*  Kamus Lokal  */
    boolean kurang;
/*  Algoritma */
        if ((GetAbsis(p1) < GetAbsis(p2)) && (GetOrdinat(p1) < GetOrdinat(p2))) {
            kurang = true;
        } else
            kurang = false;

        return(kurang);
    }


boolean LebihDari(POINT p1, POINT p2) {
/*  mengirimkan true jika p1>p2. definisi lebih besar : lebih kanan atas
    di bidang kartesian
*/
/*  Kamus Lokal  */
    boolean lebih;
/*  Algoritma */
        if ((GetAbsis(p1) < GetAbsis(p2)) && (GetOrdinat(p1) < GetOrdinat(p2))) {
            lebih = true;
        } else
            lebih = false;

        return(lebih);
    }

//kelompok menentukan dimana p berada
boolean IsOrigin(POINT p) {
/*  menghasilkan true jika p adalah titik origin */
/*  Kamus Lokal  */
    boolean orig;
/*  Algoritma */
        if ((GetAbsis(p)=0) && (GetOrdinat(p)=0)) {
            orig = true;
        } else
            orig = false;

        return(orig);
    }

boolean IsOnSbX(POINT p) {
/*  menghasilkan true jika p terletak pada sumbu x */
/*  Kamus Lokal  */
    boolean sumbx;
/*  Algoritma */
        if (GetAbsis(p)=0) {
            sumbx = true;
        } else
            sumbx = false;

        return(sumbx);
    }

boolean IsOnSbY(POINT p) {
/*  menghasilkan true jika p terletak pada sumbu y */
/*  Kamus Lokal  */
    boolean sumby;
/*  Algoritma */
        if (GetAbsis(p)=0) {
            sumby = true;
        } else
            sumby = false;

        return(sumby);
    }

int Kuadran(POINT p) {
/*  menghasilkan kuadran dari p : 1, 2, 3 dan 4
    precond : p bukan titik origin
    dan  tidak terletak di salah satu sumbu
*/
/*  Kamus Lokal  */
    int kuad;
/*  Algoritma */
        if ( IsOrigin(p) != true) {
            if (GetAbsis(p) > 0) && (GetOrdinat(p) > 0) {
                kuad = 1;
            } else
            {if (GetAbsis(p) < 0) && (GetOrdinat(p) > 0) {
                    kuad = 2;
                } else
                {
                    if (GetAbsis(p) < 0) && (GetOrdinat(p) < 0) {
                        kuad = 3;
                    } else
                        kuad = 4;
                }
            }

        }
        return(kuad);
    }

//kelompok operasi lain terharap tipe
POINT NextX(POINT p) {
/*  mengirim salinan P dengan absis ditambah satu */
/*  Kamus Lokal  */
    POINT salinan;
/*  Algoritma */
        GetAbsis(salinan) = GetAbsis(p) + 1;
        GetOrdinat(salinan) = GetOrdinat(p);
        return(salinan);
    }

POINT NextY(POINT p) {
/*  mengirim salinan P dengan ordinat ditambah satu */
/*  Kamus Lokal  */
    POINT salinan;
/*  Algoritma */
        GetAbsis(salinan) = GetAbsis(p);
        GetOrdinat(salinan) = GetOrdinat(p)+ 1;
        return(salinan);
    }

POINT PlusDelta(POINT p, float deltaX, float deltaY) {
/*  mengirim salinan p yang absisnya = absis(p) + deltaX
    dan ordinatnya adalah ordinat(p) +deltaY
*/
/*  Kamus Lokal  */
    float x,y;
    POINT salinan;
/*  Algoritma */
        x = GetAbsis(p) + deltaX;
        y = GetOrdinat(p) + deltaY
        SetAbsis(salinan, x);
        SetOrdinat(salinan, y);

        return(salinan);
    }

POINT MirrorOf(POINT p, boolean SbX, boolean SbY) {
/*  menghasilkan salinan P yang dicerminkan
    tergantung nilai SbX dan SbY
    jika SbX bernilai true maka dicermintan thd sumbu x
    jika SbY bernilai true maka dicerminkan terhadap sumbu Y
*/
/*  Kamus Lokal  */
/*  Algoritma */

float Jarak0(POINT p) {
/*  menghitung jarak p ke (0,0) */
/*  Kamus Lokal  */
    float hasil;
    double exponent=2;
/*  Algoritma */
        hasil = sqrt(pow(GetAbsis(p), exponent) + pow(GetOrdinat(p), exponent));

        return(hasil);
    }

float Panjang(POINT p1, POINT p2) {
/*  menghitung panjang garis yang dibentuk p1 dan p2 */
/*  Kamus Lokal  */
    float hasil;
    float x1, x2, y1, y2;
    double exponent=2;

/*  Algoritma */

        x1 = GetAbsis(p1);
        x2 = GetAbsis(p2);
        y1 = GetOrdinat(p1);
        y2 = GetOrdinat(p2);
        hasil = sqrt(pow((x1-x2), exponent) + pow((y1-y2), exponent));

        return(hasil);
    }

void Geser(POINT *p, float deltaX, float deltaY) {
/*  IS : p terdefinisi
    FS : p digeser absisnya sebesar deltaX dan ordinatnya sebesar deltaY
*/
/*  Kamus Lokal  */
    float x,y;
/*  Algoritma */

        x = GetAbsis(p) + deltaX;
        y = GetOrdinat(p) + deltaY
        *p = MakePoint(x, y);
    }

void GeserKeSbX(POINT *p) {
/*  IS : p terdefinisi
    FS : p di sumbu x dengan absis sama dengan absis sama
    dengan sbsis absis semula
    proses : tergeser ke sumbu x
    contoh : jika koordinat semula (9,9) menjadi (9,0)
*/
/*  Kamus Lokal  */
/*  Algoritma */

        *p = MakePoint(GetAbsis(p), 0);
    }

void GeserKeSbY(POINT *p) {
/*  IS : p terdefinisi
    FS : p di sumbu x dengan absis sama dengan absis sama
    dengan sbsis absis semula
    proses : tergeser ke sumbu Y
    contoh : jika koordinat semula (9,9) menjadi (0,9)
*/
/*  Kamus Lokal  */
/*  Algoritma */

        *p = MakePoint(0, GetOrdinat(p));
    }

void Mirror(POINT *p, boolean SbX, boolean SbY) {
/*  IS : p terdefinisi
    FS : p dicerminkan tergantung nilai SbX atauSbY
    jika SbX true maka dicerminkan terhadap sumbu X
    jika SbY true maka dicerminkan terhadap sumbu Y
*/
/*  Kamus Lokal  */
    float x,y;
/*  Algoritma */

        x = GetAbsis(p);
        y = GetOrdinat(p);
        if (SbX = true) {
            *p = MakePoint(x, -y);
        } else
        {
            *p = MakePoint(-x, y);
        }
    }

void Putar(POINT *p, float sudut) {
/*  IS : p terdefinisi
    FS : p diputar sebesar (sudut) derajat berlawanan jarum jam
*/
/*  Kamus Lokal  */
    float x, y, rad;
/*  Algoritma */
    rad = sudut/180 * pi;
    x = GetAbsis(p);
    y = GetOrdinasAbt(p);
    x = x*cos(rad) - y*sin(rad);
    y = x*sin(rad) + y*cos(rad);
    *p = MakePoint(x,y);
}