Bagian 1: Perancangan Kalkulator

Program latih sejauh ini berjalan dari atas ke bawah, mencetak hasil, lalu berhenti. Kalkulator matriks bekerja secara berbeda: program harus tetap hidup, menampilkan menu, membaca matriks yang diketik pengguna, dan mengulang semuanya sampai pengguna memilih keluar. Pada bagian ini kita menetapkan keputusan desain yang paling mahal diubah belakangan — bentuk input, struktur berkas, dan cara program diuji — lalu membangun kerangka yang sudah bisa dijalankan.

Yang kita bangun pada bagian ini:

• kebutuhan dan fitur program yang jelas batasnya,
• keputusan desain: berkas fungsi, parser manual, dan mode demo,
• struktur proyek beserta diagram arsitektur alur data,
• kerangka kalkulator.m: menu, dispatch, pembacaan pilihan, dan keluar.

Kebutuhan dan Fitur #

Kalkulator ini ditujukan untuk pembelajar yang ingin memeriksa hitungan matriks dengan cepat. Dari kebutuhan itu kita turunkan fitur yang dibangun dan batas yang sengaja tidak dibangun:

Batas seperti “tanpa penyimpanan” bukan kemunduran. Proyek yang cakupannya kecil selesai dan teruji jauh lebih bernilai daripada proyek besar yang setengah jalan — daftar pengembangan lanjutan kita bahas pada Bagian 4.

Keputusan Desain Utama #

Empat keputusan berikut membentuk seluruh kode proyek. Semua diambil sebelum satu baris logika ditulis.

Pertama, program utama berupa berkas fungsi, bukan script. kalkulator.m didefinisikan sebagai function kalkulator(mode). Dengan bentuk ini program bisa menerima argumen: kalkulator berjalan interaktif, kalkulator('demo') berjalan dengan data tetap. Deteksi interaktivitas otomatis tidak kita pakai — Octave 10 tidak menyediakan isinteractive, dan dokumentasi MATLAB R2026b juga tidak memuat fungsi serupa — sedangkan argumen eksplisit bekerja sama di kedua mesin.

Kedua, program interaktif harus bisa diuji otomatis sejak hari pertama. Loop yang membaca input() tidak bisa diuji batch — runner Octave tidak punya keyboard. Karena itu setiap jalur baca input punya sepasang cabang: cabang demo memakai data tetap dan mencetaknya agar keluaran terbaca seperti sesi sungguhan, cabang interaktif memakai input(). Seluruh logika sesudahnya — validasi, operasi, pencetakan — berdiri di atas jalur yang sama sehingga mode demo sungguh menguji program, bukan menirunya.

Ketiga, teks pengguna tidak pernah dieksekusi. Cara cepat menerjemahkan '1 2; 3 4' menjadi matriks adalah eval atau str2num. Kita menolak keduanya dan menulis parser manual.

Keempat, satu tanggung jawab = satu berkas. Setiap operasi (tambahMatriks, kaliMatriks, …) dan setiap util (parserMatriks, tampilkanMatriks, …) berdiri sebagai berkas fungsi sendiri di src/, sehingga bisa dipanggil dari program utama maupun dari test tanpa saling menempel.

Diagram Arsitektur #

Alur satu putaran menu dirangkai dari fungsi-fungsi kecil di src/. Setiap kotak operasi memvalidasi dimensinya sendiri dan melempar error bila tidak layak; galat apa pun ditangkap loop utama lalu program kembali ke menu:

Data mengalir dalam tiga jenis — teks, matriks, dan skalar — sepanjang alur itu. Tabel berikut merangkum transformasi yang menjadi tanggung jawab tiap tahap:

Kerangka Program #

Kerangka tahap ini sudah berupa berkas fungsi lengkap dengan menu dan dispatch, tetapi lima operasi masih berupa pesan placeholder. Simpan isi berikut sebagai src/kalkulator.m:

function kalkulator(mode)
% KALKULATOR Kerangka kalkulator matriks (tahap perancangan).
%   kalkulator          : mode interaktif
%   kalkulator('demo')  : mode demo dengan urutan pilihan tetap
if nargin < 1 || isempty(mode)
    mode = 'interaktif';
end
demo = strcmp(mode, 'demo');

% Mode demo memakai urutan pilihan tetap agar bisa diuji otomatis.
urutanDemo = [1 9 0];
langkah = 1;

selesai = false;
while ~selesai
    tampilkanMenu();
    if demo
        pilihan = urutanDemo(langkah);
        fprintf('Pilihan: %d\n', pilihan);
        langkah = langkah + 1;
    else
        pilihan = str2double(input('Pilihan: ', 's'));
        if isnan(pilihan)
            pilihan = -1;   % teks tak dikenal pasti jatuh ke otherwise
        end
    end
    switch pilihan
        case {1 2 3 4 5}
            fprintf('Operasi matriks dibangun pada Bagian 2.\n');
        case 0
            selesai = true;
            fprintf('Terima kasih. Program selesai.\n');
        otherwise
            fprintf('Pilihan tidak dikenal. Masukkan angka 0 sampai 5.\n');
    end
end
end

function tampilkanMenu()
% TAMPILKANMENU Mencetak menu utama kalkulator.
fprintf('=== Kalkulator Matriks ===\n');
fprintf('1. Tambah matriks\n');
fprintf('2. Kurang matriks\n');
fprintf('3. Kali matriks\n');
fprintf('4. Transpose\n');
fprintf('5. Determinan\n');
fprintf('0. Keluar\n');
end

Mari kita bedah baris-baris kode di atas:

1. Baris 5-7 (if nargin < 1 || isempty(mode)): pemanggilan tanpa argumen (kalkulator) memberi nargin bernilai 0, sehingga mode diisi 'interaktif'. Dengan begitu kalkulator dan kalkulator('interaktif') berperilaku sama.
2. Baris 8 (demo = strcmp(mode, 'demo');): satu baris inilah sakelar mode demo. strcmp menghasilkan logical yang dipakai cabang-cabang berikutnya.
3. Baris 11-12 (urutanDemo = [1 9 0];): mode demo memutar urutan pilihan tetap — coba operasi, ketik pilihan tak dikenal, lalu keluar. langkah adalah penunjuk posisi urutan yang sedang berjalan.
4. Baris 15 (while ~selesai): menu loop. Loop berjalan selama selesai bernilai false; hanya cabang keluar yang menggantinya menjadi true.
5. Baris 17-20 (if demo ... langkah = langkah + 1;): cabang demo mengambil pilihan berikutnya lalu mencetaknya dengan fprintf('Pilihan: %d\n', ...) — gema ini membuat transkrip demo terbaca persis seperti sesi interaktif.
6. Baris 22-25 (pilihan = str2double(input('Pilihan: ', 's'));): pilihan dibaca sebagai teks (input dengan argumen 's'), lalu diubah str2double. Teks yang bukan angka menjadi NaN, diganti -1 agar jatuh ke otherwise — program tidak pernah crash karena salah ketik.
7. Baris 27-35 (switch pilihan): dispatch. case {1 2 3 4 5} mencocokkan semua angka operasi sekaligus, case 0 mengakhiri program, dan otherwise menampung sisanya.
8. Baris 39-48 (function tampilkanMenu()): subfunction pencetak menu. Ia didefinisikan setelah fungsi utama ditutup end — posisi standar subfunction di berkas fungsi, dan aman di MATLAB maupun Octave.

Menjalankan Kerangka #

Uji kerangka lewat mode demo. Panggil kalkulator('demo') dari Command Window pada folder src/, atau lewat berkas driver kecil berisi satu baris kalkulator('demo');:

% driver sementara: jalankan dari folder src/
kalkulator('demo');

Output yang Dihasilkan:

=== Kalkulator Matriks ===
1. Tambah matriks
2. Kurang matriks
3. Kali matriks
4. Transpose
5. Determinan
0. Keluar
Pilihan: 1
Operasi matriks dibangun pada Bagian 2.
=== Kalkulator Matriks ===
1. Tambah matriks
2. Kurang matriks
3. Kali matriks
4. Transpose
5. Determinan
0. Keluar
Pilihan: 9
Pilihan tidak dikenal. Masukkan angka 0 sampai 5.
=== Kalkulator Matriks ===
1. Tambah matriks
2. Kurang matriks
3. Kali matriks
4. Transpose
5. Determinan
0. Keluar
Pilihan: 0
Terima kasih. Program selesai.

Kerangka terbukti hidup: menu tercetak tiap putaran, pilihan tak dikenal ditolak tanpa menghentikan program, dan pilihan 0 menutupnya dengan rapi.

Kerangka kini berdiri dan uji otomatisnya bekerja. Bagian 2 mengisi lima operasi matriks beserta validasi dimensinya — mulai dari tambahMatriks yang paling sederhana sampai kaliMatriks yang aturan kompatibilitasnya paling ketat.