Mengubah Ukuran Array

Data yang sama sering dibutuhkan dalam bentuk yang berbeda: deret sensor panjang harus disusun menjadi tabel per hari, atau gambar perlu diputar 90 derajat. MATLAB memisahkan ISI dari BENTUK: seluruh fungsi pada Chapter ini menyusun ulang elemen yang sama tanpa menghitung ulang satu nilai pun. Bab ini juga membahas soal performa — mengapa menumbuhkan array sedikit demi sedikit itu mahal, dan bagaimana preallocation menyelesaikannya:

• reshape dan aturan column-major-nya
• permute untuk menyusun ulang dimensi
• fliplr, flipud, flip, dan rot90
• Transpose ' versus .'
• Menumbuhkan array dan preallocation

reshape: Bentuk Baru, Data Lama #

Aturannya: reshape(A, m, n) menyusun ulang elemen A menjadi matriks m×n dengan syarat numel TIDAK berubah. Mekanismenya: MATLAB membaca elemen A mengikuti urutan column-major, lalu menuliskannya ke array baru — juga kolom demi kolom. Karena pembacaan dan penulisan sama-sama column-major, elemen ke-k tetap di posisi linear ke-k; hanya label baris-kolomnya yang berubah:

dataSuhu = reshape(1:12, 3, 4);
fprintf('reshape(1:12, 3, 4):\n');
disp(dataSuhu);

satuBaris = reshape(dataSuhu, 1, 12);
fprintf('size satuBaris: %d x %d\n', size(satuBaris));
fprintf('satuBaris: ');
fprintf('%d ', satuBaris);
fprintf('\n');

Output yang Dihasilkan:

reshape(1:12, 3, 4):
     1     4     7    10
     2     5     8    11
     3     6     9    12
size satuBaris: 1 x 12
satuBaris: 1 2 3 4 5 6 7 8 9 10 11 12

Mari kita bedah baris-baris kode di atas:

1. Baris 1 (reshape(1:12, 3, 4)): deret 1..12 disusun kolom demi kolom — kolom pertama berisi 1, 2, 3, kolom kedua 4, 5, 6, dan seterusnya. Pola vertikal ini adalah jejak column-major dari Chapter Konsep Array dan Matriks.
2. Baris 5 (reshape(dataSuhu, 1, 12)): matriks 3×4 diluruskan kembali menjadi row vector 1×12 — urutan linear elemen tidak pernah berubah.
3. Ukuran bebas: satu dimensi boleh ditulis -1 atau [] agar MATLAB menghitung sendiri — reshape(1:12, [], 4) menghasilkan 3×4.

Bila jumlah elemen berubah, MATLAB menolak dengan galat Error using reshape / To RESHAPE the number of elements must not change. — kontrak reshape hanya mengganti bentuk, tidak pernah menambah atau membuang elemen.

permute: Menukar Urutan Dimensi #

Fungsi permute(A, order) menyusun ulang DIMENSI array: dimensi ke-order(1) array baru menjadi dimensi pertama, dan seterusnya. Untuk array 2-D, permute(A, [2 1]) menukar baris dengan kolom; untuk array 3-D, permute adalah satu-satunya cara menukar dimensi tanpa mengubah makna data:

M = [10 20; 30 40];
Mtukar = permute(M, [2 1]);
fprintf('permute(M, [2 1]) baris 1: %d %d\n', Mtukar(1, :));
fprintf('permute(M, [2 1]) baris 2: %d %d\n', Mtukar(2, :));

kubus = reshape(1:8, 2, 2, 2);
fprintf('size kubus: %d x %d x %d\n', size(kubus));
kubusTukar = permute(kubus, [3 1 2]);
fprintf('size kubusTukar: %d x %d x %d\n', size(kubusTukar));

Output yang Dihasilkan:

permute(M, [2 1]) baris 1: 10 30
permute(M, [2 1]) baris 2: 20 40
size kubus: 2 x 2 x 2
size kubusTukar: 2 x 2 x 2

Mari kita bedah baris-baris kode di atas:

1. Baris 2 (permute(M, [2 1])): dimensi 2 naik jadi dimensi 1 — [10 20; 30 40] menjadi [10 30; 20 40]. Elemen tidak dihitung ulang; hanya alamat baris-kolomnya yang dipetakan ulang.
2. Baris 6-9 (permute(kubus, [3 1 2])): array 2×2×2 diatur ulang sehingga pages menjadi baris. Ukurannya kebetulan tetap 2×2×2, tetapi isi tiap halaman berpindah tempat.

fliplr, flipud, flip, dan rot90 #

Keluarga fungsi berikut membalik dan memutar array tanpa menyentuh nilainya: fliplr mencerminkan tiap baris, flipud membalik urutan baris, flip(A, dim) adalah bentuk umum untuk dimensi mana pun, dan rot90(A) memutar 90 derajat berlawanan arah jarum jam (rot90(A, k) memutar k kali):

A = [1 2 3; 4 5 6];

kirBalik = fliplr(A);
bwhBalik = flipud(A);
kolBalik = flip(A, 2);
R90 = rot90(A);
R180 = rot90(A, 2);

fprintf('fliplr(A)   baris 1: %d %d %d\n', kirBalik(1, :));
fprintf('flipud(A)   baris 1: %d %d %d\n', bwhBalik(1, :));
fprintf('flip(A, 2)  baris 1: %d %d %d\n', kolBalik(1, :));
fprintf('size rot90(A)  : %d x %d\n', size(R90));
fprintf('rot90(A)    baris 1: %d %d\n', R90(1, :));
fprintf('rot90(A)    baris 2: %d %d\n', R90(2, :));
fprintf('rot90(A, 2) baris 1: %d %d %d\n', R180(1, :));

Output yang Dihasilkan:

fliplr(A)   baris 1: 3 2 1
flipud(A)   baris 1: 4 5 6
flip(A, 2)  baris 1: 3 2 1
size rot90(A)  : 3 x 2
rot90(A)    baris 1: 3 6
rot90(A)    baris 2: 2 5
rot90(A, 2) baris 1: 6 5 4

Mari kita bedah baris-baris kode di atas:

1. Baris 3 (kirBalik = fliplr(A)): tiap baris dicerminkan — [1 2 3] menjadi [3 2 1].
2. Baris 4 (bwhBalik = flipud(A)): urutan baris dibalik — baris pertama hasilnya [4 5 6]; isi tiap barisnya sendiri tidak berubah.
3. Baris 5 (kolBalik = flip(A, 2)): dimensi 2 adalah kolom, jadi flip(A, 2) identik dengan fliplr(A); flip(A, 1) identik dengan flipud(A).
4. Baris 6-7 (R90, R180): matriks 2×3 menjadi 3×2 — kolom pertama hasil [3 6] adalah baris terakhir A yang dibaca terbalik; rot90(A, 2) sama dengan rotasi 180°.

Transpose: Kutip versus Kutip-Titik #

Transpose menukar baris dan kolom. Operator ' menghasilkan transpose konjugat — bilangan kompleks diubah ke konjugatnya; operator .' menghasilkan transpose biasa tanpa konjugat (keduanya kita perkenalkan pada Chapter Operator Aritmetika). Untuk data real keduanya identik; bedanya baru terasa pada bilangan kompleks:

z = [1+2i, 3-4i];
fprintf('imag z      : %d %d\n', imag(z));
fprintf('imag z konjugat : %d %d\n', imag(z'));
fprintf('imag z transpose: %d %d\n', imag(z.'));

v = [10 20 30];
w = v';
fprintf('size w: %d x %d\n', size(w));
fprintf('isi w : %d %d %d\n', w);

Output yang Dihasilkan:

imag z      : 2 -4
imag z konjugat : -2 4
imag z transpose: 2 -4
size w: 3 x 1
isi w : 10 20 30

Mari kita bedah baris-baris kode di atas:

1. Baris 3 (imag(z')): konjugat membalik tanda bagian imajiner — 2 menjadi -2, -4 menjadi 4. Gunakan ' untuk aljabar linear (misalnya x' * x).
2. Baris 4 (imag(z.')): bagian imajiner dipertahankan — .' murni menukar bentuk. Gunakan .' untuk mentranspose data pengukuran yang kebetulan kompleks.
3. Baris 7-9 (w = v'): row vector 1×3 menjadi column vector 3×1 dengan isi yang sama persis.

Menumbuhkan Array dan Preallocation #

Array dapat membesar otomatis: assignment ke indeks di luar ukuran saat ini membuat MATLAB memperluas array dan mengisi celahnya dengan 0. Pola deret(end+1) = nilai menambah satu elemen di ekor:

deret = [];
deret(end+1) = 10;
deret(end+1) = 20;
deret(end+1) = 30;
fprintf('deret setelah tumbuh: ');
fprintf('%d ', deret);
fprintf('(%d elemen)\n', numel(deret));

pre = zeros(1, 3);
pre(3) = 30;
fprintf('pre: %d %d %d\n', pre);

Output yang Dihasilkan:

deret setelah tumbuh: 10 20 30 (3 elemen)
pre: 0 0 30

Mari kita bedah baris-baris kode di atas:

1. Baris 1-4 (deret(end+1) = ...): tiap assignment membuat MATLAB mengalokasikan blok memori BARU, menyalin seluruh isi lama, lalu menulis elemen baru — sekuens realokasi-salin-tulis yang berulang. Untuk tiga elemen tidak terasa; untuk puluhan ribu penambahan, ongkos kumulatifnya tumbuh kuadratik (O(n²)).
2. Baris 9-11 (pre = zeros(1, 3)): preallocation — tempat dipesan SEKALI di depan (zeros dari Chapter Membuat Matriks); pre(3) = 30 kemudian menulis tanpa realokasi, dan posisi 1-2 tetap 0 menunggu giliran diisi.

Berkas contoh.m pada bagian bawah halaman menjalankan seluruh transformasi di atas dalam satu script yang dapat dijalankan langsung.

Ringkasan #

reshape menyusun ulang elemen dengan syarat numel tetap, permute menukar urutan dimensi, keluarga flip/rot90 mencerminkan dan memutar, sedangkan ' dan .' mentranspose dengan dan tanpa konjugat kompleks — semuanya tanpa menghitung ulang nilai. Sebaliknya, menumbuhkan array memicu realokasi berulang yang mahal; pesan tempat lebih dulu dengan zeros begitu ukuran akhir diketahui. Dengan bentuk yang kini lentur, kita siap menggabungkan beberapa array menjadi satu lewat concatenation.