Array numerik yang telah kita kuasai bersifat homogen: setiap elemen bertipe sama dan seluruh array membentuk kotak berukuran seragam. Data nyata sering menolak aturan itu — satu baris record berisi nama (teks), umur (angka), dan daftar nilai ujian (matriks kecil). Memaksakan data seperti itu ke array biasa memicu konversi tipe yang diam-diam merusak nilai. MATLAB menyediakan cell array sebagai jawaban: array yang setiap elemennya adalah sel independen yang mampu menyimpan tipe dan ukuran apa pun. Bab ini memperkenalkan pembuatan cell array, perbedaan mendasar kurung () vs kurung kurawal {}, serta alat mat2cell/cell2mat.

Array Homogen vs Data Heterogen #

Aturan array biasa: kurung siku menggabungkan elemen menjadi satu blok numerik atau teks yang seragam; ketika tipe berbeda dicampur, MATLAB melakukan konversi implisit tanpa protes:

matlab 
x = [1 'teks'];
fprintf('class(x) : %s\n', class(x));
fprintf('size(x)  : %dx%d\n', size(x, 1), size(x, 2));

Output yang Dihasilkan:

text 
class(x) : char
size(x)  : 1x5

Mari kita bedah baris-baris kode di atas:

  1. Baris 1 (x = [1 'teks']): angka 1 dikonversi menjadi karakter bernomor kode 1, lalu digabungkan dengan empat karakter teks — hasilnya char 1×5, bukan gabungan angka dan teks.
  2. Baris 2-3 (class, size): kelas hasil adalah char dengan lima elemen — angka 1 sudah kehilangan makna numeriknya.

Cell array mengganti aturan seragam dengan aturan sel: setiap elemen adalah sel — wadah berdiri sendiri — sehingga barisan 1×3 yang berisi double, char, dan matriks tetap sah.

Membuat Cell Array #

Pembuatan cell array memakai kurung kurawal {} dengan pemisah yang sama seperti kurung siku: koma atau spasi untuk kolom, titik koma untuk baris:

matlab 
C = {1, 'teks', [1 2 3]};
fprintf('class(C) : %s\n', class(C));
fprintf('size(C)  : %dx%d\n', size(C, 1), size(C, 2));

Output yang Dihasilkan:

text 
class(C) : cell
size(C)  : 1x3

Mengetik nama C tanpa titik koma di Command Window menampilkan ringkasan isi tiap sel dalam gaya tampilan MATLAB:

text 
C =
  1×3 cell array
    {[1]}    {'teks'}    {1×3 double}

Fungsi cell(2, 2) menyiapkan kerangka kosong — setiap sel berisi array kosong [] bertipe double, siap diisi:

matlab 
ruang = cell(2, 2);
fprintf('ruang : cell %dx%d, class isi {1,1}: %s\n', ...
        size(ruang,1), size(ruang,2), class(ruang{1,1}));

Output yang Dihasilkan:

text 
ruang : cell 2x2, class isi {1,1}: double

Mari kita bedah baris-baris kode di atas:

  1. Baris 1 (C = {1, 'teks', [1 2 3]}): tiga sel berjajar — sel 1 berisi skalar double, sel 2 berisi char, sel 3 berisi matriks double 1×3; seluruh wadah berkelas cell berukuran 1×3.
  2. Baris 1 (ruang = cell(2, 2)): fungsi cell() mengalokasikan wadah 2×2; isi sel masih [] sehingga kelasnya double — bukti bahwa sel memang wadah netral yang menunggu diisi.

Kurung () vs Kurung Kurawal #

Konsep terpenting bab ini: kurung () dan kurung kurawal {} mengambil dua hal yang berbeda. Kurung () mengambil sel-nya — hasilnya tetap cell array. Kurung kurawal {} mengambil isi sel — hasilnya mengikuti kelas apa pun yang tersimpan di dalam sel. Diagram berikut merangkum perbedaannya:

Analoginya: kurung () menyerahkan kotaknya (hasil masih berupa kotak), kurung kurawal {} membuka kotak dan menyerahkan isinya. Contoh konkret dengan pemeriksaan kelas:

matlab 
fprintf('C{1} : class %s, nilai %d\n', class(C{1}), C{1});
fprintf('C{2} : class %s, nilai %s\n', class(C{2}), C{2});
v = C{3};
fprintf('C{3} : class %s, nilai %d %d %d\n', class(C{3}), v);

sel = C(2);
fprintf('C(2) : class %s, size %dx%d\n', class(sel), size(sel,1), size(sel,2));

Output yang Dihasilkan:

text 
C{1} : class double, nilai 1
C{2} : class char, nilai teks
C{3} : class double, nilai 1 2 3
C(2) : class cell, size 1x1

Mari kita bedah baris-baris kode di atas:

  1. Baris 1-2 (C{1}, C{2}): kurung kurawal membuka sel — kelas yang dilaporkan adalah kelas isi (double, char), dan nilainya langsung bisa dipakai sebagai angka atau teks.
  2. Baris 3 (v = C{3}): isi sel ketiga (matriks 1×3) disalin ke variabel v sebagai double biasa — setelah keluar dari sel, tidak ada lagi atribut cell.
  3. Baris 6 (sel = C(2)): kurung menghasilkan cell array 1×1 yang membungkus 'teks' — kelasnya cell, bukan char.

Tertukar-tukar keduanya berujung galat. Ekspresi C(2) + 1 mencoba menjumlahkan cell dengan skalar:

text 
Undefined operator '+' for input arguments of type 'cell'.

Menyimpan Matriks Berbeda Ukuran #

Array biasa menuntut blok berbentuk persegi panjang, tetapi sel-sel cell array bebas berukuran apa pun. Satu cell array dapat menampung matriks 2×2 dan vektor baris 1×3 sekaligus:

matlab 
A = [1 2; 3 4];
B = [10 20 30];
kumpulan = {A, B};

fprintf('kumpulan{1}: %dx%d\n', size(kumpulan{1},1), size(kumpulan{1},2));
fprintf('kumpulan{2}: %dx%d\n', size(kumpulan{2},1), size(kumpulan{2},2));
fprintf('kumpulan{1} baris 1: %d %d\n', kumpulan{1}(1,:));

Output yang Dihasilkan:

text 
kumpulan{1}: 2x2
kumpulan{2}: 1x3
kumpulan{1} baris 1: 1 2

Mari kita bedah baris-baris kode di atas:

  1. Baris 3 (kumpulan = {A, B}): dua matriks berukuran berbeda masuk ke dua sel yang berbeda — tidak ada syarat bentuk seragam.
  2. Baris 7 (kumpulan{1}(1,:)): pengindeksan berantai — kumpulan{1} membuka sel pertama (matriks 2×2), lalu (1,:) mengiris baris pertama matriks tersebut.

Memecah dan Menggabung: mat2cell dan cell2mat #

Dua fungsi jembatan menghubungkan dunia matriks dan dunia cell array. Fungsi mat2cell(M, pembagianBaris, pembagianKolom) memecah matriks menjadi blok-blok, sedangkan cell2mat menyusun blok-blok kembali menjadi matriks utuh:

matlab 
M = [1 2 3 4; 5 6 7 8; 9 10 11 12];
blok = mat2cell(M, [2 1], [1 3]);
gabungan = cell2mat(blok);

fprintf('blok        : cell %dx%d\n', size(blok,1), size(blok,2));
fprintf('blok{1,1}   : %dx%d\n', size(blok{1,1},1), size(blok{1,1},2));
fprintf('blok{1,2}   : %dx%d\n', size(blok{1,2},1), size(blok{1,2},2));
fprintf('blok{1,2} b1: %d %d %d\n', blok{1,2}(1,:));
fprintf('gabungan    : %dx%d, elemen (3,4) = %d\n', ...
        size(gabungan,1), size(gabungan,2), gabungan(3,4));

Output yang Dihasilkan:

text 
blok        : cell 2x2
blok{1,1}   : 2x1
blok{1,2}   : 2x3
blok{1,2} b1: 2 3 4
gabungan    : 3x4, elemen (3,4) = 12

Mari kita bedah baris-baris kode di atas:

  1. Baris 2 (mat2cell(M, [2 1], [1 3])): baris M terbagi 2+1 (dua baris pertama, satu baris terakhir) dan kolomnya terbagi 1+3 — hasilnya cell array 2×2 berisi empat blok.
  2. Baris 8 (blok{1,2}(1,:)): blok kanan-atas berukuran 2×3; baris pertamanya adalah 2 3 4 — irisan baris 1-2 dengan kolom 2-4 dari M.
  3. Baris 3 (cell2mat(blok)): kebalikan mat2cell — empat blok disusun kembali menjadi matriks 3×4 yang identik dengan M.

Menampilkan Isi Cell Array #

Fungsi disp pada cell array hanya menampilkan ringkasan per sel, sehingga untuk melihat seluruh isi kita memakai celldisp:

matlab 
celldisp(C)

Output yang Dihasilkan (tampilan Command Window MATLAB):

text 
C{1} =
     1

C{2} =
teks

C{3} =
     1     2     3

celldisp menelusuri sel demi sel (kolom demi kolom, seperti pengindeksan array) dan mencetak label C{i} beserta isi lengkapnya — praktis untuk memeriksa cell array kecil.

Ringkasan #

Cell array menyimpan data heterogen: {1, 'teks', [1 2 3]} sah karena setiap sel adalah wadah independen. Kurung () mengambil sel (hasil tetap cell), kurung kurawal {} mengambil isinya (hasil mengikuti kelas isi). Fungsi mat2cell dan cell2mat menjembatani matriks dan cell array, sementara celldisp menampilkan isi seluruh sel. Berkas contoh.m pada bagian bawah halaman menguji seluruh contoh bab ini secara utuh.