Operator, Ekspresi, dan Konversi Tipe

Setelah menyelesaikan modul ini, mahasiswa diharapkan mampu:

1. Menggunakan operator aritmatika dan membedakan perilaku / dan div.
2. Menjelaskan fungsi mod dan menerapkannya untuk pemeriksaan keterbagian.
3. Menggunakan operator relasional untuk membandingkan nilai.
4. Menggabungkan kondisi dengan operator logika and, or, dan not.
5. Menjelaskan konsep short-circuit evaluation pada operator logika.
6. Menggunakan operator bitwise untuk manipulasi bit.
7. Menerapkan prioritas operator dengan benar dalam ekspresi majemuk.
8. Melakukan konversi tipe implisit dan eksplisit menggunakan fungsi standar.
9. Menghindari kesalahan umum terkait pembagian bilangan bulat dan perbandingan nilai real.
10. Menggunakan fungsi matematika standar seperti abs, sqr, sqrt, round, dan trunc.

Capaian Pembelajaran Mata Kuliah

Mahasiswa mampu menyusun ekspresi aritmatika, relasional, dan logika dengan benar, serta melakukan konversi antar tipe data sesuai kebutuhan perhitungan, sehingga program menghasilkan nilai yang akurat.

Indikator Ketercapaian Modul

3.1 Pengertian Operator dan Ekspresi

Operator adalah simbol yang melakukan operasi terhadap satu atau lebih nilai. Operand adalah nilai yang dioperasikan. Gabungan operator dan operand disebut ekspresi.

Contoh ekspresi sederhana:

luas := panjang * lebar;
rata := (nilaiA + nilaiB + nilaiC) / 3;
lulus := (nilai >= 70) and (kehadiran >= 75);

Pada baris pertama, * adalah operator, panjang dan lebar adalah operand, dan panjang * lebar adalah ekspresi.

Operator dalam Pascal dikelompokkan menjadi beberapa kategori berdasarkan jenis operasinya.

3.2 Operator Aritmatika

Operator aritmatika bekerja pada nilai numerik (integer atau real) dan menghasilkan nilai numerik.

writeln(7 / 2);      { 3.50000000000000E+000 }
writeln(7 div 2);    { 3 }
writeln(7 mod 2);    { 1 }
writeln(-7 div 2);   { -3, bukan -4 }
writeln(-7 mod 2);   { -1, bukan 1 }

Fungsi Matematika Standar

Selain operator, Pascal menyediakan fungsi matematika bawaan yang sering dipakai.

3.3 Operator Relasional (Perbandingan)

Operator relasional membandingkan dua nilai dan menghasilkan boolean (true atau false).

Perbandingan Nilai Real

Nilai real disimpan sebagai pendekatan, sehingga perbandingan langsung dengan = sering menyesatkan. Perhatikan contoh klasik berikut.

var
  a, b: double;

begin
  a := 0.1 + 0.2;
  b := 0.3;

  if a = b then
    writeln('Sama')
  else
    writeln('Tidak sama');      { Ini yang akan tercetak }

  writeln('a = ', a:0:20);
  writeln('b = ', b:0:20);
end.

Alih-alih membandingkan langsung, bandingkan selisihnya dengan toleransi kecil (epsilon).

const
  EPSILON = 1E-9;

var
  a, b: double;

begin
  a := 0.1 + 0.2;
  b := 0.3;

  if Abs(a - b) < EPSILON then
    writeln('Sama (dalam toleransi)')
  else
    writeln('Tidak sama');
end.

3.4 Operator Logika

Operator logika bekerja pada nilai boolean dan menghasilkan boolean.

Operator xor juga tersedia untuk logika eksklusif. Operator xor menghasilkan true hanya ketika tepat satu operand bernilai true.

Short-Circuit Evaluation

Free Pascal dan Delphi modern mendukung short-circuit evaluation secara default. Artinya, pada ekspresi A and B, bila A sudah false, maka B tidak dievaluasi sama sekali. Demikian pula pada A or B, bila A sudah true, maka B dilewati.

Perilaku ini dapat dikendalikan dengan direktif kompilator:

if (p <> nil) and (p^.nilai > 0) then
  writeln('Nilai positif');

3.5 Operator Bitwise

Operator bitwise memanipulasi nilai pada tingkat bit individual. Operator ini hanya bekerja pada tipe integer.

Aplikasi Bitwise: Mengecek Bilangan Ganjil

Karena bilangan ganjil selalu memiliki bit terakhir 1, kita dapat memeriksa bit terakhir dengan operator and.

var
  n: integer;

begin
  write('Masukkan bilangan bulat: ');
  readln(n);

  if (n and 1) = 1 then
    writeln(n, ' adalah bilangan ganjil')
  else
    writeln(n, ' adalah bilangan genap');
end.

3.6 Prioritas Operator

Ketika sebuah ekspresi memuat beberapa operator, urutan evaluasinya ditentukan oleh prioritas. Operator dengan prioritas lebih tinggi dievaluasi lebih dahulu.

Berikut contoh yang sering mengejutkan pemula.

writeln(2 + 3 * 4);         { 14, bukan 20 }
writeln((2 + 3) * 4);       { 20 }
writeln(10 - 3 - 2);        { 5, dievaluasi kiri ke kanan }
writeln(2 + 3 = 5);         { TRUE, karena + lebih tinggi dari = }
writeln(not true or false); { TRUE, karena not lebih tinggi dari or }

3.7 Konversi Tipe Implisit

Pascal melakukan konversi tipe otomatis pada beberapa situasi. Konversi implisit umumnya bergerak dari tipe yang lebih sempit ke tipe yang lebih luas, atau dari integer ke real.

3.8 Konversi Tipe Eksplisit

Ketika konversi implisit tidak tersedia atau Anda ingin mengontrol secara eksplisit, gunakan fungsi konversi berikut.

Contoh Konversi String ke Angka

Prosedur Val memerlukan tiga argumen: string sumber, variabel hasil, dan variabel kode kesalahan. Bila konversi berhasil, kode kesalahan bernilai 0. Bila gagal, kode kesalahan menunjukkan posisi karakter yang bermasalah.

var
  s: string;
  n: integer;
  kode: integer;

begin
  s := '123';
  Val(s, n, kode);

  if kode = 0 then
    writeln('Konversi berhasil: ', n)
  else
    writeln('Konversi gagal pada karakter ke-', kode);
end.

3.9 Pembagian Bulat: Sumber Kesalahan Klasik

Karena operator / selalu menghasilkan real, sedangkan div selalu integer, perhatikan dengan cermat konteks pembagian.

var
  a, b: integer;
  hasil1: real;
  hasil2: integer;

begin
  a := 7;
  b := 2;

  hasil1 := a / b;          { hasil1 = 3.5, benar }
  hasil2 := a div b;        { hasil2 = 3, memotong desimal }

  { Kesalahan umum: hasil2 := a / b; }
  { Ini akan menghasilkan kesalahan kompilasi karena
    tidak dapat menugaskan real ke integer. }
end.

3.10 Kesalahan Umum Terkait Operator dan Ekspresi

1. Menukar = dan :=. = adalah pembanding, := adalah penugasan.
2. Pembagian integer tak sengaja. Memakai div padahal ingin /, atau sebaliknya.
3. Membandingkan real dengan =. Gunakan toleransi epsilon.
4. Mengabaikan prioritas operator. Selalu gunakan tanda kurung untuk memperjelas.
5. Salah mengartikan mod. mod mengikuti perilaku pembagian bulat Pascal (pembulatan ke arah nol), bukan matematis (pembulatan ke bawah).
6. Menggunakan and/or pada integer. Operator ini juga bitwise; pastikan operand bertipe boolean bila maksudnya logika.
7. Bergantung pada short-circuit pada kode lama. Kode yang dikompilasi dengan {$B+} akan mengevaluasi kedua sisi. Jangan andalkan short-circuit untuk validasi pointer pada kode portabel.
8. Lupa bahwa / menghasilkan real. Menyimpan hasil / ke variabel integer menyebabkan kesalahan kompilasi.

3.11 Perbedaan Free Pascal dan Turbo Pascal

4.1 Flowchart Prioritas Operator Aritmatika

Diagram berikut menggambarkan bagaimana ekspresi 2 + 3 * 4 - 10 div 3 dievaluasi selangkah demi selangkah.

flowchart TD
    A(["Ekspresi awal:
2 + 3 * 4 - 10 div 3"]) --> B["Identifikasi operator
prioritas tertinggi:
3 * 4 dan 10 div 3"]
    B --> C["Evaluasi 3 * 4 = 12"]
    C --> D["Evaluasi 10 div 3 = 3"]
    D --> E["Ekspresi menjadi:
2 + 12 - 3"]
    E --> F["Evaluasi kiri ke kanan:
2 + 12 = 14"]
    F --> G["Evaluasi 14 - 3 = 11"]
    G --> H(["Hasil akhir = 11"])
      

4.2 Flowchart Konversi Tipe Otomatis

Diagram berikut menggambarkan alur yang dijalankan kompiler ketika menemui operasi antar tipe yang berbeda.

flowchart TD
    A(["Operasi biner
a OP b"]) --> B{"Tipe a = tipe b?"}
    B -- "Ya" --> C["Langsung eksekusi"]
    B -- "Tidak" --> D{"Ada tipe
yang dapat
dilebarkan?"}
    D -- "Ya" --> E["Konversi implisit
ke tipe yang lebih luas"]
    D -- "Tidak" --> F{"Konversi eksplisit
diberikan?"}
    F -- "Ya" --> G["Terapkan konversi
eksplisit"]
    F -- "Tidak" --> H["Error:
incompatible types"]
    E --> C
    G --> C
    C --> I(["Selesai"])
    H --> J(["Selesai dengan kesalahan"])
      

4.3 Flowchart Pengecekan Bilangan Prima

Contoh penerapan operator mod untuk memeriksa keterbagian. Algoritma sederhana ini memeriksa apakah sebuah bilangan dapat dibagi oleh bilangan lain selain 1 dan dirinya sendiri.

flowchart TD
    A(["Mulai"]) --> B[/"Baca n"/]
    B --> C{"n < 2?"}
    C -- "Ya" --> D["Bukan prima"]
    C -- "Tidak" --> E["i = 2, prima = true"]
    E --> F{"i < n dan
prima = true?"}
    F -- "Tidak" --> J{"prima?"}
    F -- "Ya" --> G{"n mod i = 0?"}
    G -- "Ya" --> H["prima = false"]
    G -- "Tidak" --> I["i = i + 1"]
    H --> I
    I --> F
    J -- "Ya" --> K[/"Tampilkan PRIMA"/]
    J -- "Tidak" --> L[/"Tampilkan BUKAN PRIMA"/]
    D --> M(["Selesai"])
    K --> M
    L --> M
      

5.1 Pseudocode Kalkulator Sederhana

PROGRAM KalkulatorSederhana
{ Melakukan empat operasi dasar pada dua bilangan }

DEKLARASI
  a, b       : real
  operasi    : char

ALGORITMA
  write("Masukkan bilangan pertama: ")
  read(a)
  write("Masukkan bilangan kedua: ")
  read(b)
  write("Operasi (+ - * /): ")
  read(operasi)

  jika operasi = '+' maka
    write("Hasil: ", a + b)
  selain jika operasi = '-' maka
    write("Hasil: ", a - b)
  selain jika operasi = '*' maka
    write("Hasil: ", a * b)
  selain jika operasi = '/' maka
    jika b = 0 maka
      write("Kesalahan: pembagian dengan nol")
    selain itu
      write("Hasil: ", a / b)
    akhir jika
  selain itu
    write("Operasi tidak dikenali")
  akhir jika
END

5.2 Pseudocode Konversi Suhu

PROGRAM KonversiSuhu
{ Mengkonversi Celsius ke Fahrenheit dan Kelvin }

DEKLARASI
  celsius    : real
  fahrenheit : real
  kelvin     : real

ALGORITMA
  write("Masukkan suhu Celsius: ")
  read(celsius)

  fahrenheit <- celsius * 9 / 5 + 32
  kelvin     <- celsius + 273.15

  write("Fahrenheit : ", fahrenheit)
  write("Kelvin     : ", kelvin)
END

5.3 Pseudocode Pemeriksaan Bilangan Prima

PROGRAM CekBilanganPrima
{ Menentukan apakah sebuah bilangan bulat positif adalah prima }

DEKLARASI
  n     : integer
  i     : integer
  prima : boolean

ALGORITMA
  write("Masukkan bilangan bulat: ")
  read(n)

  jika n < 2 maka
    prima <- false
  selain itu
    prima <- true
    i <- 2
    selama i < n dan prima = true lakukan
      jika n mod i = 0 maka
        prima <- false
      akhir jika
      i <- i + 1
    akhir selama
  akhir jika

  jika prima = true maka
    write(n, " adalah bilangan prima")
  selain itu
    write(n, " bukan bilangan prima")
  akhir jika
END

6.1 Program Demonstrasi Semua Operator Aritmatika

program DemoAritmatika;
{ Mendemonstrasikan seluruh operator aritmatika Pascal }

var
  a, b: integer;
  hasilReal: real;

begin
  a := 17;
  b := 5;

  writeln('a = ', a, ', b = ', b);
  writeln('----------------------------------------');

  writeln('a + b   = ', a + b);
  writeln('a - b   = ', a - b);
  writeln('a * b   = ', a * b);

  hasilReal := a / b;
  writeln('a / b   = ', hasilReal:0:6, ' (real)');

  writeln('a div b = ', a div b, ' (integer)');
  writeln('a mod b = ', a mod b, ' (integer)');

  writeln('----------------------------------------');
  writeln('Fungsi matematika pada a = ', a);
  writeln('Abs(-a)  = ', Abs(-a));
  writeln('Sqr(a)   = ', Sqr(a));
  writeln('Sqrt(a)  = ', Sqrt(a):0:6);
  writeln('Round(a / b) = ', Round(a / b));
  writeln('Trunc(a / b) = ', Trunc(a / b));
end.

Keluaran:

a = 17, b = 5
----------------------------------------
a + b   = 22
a - b   = 12
a * b   = 85
a / b   = 3.400000 (real)
a div b = 3 (integer)
a mod b = 2 (integer)
----------------------------------------
Fungsi matematika pada a = 17
Abs(-a)  = 17
Sqr(a)   = 289
Sqrt(a)  = 4.123106
Round(a / b) = 3
Trunc(a / b) = 3

6.2 Program Demonstrasi Operator Logika dan Short-Circuit

program DemoLogika;
{ Mendemonstrasikan operator logika dan tabel kebenaran }

var
  a, b: boolean;

begin
  writeln('Tabel Kebenaran Operator Logika');
  writeln('----------------------------------------');
  writeln('A     B     A and B  A or B   A xor B  not A');
  writeln('----------------------------------------');

  a := true;  b := true;
  writeln(a:5, b:6, (a and b):9, (a or b):9, (a xor b):10, (not a):8);

  a := true;  b := false;
  writeln(a:5, b:6, (a and b):9, (a or b):9, (a xor b):10, (not a):8);

  a := false; b := true;
  writeln(a:5, b:6, (a and b):9, (a or b):9, (a xor b):10, (not a):8);

  a := false; b := false;
  writeln(a:5, b:6, (a and b):9, (a or b):9, (a xor b):10, (not a):8);

  writeln('----------------------------------------');

  { Demonstrasi short-circuit }
  writeln('Short-circuit: (false) and (1/0 = 0)');
  if false and (1 / 0 = 0) then
    writeln('Tidak akan tercetak')
  else
    writeln('Bagian kanan tidak dievaluasi');
end.

Keluaran:

Tabel Kebenaran Operator Logika
----------------------------------------
A     B     A and B  A or B   A xor B  not A
----------------------------------------
 TRUE  TRUE     TRUE    TRUE     FALSE   FALSE
 TRUE FALSE    FALSE    TRUE      TRUE   FALSE
FALSE  TRUE    FALSE    TRUE      TRUE    TRUE
FALSE FALSE    FALSE   FALSE     FALSE    TRUE
----------------------------------------
Short-circuit: (false) and (1/0 = 0)
Bagian kanan tidak dievaluasi

6.3 Program Konversi Tipe dan String

program DemoKonversi;
{ Mendemonstrasikan konversi tipe di Pascal }

var
  n: integer;
  r: real;
  s: string;
  c: char;
  kode: integer;

begin
  writeln('=== Konversi Real ke Integer ===');
  r := 3.75;
  writeln('Nilai real      : ', r:0:4);
  writeln('Round(r)        : ', Round(r));
  writeln('Trunc(r)        : ', Trunc(r));
  writeln('Int(r)          : ', Int(r):0:4);
  writeln('Frac(r)         : ', Frac(r):0:4);

  writeln;
  writeln('=== Konversi Integer ke Real ===');
  n := 42;
  r := n;                        { implisit }
  writeln('n (integer)     : ', n);
  writeln('r (real)        : ', r:0:2);

  writeln;
  writeln('=== Konversi Char dan Ordinal ===');
  c := 'Z';
  writeln('Karakter        : ', c);
  writeln('Ord(c)          : ', Ord(c));
  writeln('Chr(65)         : ', Chr(65));
  writeln('Succ(c)         : ', Succ(c));
  writeln('Pred(c)         : ', Pred(c));

  writeln;
  writeln('=== Konversi String dan Angka ===');
  n := 12345;
  Str(n, s);
  writeln('Str(12345, s)   : s = "', s, '"');

  s := '67890';
  Val(s, n, kode);
  writeln('Val("67890", n) : n = ', n, ', kode = ', kode);

  s := '12abc';
  Val(s, n, kode);
  writeln('Val("12abc", n) : n = ', n, ', kode = ', kode);
end.

Keluaran:

=== Konversi Real ke Integer ===
Nilai real      : 3.7500
Round(r)        : 4
Trunc(r)        : 3
Int(r)          : 3.0000
Frac(r)         : 0.7500

=== Konversi Integer ke Real ===
n (integer)     : 42
r (real)        : 42.00

=== Konversi Char dan Ordinal ===
Karakter        : Z
Ord(c)          : 90
Chr(65)         : A
Succ(c)         : [
Pred(c)         : Y

=== Konversi String dan Angka ===
Str(12345, s)   : s = "12345"
Val("67890", n) : n = 67890, kode = 0
Val("12abc", n) : n = 12, kode = 3

6.4 Program Pemeriksaan Bilangan Prima

program CekPrima;
{ Menentukan apakah sebuah bilangan bulat positif adalah prima }

var
  n: integer;
  i: integer;
  prima: boolean;
  jumlahFaktor: integer;

begin
  write('Masukkan bilangan bulat positif: ');
  readln(n);

  if n < 2 then
  begin
    prima := false;
    jumlahFaktor := 0;
  end
  else
  begin
    prima := true;
    jumlahFaktor := 2;          { 1 dan n }
    i := 2;
    while (i <= n div 2) and prima do
    begin
      if n mod i = 0 then
      begin
        prima := false;
        jumlahFaktor := jumlahFaktor + 1;
      end;
      i := i + 1;
    end;
  end;

  writeln;
  writeln('Bilangan yang diperiksa: ', n);

  if prima then
    writeln('Status: PRIMA')
  else
    writeln('Status: BUKAN PRIMA');

  writeln('Jumlah faktor yang ditemukan: ', jumlahFaktor);
end.

Contoh sesi interaksi:

Masukkan bilangan bulat positif: 97

Bilangan yang diperiksa: 97
Status: PRIMA
Jumlah faktor yang ditemukan: 2

7.1 Program DemoAritmatika

7.2 Program CekPrima

7.3 Jejak Eksekusi CekPrima untuk n = 15

Karena 15 mod 3 = 0, maka 15 bukan bilangan prima. Perulangan berhenti lebih awal karena kondisi prima sudah bernilai false.

9.1 Deskripsi Masalah

PT "Maju Bersama" memerlukan program untuk menghitung gaji bersih karyawan bulanan. Setiap karyawan memiliki: nama, jumlah jam kerja reguler, jumlah jam lembur, dan gaji pokok. Program menghitung upah lembur, gaji kotor, potongan pajak, dan gaji bersih.

9.2 Aturan Perhitungan

9.3 Flowchart Studi Kasus

flowchart TD
    A(["Mulai"]) --> B[/"Baca nama, jamLembur, gajiPokok"/]
    B --> C["upahPerJam = gajiPokok / 173"]
    C --> D["upahLembur = jamLembur * upahPerJam * 1.5"]
    D --> E["gajiKotor = gajiPokok + upahLembur"]
    E --> F["pajak = gajiKotor * 0.05"]
    F --> G["gajiBersih = gajiKotor - pajak"]
    G --> H[/"Tampilkan slip gaji"/]
    H --> I(["Selesai"])
      

9.4 Pseudocode Studi Kasus

PROGRAM PerhitunganGaji
{ Menghitung gaji bersih karyawan bulanan }

KONSTANTA
  JAM_KERJA_BULANAN = 173
  TARIF_LEMBUR      = 1.5
  TARIF_PAJAK       = 0.05
  GARIS_GANDA       = "=========================================="
  GARIS_TUNGGAL     = "------------------------------------------"

DEKLARASI
  nama         : string
  jamLembur    : integer
  gajiPokok    : currency
  upahPerJam   : currency
  upahLembur   : currency
  gajiKotor    : currency
  pajak        : currency
  gajiBersih   : currency

ALGORITMA
  write("Nama karyawan     : ")
  read(nama)
  write("Jam lembur (jam)  : ")
  read(jamLembur)
  write("Gaji pokok (Rp)   : ")
  read(gajiPokok)

  upahPerJam <- gajiPokok / JAM_KERJA_BULANAN
  upahLembur <- jamLembur * upahPerJam * TARIF_LEMBUR
  gajiKotor  <- gajiPokok + upahLembur
  pajak      <- gajiKotor * TARIF_PAJAK
  gajiBersih <- gajiKotor - pajak

  write(GARIS_GANDA)
  write("SLIP GAJI KARYAWAN")
  write("PT Maju Bersama")
  write(GARIS_GANDA)
  write("Nama          : ", nama)
  write("Jam lembur    : ", jamLembur, " jam")
  write("Gaji pokok    : Rp ", gajiPokok)
  write(GARIS_TUNGGAL)
  write("Upah per jam  : Rp ", upahPerJam)
  write("Upah lembur   : Rp ", upahLembur)
  write("Gaji kotor    : Rp ", gajiKotor)
  write("Pajak 5 persen: Rp ", pajak)
  write(GARIS_TUNGGAL)
  write("Gaji bersih   : Rp ", gajiBersih)
  write(GARIS_GANDA)
END

9.5 Implementasi dalam Pascal

program PerhitunganGaji;
{ Studi Kasus Modul 4 - Perhitungan gaji bersih karyawan }

const
  JAM_KERJA_BULANAN = 173;
  TARIF_LEMBUR      = 1.5;
  TARIF_PAJAK       = 0.05;
  GARIS_GANDA       = '==========================================';
  GARIS_TUNGGAL     = '------------------------------------------';

var
  nama       : string[50];
  jamLembur  : integer;
  gajiPokok  : currency;
  upahPerJam : currency;
  upahLembur : currency;
  gajiKotor  : currency;
  pajak      : currency;
  gajiBersih : currency;

begin
  writeln('Formulir Perhitungan Gaji');
  writeln(GARIS_TUNGGAL);
  writeln;

  write('Nama karyawan     : ');
  readln(nama);

  write('Jam lembur (jam)  : ');
  readln(jamLembur);

  write('Gaji pokok (Rp)   : ');
  readln(gajiPokok);

  upahPerJam := gajiPokok / JAM_KERJA_BULANAN;
  upahLembur := jamLembur * upahPerJam * TARIF_LEMBUR;
  gajiKotor  := gajiPokok + upahLembur;
  pajak      := gajiKotor * TARIF_PAJAK;
  gajiBersih := gajiKotor - pajak;

  writeln;
  writeln(GARIS_GANDA);
  writeln('SLIP GAJI KARYAWAN');
  writeln('PT Maju Bersama');
  writeln(GARIS_GANDA);
  writeln('Nama          : ', nama);
  writeln('Jam lembur    : ', jamLembur, ' jam');
  writeln('Gaji pokok    : Rp ', gajiPokok:0:2);
  writeln(GARIS_TUNGGAL);
  writeln('Upah per jam  : Rp ', upahPerJam:0:2);
  writeln('Upah lembur   : Rp ', upahLembur:0:2);
  writeln('Gaji kotor    : Rp ', gajiKotor:0:2);
  writeln('Pajak 5 persen: Rp ', pajak:0:2);
  writeln(GARIS_TUNGGAL);
  writeln('Gaji bersih   : Rp ', gajiBersih:0:2);
  writeln(GARIS_GANDA);
end.

9.6 Contoh Keluaran

Formulir Perhitungan Gaji
------------------------------------------

Nama karyawan     : Budi Hartono
Jam lembur (jam)  : 12
Gaji pokok (Rp)   : 6500000

==========================================
SLIP GAJI KARYAWAN
PT Maju Bersama
==========================================
Nama          : Budi Hartono
Jam lembur    : 12 jam
Gaji pokok    : Rp 6500000.00
------------------------------------------
Upah per jam  : Rp 37572.25
Upah lembur   : Rp 676300.58
Gaji kotor    : Rp 7176300.58
Pajak 5 persen: Rp 358815.03
------------------------------------------
Gaji bersih   : Rp 6817485.55
==========================================

9.7 Pembahasan

Beberapa keputusan perancangan penting pada program ini.

1. Konstanta bertipe untuk tarif. Dengan mendefinisikan TARIF_LEMBUR dan TARIF_PAJAK sebagai konstanta, bila tarif berubah cukup ubah satu tempat.
2. Operator / untuk upah per jam. Karena gaji pokok tidak selalu habis dibagi 173, operator / menghasilkan real. Dengan tipe currency, hasilnya tetap presisi hingga 4 angka desimal.
3. Urutan operasi perkalian. jamLembur * upahPerJam * TARIF_LEMBUR dievaluasi kiri ke kanan: pertama jamLembur × upahPerJam, lalu hasilnya × TARIF_LEMBUR. Semua bertipe currency, sehingga tidak ada konversi tersembunyi.
4. Penggunaan currency. Semua nilai moneter menggunakan currency, sehingga tidak ada kesalahan pembulatan akumulatif seperti pada real.
5. Blok keluaran terstruktur. Slip gaji disusun dengan writeln tunggal per baris, memudahkan modifikasi format di kemudian hari.

9.8 Pengembangan Selanjutnya

1. Operator aritmatika meliputi +, -, *, /, div, dan mod. Perhatikan bahwa / menghasilkan real, sedangkan div menghasilkan integer.
2. Operator mod menghasilkan sisa bagi dan mengikuti perilaku pembagian bulat Pascal (pembulatan ke arah nol).
3. Fungsi matematika standar seperti Abs, Sqr, Sqrt, Round, dan Trunc sangat berguna dalam perhitungan.
4. Operator relasional membandingkan dua nilai dan menghasilkan boolean. = adalah pembanding, := adalah penugasan.
5. Jangan membandingkan real dengan = secara langsung. Gunakan toleransi epsilon.
6. Operator logika and, or, not, dan xor bekerja pada boolean.
7. Short-circuit evaluation aktif secara default pada Free Pascal modern. Bila operand kiri sudah menentukan hasil, operand kanan tidak dievaluasi.
8. Operator bitwise bekerja pada tingkat bit. and dan or berlaku untuk integer (bitwise) maupun boolean (logika).
9. Prioritas operator menentukan urutan evaluasi. Selalu gunakan tanda kurung untuk memperjelas maksud.
10. Konversi tipe implisit terjadi dari tipe sempit ke tipe lebar. Konversi sebaliknya memerlukan fungsi eksplisit seperti Round atau Trunc.
11. Fungsi Ord dan Chr mengkonversi antara char dan kode ordinalnya. Fungsi Str dan Val mengkonversi antara angka dan string.
12. Waspadai pembagian bilangan bulat. 1 div 2 menghasilkan 0, bukan 0.5. Kesalahan ini sering menimbulkan bug yang sulit dilacak.

Buku Teks

1. Jensen, K., & Wirth, N. (1991). Pascal User Manual and Report (4th ed.). Springer-Verlag. Bab 6 membahas ekspresi dan operator secara formal.
2. Cantu, M. (2020). Object Pascal Handbook. Marco Cantu. Bab 4 membahas operator dan ekspresi pada Free Pascal dan Delphi.
3. Cooper, D., & Clancy, M. (1982). Oh! Pascal! W. W. Norton & Company. Bab tentang ekspresi dan konversi tipe dengan pendekatan pedagogis yang sangat baik.
4. Grogono, P. (1995). Programming with Pascal. Addison-Wesley. Bab 4 membahas operator dan ekspresi.
5. Goldberg, D. (1991). "What Every Computer Scientist Should Know About Floating-Point Arithmetic." ACM Computing Surveys, 23(1), 5-48. Rujukan klasik tentang presisi real.

Dokumentasi Resmi

1. Free Pascal Team. Free Pascal Reference Guide. Bab tentang operator, ekspresi, dan fungsi standar. Tersedia di freepascal.org/docs.html.
2. Free Pascal Team. Free Pascal Programmer's Guide. Bab tentang direktif kompilator {$B+} dan {$B-}.
3. Lazarus IDE Documentation. Panduan penggunaan fungsi matematika dan konversi tipe.

Artikel dan Sumber Daring

1. IEEE Computer Society. (1990). IEEE Standard for Pascal (IEEE Std 770-1983). Bab tentang ekspresi dan operator.
2. Knuth, D. E. (1997). The Art of Computer Programming, Volume 1 (3rd ed.). Addison-Wesley. Bab 1 membahas aritmatika bilangan bulat dan sifat div serta mod.
3. Free Pascal Community Forum. Diskusi tentang perilaku short-circuit pada berbagai mode kompilasi.