ADT Point


Jujur, baru pertama kali ne pake C++….
Tapi lumayan juga 2 setengah hari begadang….90 % mendekati ketuntasan, masih ada yang belum ketemu rumus yang sangat menggemaskannya itu…. hhe… :p
Inilah hasil begadangku…😀
Memang, masih ada yang perlu dirapikan lagi….Oleh karena itu, tunggu revisi selanjutnya ya…🙂

Saatnya penuntasan….^^
Ini dia hasil terbaru dari perjalananku menyelami C++ di ADT Point…😀
Alhamdulillah…akhirnya selesai juga…🙂

ADT Point.h
/* file : point.h */
/* ADT point */

#ifndef point_h
#define point_h
#include “boolean.h”

/* definisi ADT point */
typedef struct
{
int x; /* absis */
int y; /* ordinat */
} point;

/* definisi prototipe primitif */
/*** konstruktor membentuk point ***/
point makepoint(int x,int y);
/* membentuk sebuah point dari komponen-komponennya */

/*** selektor point ***/
int getabsis (point p);
/* mengirimkan komponen absis dari p */

int getordinat(point p);
/* mengirimkan komponen ordinat dari p */

/*** destruktor/dealokator:tidak perlu ***/
/*** set nilai komponen point ***/
void setabsis(point *p,int newx);
/* men-set komponen absis dari p */

void setordinat(point *p,int newy);
/* men-set komponen ordinat dari p */

/* kelompok interaksi dengan I/O device, baca/tulis */
void bacapoint(point *p);
/* bacapoint(p) membentuk p dari x dan y yang dibaca dari keyboard */

void tulispoint(point p);
/* nilai p ditulis ke layar dg format (X,Y) */

/* kelompok operasi aritmatika terhadap byte */
point pluspoint(point p1,point p2);
/* menghasilkan salinan p yang berisi p1+p2 */
/* melakukan operasi penjumlahan vektor */

point minuspoint(point p1,point p2);
/* menghasilkan p1-p2 */

/*** kelompok operasi relasional terhadap point ***/
boolean EQ(point p1,point p2);
/* mengirimkan true jika p1=p2 */

boolean NEQ(point p1,point p2);
/* mengirimkan true jika p1 tidak sama dengan p2 */

boolean LT(point p1,point p2);
/* mengirimkan true jika p1p2 */
/* definisi lebih besar:lebih “kanan-atas” dalam bidang kartesian */

/* kelompok menentukan dimana p berada */
boolean isorigin(point p);
/* menghasilkan true jika p adalah titik origin */

boolean isonsbx(point p);
/* menghasilkan true jika p terletak pada sumbu x */

boolean isonsby(point p);
/* menghasilkan true jika p terletak pada sumbu y */

int kuadran(point p);
/* menghasilkan kuadran dari p: 1,2,3,atau 4 */
/* precondition: p bukan titik origin dan p tdk terletak pd slh satu sumbu */

/* kelompok operasi lain terhadap type */
point nextx(point p);
/* mengirim salinan p dengan absis ditambah satu */

point nexty(point p);
/* mengirim salinan p dengan ordinat ditambah satu */

point plusdelta(point p,int deltax,int deltay);
/* mengirim salinan p yang absisnya = absis(p)+deltax dan */
/* ordinatnya = ordinat(p)+deltay */

point mirrorofpoint(point p,boolean sbx,boolean sby);
/* menghasilkan salinan p yang dicerminkan */
/* tergantung nilai sbx dan sby */
/* jika sbx bernilai true, maka dicerminkan terhadap sb x */
/* jika sby bernilai true, maka dicerminkan terhadap sb y */

float jarak0(point p);
/* menghitung jarak p ke (0,0) */

void geserpoint(point *p,int deltax,int deltay);
/*I.S : p terdefinisi */
/*F.S : p digeser sebesar deltax dan ordinatnya sebesar delta y*/

void geserpointkesbx(point *p);
/* I.S : p terdefinisi */
/* F.S : p di sumbu x dg absis = absis semula */
/* proses : tergeser ke sumbu x */
/* contoh : jika koordinat semula(9,9) menjadi (9,0)*/

void geserpointkesby(point *p);
/* I.S : p terdefinisi */
/* F.S : p di sumbu y dg absis = absis semula */
/* proses : tergeser ke sumbu y */
/* contoh : jika koordinat semula(9,9) menjadi (0,9)*/

void mirrorpoint(point *p,boolean sbx,boolean sby);
/* I.S : p terdefinisi */
/* F.S : p dicerminkan tergantung nilai sbx atau sby */
/* jika sbx true maka dicerminkan thd sumbu x */
/* jika sby true maka dicerminkan thd sumbu y */

//void putarpoint(point *p,float sudut);
/* I.S : p terdefinisi */
/* F.S : p diputar sebesar sudut derajat */

#endif

Boolean.h
#ifndef __boolean__
#define __boolean__
#define true 1
#define false 0
#define boolean unsigned char
#endif

Point.cpp

#include
#include
#include “ADTpoint.h”
#include “boolean.h”
point makepoint(int x,int y)
{
point temp; //buat variabel poin bernama temp
temp.x=x;//mengisikan nilai x
temp.y=y;//mengisikan nilai y
return temp;//mengembalikan nilai temp
}
void tulispoint(point p)//mencetak nilai p di layar dengan format x dan y
{
printf(“x : %d, y : %d”,p.x,p.y);//mencetak nilai x dan y di layar
}
int getabsis (point p)//mendapatkan nilai x dari p
{
return p.x;//mengembalikan nilai p
}
int getordinat (point p)//mendapatkan nilai y dari p
{
return p.y;//mengembalikan nilai p
}
void bacapoint(point *p)//membentuk p dari x dan y yang dibaca dari keyboard
{
point temp;//type dari variable temp adalah point
scanf(“%d”,&(*p).x);//membaca nilai x yang sudah terdefinisi
scanf(“%d”,&(*p).y);//membaca nilai y yang sudah terdefinisi
}

point pluspoint(point p1,point p2)//menjumlahkan kedua point dan menghasilkan nilai yang bertipe point
{
point p;//variable p yang bertipe point
p.x=p1.x+p2.x;//menjumlahkan kedua point komponen x
p.y=p1.y+p2.y;//menjumlahkan kedua point komponen y
return p;//mengembalikan nilai p
}
point minuspoint(point p1,point p2)//mencari selisih kedua point
{
point p;//variable p yang bertipe point
p.x=p1.x-p2.x;//mengurangi kedua point komponen x
p.y=p1.y-p2.y;//mengurangi kedua point komponen y
return p;//mengembalikan nilai p
}

void setabsis(point *p,int newx)//men-set komponen x dari p
{
(*p).x = newx;//mengiisikan nilai baru dari x
}

void setordinat(point *p,int newy)//men-set komponen y dari p
{
(*p).y = newy;//mengiisikan nilai baru dari y
}

boolean EQ(point p1,point p2)//menentukan apakah kedua point memiliki nilai yang sama?
{
if ((p1.x == p2.x) && (p1.y == p2.y))//syarat kesamaaan dari kedua point, kedua komponen pada point harus sama
{printf (“true”);}//menuliskan kata true jika kedua point bernilai sama
else printf (“false”);//menuliskan kata false jika point bernilai berbeda
}
boolean NEQ(point p1,point p2)//menentukan apakah kedua point memiliki nilai yang tidak sama?
{
if ((p1.x != p2.x) || (p1.y != p2.y))//syarat bila kedua point dikatakan berbeda
{printf (“true”);}//menuliskan kata true jika kedua point bernilai berbeda
else printf (“false”);//menuliskan kata false jika kedua point bernilai sama
}
boolean LT(point p1,point p2)//menentukan apakah nilai point 1 lebih kecil daripada point 2?
{
if ((p1.x < p2.x) && (p1.y p2.x) && (p1.y > p2.y))//syarat bila dikatakan point 1 lebih besar dibandingkan point 2
{printf (“true”);}//menuliskan kata true bila nilai point 1 lebih besar dibandingkan nilai point 2
else printf (“false”);//menuliskan kata false bila nilai point 1 tidak lebih besar dibandingkan nilai point 2
}
boolean isorigin(point p)//menentukan apakah point p terletak di koordinat (0,0)?
{
if ((p.x == 0) && (p.y == 0))//syarat yang harus dipenuhi jika point p isorigin
{printf (“true”);}//menuliskan kata true bila point p isorigin
else printf (“false”);//menuliskan kata false bila point p tidak isorigin
}
boolean isonsbx(point p)//menentukan apakah point p terletak di sumbu x
{
if (p.y == 0)//syarat agar point p terletak di sumbu x
{printf (“true”);}//menuliskan kata true bila point p terletak di sumbu x
else printf (“false”);//menuliskan kata false bila point p tidak terletak di sumbu x
}
boolean isonsby(point p)//menentukan apakah point p terletak di sumbu y
{
if (p.x == 0)//syarat agar point p terletak di sumbu y
{printf (“true”);}//menuliskan kata true bila point p terletak di sumbu y
else printf (“false”);//menuliskan kata false bila point p tidak terletak di sumbu y
}

int kuadran(point p)//menentukan point p terletak di kuadran mana
{
if ((p.x > 0) && (p.y > 0))//syarat bila point p terletak di kuadran 1
{printf (“\nTitik (%d , %d) terletak pada kuadran 1\n”,p.x,p.y);}//menuliskan point p terletak dikuadran 1
else
if ((p.x 0))//syarat bila point p terletak di kuadran 2
{printf (“\nTitik (%d , %d) terletak pada kuadran 2\n”,p.x,p.y);}//menuliskan point p terletak dikuadran 2
else
if ((p.x < 0) && (p.y 0) && (p.y < 0))//syarat bila point p terletak di kuadran 4
{printf ("\nTitik (%d , %d) terletak pada kuadran 4\n",p.x,p.y);}//menuliskan point p terletak dikuadran 4
}
point nextx(point p)//menggeser 1 letak koordinat p ke kanan
{
p.x=p.x+1;//mengisi nili komponen x setelah bergeser 1 ke kanan
p.y=p.y;//mengisi nilai komponen y
return p;//mengembalikan nilai p
}

point nexty(point p)//menggeser 1 letak koordinat p ke atas
{

p.x=p.x;//mengisi nilai komponen x
p.y=p.y+1;//mengisi nili komponen y setelah bergeser 1 ke atas
return p;//mengembalikan nilai p
}

point plusdelta(point p,int deltax,int deltay)//menentukan nilai p setelah ditambah dengan nilai yang telah ditentukan
{
p.x=p.x+deltax;//mengisikan nilai komponen x setalah menambahkan nilai x asal dengan nilai yang telah ditentukan
p.y=p.y+deltay;//mengisikan nilai komponen y setalah menambahkan nilai y asal dengan nilai yang telah ditentukan
return p;
}

float jarak0(point p)//menentukan jarak dari koordinat p ke titik (0,0)
{
float j;//variable j yang bertipe float
j=(sqrt(p.x*p.x)+(p.y*p.y));//variable j merupakan jarak dari koordinat p ke titik (0,0)
return j;//mengembalikan nilai j
}

void geserpoint(point *p,int deltax,int deltay)//menggeser koordinat p sebesar nilai yang akan didefinisi
{
(*p).x=(*p).x+deltax;//menggeser koordinat x ke kanan sebesar nilai yang akan didefinisikan
(*p).y=(*p).y+deltay;//menggeser koordinat y ke atas sebesar nilai yang akan didefinisikan
}

void geserpointkesbx(point *p)//menggeser koordinat p ke sb. x
{
(*p).x=(*p).x;//mengisikan nilai komponen x
(*p).y==0;//mengisikan nilai komponen y dengan 0
}

void geserpointkesby(point *p)//menggeser koordinat p ke sb. y
{
(*p).x==0;//mengisikan nilai komponen x dengan 0
(*p).y=(*p).y;//mengisikan nilai komponen y
}

point mirrorofpoint(point p,boolean sbx,boolean sby)//mencerminkan titik koordinat
{
if ((sbx==false) && (sby==true))//syarat jika pada sb y bernilai true
{(p.x=-p.x) && (p.y=p.y);}//maka titik akan dicerminkan terhadap sb y, menghasilkan invers dari titik x
else
if ((sbx==true) && (sby==false))//syarat jika pada sb x bernilai true
{(p.x=p.x) && (p.y=-p.y);}//maka titik akan dicerminkan terhadap sb x, menghasilkan invers dari titik y
else
if ((sbx==true) && (sby==true))//syarat bila kedua sumbu true
{((p.x=-p.x) && (p.y=-p.y));}//maka semua titiknya berubah tanda
if ((sbx==false) && (sby==false))//bila kedua titik bernilai false
{((p.x=p.x) && (p.y=p.y));}//maka titiknya tetap
return p;//mengembalikan nilai p
}

void mirrorpoint(point *p,boolean sbx,boolean sby)//mencerminkan pointer p, yang sudah terdefinisi terhadap sb x atau y
{
if (sby==true)//syarat bila sb y bernilai true
{((*p).x=-(*p).x) && ((*p).y=(*p).y);}//maka titik akan dicerminkan terhadap sb x, menghasilkan invers dari titik y
else
if (sbx==true)//syarat jika pada sb x bernilai true
{((*p).x=(*p).x) && ((*p).y=-(*p).y);}//maka titik akan dicerminkan terhadap sb x, menghasilkan invers dari titik y
else
if ((sbx==true) && (sby==true))//syarat bila kedua sumbu true
{((*p).x=-(*p).x) && ((*p).y=-(*p).y);}//maka semua titiknya berubah tanda
if ((sbx==false) && (sby==false))//bila kedua titik bernilai false
{((*p).x=(*p).x) && ((*p).y=(*p).y);}//maka semua titiknya tetap
}

void putarpoint(point *p, float sudut)
{
(*p).x = (*p).x * cos (sudut) – (*p).y * sin (sudut);
(*p).y = (*p).x * cos (sudut) + (*p).y * sin (sudut);
}

Main.cpp
#include // system(“pause”) menggunakan IOS
#include “ADTpoint.h”
#include “boolean.h”
int main ()
{
point p,q,d,e,a,s;//variabel p,q,d,e bertipe point
p=makepoint(10,10);//mengisikan point p dengan nilai x sebesar 10 dan y sebesar 10
printf(“\nNilai absis pertama\t:%d\nNilai ordinat pertama\t:%d\n”,p);//menuliskan nilai absis dan ordinat ke layar

q=makepoint(7,4);//mengisikan point q dengan nilai x sebesar 7 dan y sebesar 4
printf(“\nNilai absis kedua\t:%d\nNilai ordinat kedua\t:%d\n”,q);//menuliskan nilai absis dan ordinat ke layar

d = pluspoint(p,q);//pemanggilan pluspoint
printf(“\nJumlah point komponen x:\t%d\nJumlah point komponen y:\t%d\n”,d);//menuliskan jumlah point p dan q ke layar

e = minuspoint (p,q);//pemanggilan minuspoint
printf(“\nSelisih point komponen x:\t%d\nSelisih point komponen y:\t%d\n”,e);//menuliskan selisih point p dan q ke layar

printf(“\nApakah point 1 sama dengan point 2 ? “);//menuliskan Apakah point 1 sama dengan point 2 ? ke layar
EQ(p,q);//pemanggilan fungsi EQ

printf(“\nApakah point 1 tidak sama dengan point 2 ? “);//menuliskan Apakah point 1 tidak sama dengan point 2 ? ke layar
NEQ(p,q);//pemanggilan fungsi NEQ

printf(“\nApakah point 1 kurang dari point 2 ? “);//menuliskan Apakah point 1 kurang dari point 2 ? ke layar
LT(p,q);//pemanggilan fungsi LT

printf(“\nApakah point 1 lebih dari point 2 ? “);//menuliskan Apakah point 1 lebih dari point 2 ? ke layar
GT(p,q);//pemanggilan fungsi GT

printf(“\nApakah x dan y merupakan isorigin ? “);//menuliskan Apakah x dan y merupakan isorigin ?ke layar
isorigin(p);//pemanggilan fungsi isorigin

printf(“\nApakah terletak pada sumbu x ? “);//menuliskan Apakah terletak pada sumbu x ? ke layar
isonsbx(p);//pemanggilan fungsi isonsbx

printf(“\nApakah terletak pada sumbu y ? “);//menuliskan Apakah terletak pada sumbu y ? ke layar
isonsby(p);//pemanggilan fungsi isonsby

printf(“\n\nSilahkan masukkan nilai x dan y yang Anda inginkan\n”);//instruksi selanjutnya
bacapoint(&p);//pemanggilan fungsi bacapoint

printf(“\nNilai absis yang Anda masukkan :\t%d\n”,getabsis(p));//menampilkan nilai absis yang sebelumnya sudah diinputkan
printf (“Nilai ordinat yang Anda masukkan :\t%d\n”,getordinat(p));//menampilkan nilai ordinat yang sebelumnya sudah diinputkan
kuadran(p);//pemanggilan fungsi kuadran
printf (“\nBila titik tersebut diputar 45 derajat maka titik yang baru adalah (%d , %d)\n”);//hasil titik setelah diputar
putarpoint(&a,45);//pemanggilan procedure putarpoint
printf (“\nCerminan dari point adalah : (%d, %d)”,mirrorofpoint(p,true,true));//menampilkan cerminan titik koordinat point terhadap sb.x
printf(“\nJarak titik tersebut ke pusat koordinat adalah %.2f\n”,jarak0(p));//menampilkan besarnya jarak dari titik koordinat ke titik pusat
printf(“\nBila titik bergerak satu ke kanan, maka titik koordinat menjadi (%d , %d)”,nextx(p));//menampilkan titik koordinat baru setelah digeser satu ke kanan
printf(“\nBila titik bergerak satu ke atas, maka titik koordinat menjadi (%d , %d)\n”,nexty(p));//menampilkan titik koordinat baru setelah digeser satu ke kiri

geserpointkesbx(&p);//pemanggilan fungsi geserpointkesbx
printf (“\nTitik koordinat yang baru setelah digeser ke sumbu x adalah (%d , 0) “,getabsis(p));//menampilkan titik koordinat baru setelah digeser ke sumbu x

geserpointkesby(&p);//pemanggilan fungsi geserpointkesby
printf (“\nTitik koordinat yang baru setelah digeser ke sumbu y adalah (0 , %d)\n “,getordinat(p));//menampilkan titik koordinat baru setelah digeser ke sumbu y

setabsis(&p,12);//pemanggilan fungsi setabsis
printf (“\nNilai absis yang baru adalah %d”,getabsis(p));//menampilkan nilai absis yang sebelumnya sudah diset
setordinat(&p,14);//pemanggilan fungsi setordinat
printf (“\nNilai ordinat yang baru adalah %d\n”,getordinat(p));//menampilkan nilai ordinat yang sebelumnya diset

a=plusdelta(p,20,7);//pengisian fungsi plusdelta ke variabel a
printf (“\nNilai x setelah ditambah 20 adalah %d dan nilai y setelah ditambah 7 adalah %d\n”,a);//nilai x dan y yang baru setelah plusdelta
tulispoint(a);//menuliskan hasil plusdelta

printf (“\nSetelah komponen x digeser sebesar 4 dan komponen y digeser sebesar 3 maka “);//nilai x dan y setelah mengalami pergeseran
geserpoint(&a,4,3);//pemanggilan prosedur geserpoint
tulispoint(a);//menuliskan hasilnya
printf (“\nBila titik tersebut diputar 90 derajat maka titik yang baru adalah (%d , %d)\n”);//hasil titik setelah diputar
putarpoint(&a,90);//pemanggilan procedure putarpoint
printf (“\nCerminan point tersebut adalah \n”);//mencerminkan titik x dan y sebelumnya
mirrorpoint(&a,false,true);//pemanggilan prosedur mirrorpoint, pencerminan terhadap sb y
tulispoint(a);//menuliskan x dan y
printf(“\nJarak titik tersebut ke pusat koordinat adalah %.2f\n”,jarak0(a));//menampilkan besarnya jarak dari titik koordinat ke titik pusat
system (“pause”);
return 0;
}

Tinggalkan Balasan

Isikan data di bawah atau klik salah satu ikon untuk log in:

Logo WordPress.com

You are commenting using your WordPress.com account. Logout / Ubah )

Gambar Twitter

You are commenting using your Twitter account. Logout / Ubah )

Foto Facebook

You are commenting using your Facebook account. Logout / Ubah )

Foto Google+

You are commenting using your Google+ account. Logout / Ubah )

Connecting to %s

%d blogger menyukai ini: