Operasi Elemen Array

Sebagai pengolah data, hampir seluruh pekerjaan kita adalah mentransformasi daftar nilai: mengonversi satuan suhu, menerapkan diskon berbeda untuk tiap item, atau menormalisasi kolom hasil pengukuran. Pekerjaan seperti itu menuntut operasi elemen-per-elemen — keluarga dot operator .*, ./, .^ yang telah kita lihat sekilas pada Chapter Operator Aritmetika. Bab ini menjadikan dot operator alat kerja utama: keluarga lengkapnya, aturan campuran skalar-array, dua studi kasus nyata, serta galat yang muncul bila ukuran operand tidak cocok.

Keluarga Dot Operator #

Aturannya satu kalimat: dot operator menghitung hasil pada tiap pasangan elemen yang menempati posisi yang sama, tanpa penjumlahan lintas baris atau lintas kolom. Tabel berikut memetakan setiap operator matriks ke pasangan dot operator-nya:

Operator + dan - tidak memiliki pasangan titik karena keduanya memang sudah bekerja elemen-per-elemen; .+ bukan operator MATLAB dan memicu galat sintaksis.

Mekanismenya: ketika MATLAB menemui a .* b, interpreter memeriksa kecocokan ukuran kedua operand, lalu memproses tiap pasangan (i,j) secara independen — elemen a(i,j) berpasangan dengan b(i,j), tanpa interaksi dengan tetangganya:

a = [6 8 10];
b = [2 4 20];

fprintf('a      = %d %d %d\n', a);
fprintf('b      = %d %d %d\n', b);
fprintf('a .* b = %d %d %d\n', a .* b);
fprintf('a ./ b = %g %g %g\n', a ./ b);
fprintf('a .^ 2 = %d %d %d\n', a .^ 2);
fprintf('2 .^ a = %d %d %d\n', 2 .^ a);

Output yang Dihasilkan:

a      = 6 8 10
b      = 2 4 20
a .* b = 12 32 200
a ./ b = 3 2 0.5
a .^ 2 = 36 64 100
2 .^ a = 64 256 1024

Mari kita bedah baris-baris kode di atas:

1. Baris 4 (a .* b): tiap pasangan dikalikan sendiri — 6×2 = 12, 8×4 = 32, 10×20 = 200.
2. Baris 5 (a ./ b): tiap pasangan dibagi sendiri — 6/2 = 3, 8/4 = 2, 10/20 = 0.5.
3. Baris 6 (a .^ 2): pangkat skalar 2 diterapkan ke tiap elemen a — 6², 8², 10².
4. Baris 7 (2 .^ a): basis skalar 2, pangkat diambil dari elemen a — 2⁶ = 64, 2⁸ = 256, 2¹⁰ = 1024.

Campuran Skalar dan Array #

Skalar boleh berpasangan dengan array berukuran apa pun: a + 100, a .* 3, 100 ./ a, hingga negasi unary -a. Mekanismenya: skalar adalah array 1×1, dan lewat aturan dimensi kompatibel (dibahas tuntas pada Chapter Broadcasting dan Implicit Expansion), operand berukuran 1×1 direntangkan mengikuti pasangannya. Perilaku ini dikenal sebagai scalar expansion — skalar otomatis “menular” ke semua elemen:

fprintf('-a       = %d %d %d\n', -a);
fprintf('a + 100  = %d %d %d\n', a + 100);
fprintf('a .* 3   = %d %d %d\n', a .* 3);
fprintf('100 ./ a = %g %g %g\n', 100 ./ a);

Output yang Dihasilkan:

-a       = -6 -8 -10
a + 100  = 106 108 110
a .* 3   = 18 24 30
100 ./ a = 16.6667 12.5 10

Mari kita bedah baris-baris kode di atas:

1. Baris 1 (-a): operator unary minus menegatifkan tiap elemen a.
2. Baris 4 (100 ./ a): pembagian dibaca dari kiri — 100 dibagi tiap elemen a — kebalikan arah dari a ./ 100.

Studi Kasus: Konversi Suhu #

Masalah: kolom suhu dalam satuan Fahrenheit perlu dikonversi ke Celsius dengan rumus C = (F − 32) × 5/9. Karena semua operand non-array berupa skalar, rumus tersebut langsung diterapkan pada array tanpa loop:

suhuF = [68 77 86 95];
suhuC = (suhuF - 32) * 5 / 9;         % skalar menular ke semua elemen
konversi = [suhuF; suhuC];            % susun menjadi tabel 2x4
fprintf('%g F = %g C\n', konversi);   % fprintf membaca kolom demi kolom

Output yang Dihasilkan:

68 F = 20 C
77 F = 25 C
86 F = 30 C
95 F = 35 C

Mari kita bedah baris-baris kode di atas:

1. Baris 2 (suhuC = (suhuF - 32) * 5 / 9): suhuF - 32 menghasilkan array 1×4 (skalar 32 menular ke semua elemen), lalu * 5 dan / 9 bekerja dengan skalar lagi — tiap elemen diproses sendiri: (68−32)×5/9 = 20, (77−32)×5/9 = 25, dan seterusnya.
2. Baris 3 (konversi = [suhuF; suhuC]): concatenation vertikal membentuk tabel 2×4 — baris 1 Fahrenheit, baris 2 Celsius.
3. Baris 4 (fprintf): fungsi fprintf mengonsumsi argumen array secara kolom demi kolom, sehingga pasangan yang terbentuk adalah (68, 20), (77, 25), (86, 30), (95, 35) — perilaku yang dibahas pada Chapter Format Output.

Studi Kasus: Diskon per Item #

Masalah: empat item memiliki harga dan persentase diskon yang berbeda. Karena harga dan diskon sama-sama array 1×4, perkaliannya wajib memakai .* — operator * justru galat karena 1×4 dikalikan 1×4 melanggar inner dimension:

harga  = [150000 275000 89000 420000];
diskon = [0.10 0.20 0.05 0.15];
hargaBayar = harga .* (1 - diskon);   % elemen demi elemen

fprintf('Rp%g  ->  Rp%g\n', [harga; hargaBayar]);

Output yang Dihasilkan:

Rp150000  ->  Rp135000
Rp275000  ->  Rp220000
Rp89000  ->  Rp84550
Rp420000  ->  Rp357000

Mari kita bedah baris-baris kode di atas:

1. Baris 2 (1 - diskon): skalar 1 dikurangkan tiap elemen diskon, menghasilkan faktor pengali [0.90 0.80 0.95 0.85].
2. Baris 3 (harga .* (1 - diskon)): dua array 1×4 dikalikan posisi demi posisi — 150000×0.90 = 135000, 275000×0.80 = 220000, 89000×0.95 = 84550, 420000×0.85 = 357000.
3. Baris 5 (fprintf): tabel 2×4 [harga; hargaBayar] dibaca kolom demi kolom sehingga tiap baris output memuat pasangan harga asal dan harga bayar.

Galat Bila Ukuran Tidak Cocok #

Dot operator menuntut operand yang ukurannya cocok. Vektor kolom 3×1 ditambah vektor baris 1×2 tidak memiliki satu pun dimensi yang sama ataupun bernilai 1, sehingga MATLAB menolak:

a = [1; 2; 3];      % 3x1
b = [10 20];        % 1x2
a + b               % dimensi pertama 3 vs 2: tidak kompatibel

Error using +
Arrays have incompatible sizes for this operation.

Ringkasan #

Dot operator .*, ./, .\, .^ memproses array elemen-per-elemen dan wajib dipakai setiap kali kita mengolah data, sedangkan operator matriks *, /, \, ^ disiapkan untuk aljabar linear. Skalar dapat berpasangan dengan array ukuran apa pun melalui scalar expansion. Berkas contoh.m pada bagian bawah halaman menguji seluruh keluarga operator beserta kedua studi kasus di atas.