function f(g1,g2,g3)
    if nargin < 3
        g3 = 'varsayilan deger';
    end
end

nargin komutu "number of arguments in"i, yani girdi sayısını veriyor. Fonksiyon iki girdi ile çağırılırsa g3'ü varsayılan değere atıyor.

Yeri gelmişken çıktı sayısını da nargout ile öğrenebildiğimizi söyleyelim. Bazı durumlarda fonksiyonu az sayıdaki değişkene atamak isteriz. Örneğin sadece özdeğerleri istiyorsak, özvektörleri ayrıca hesaplamanın masrafından eigs'ı tek çıktıya eşitleyerek yırtabiliriz.

A = 1:5;

for i = A
    A = 1;
    disp(i);
end

A değişkenini değiştirsek dahi i değişkeni A‘nın ilk halini kullanıyor.

     1

     2

     3

     4

     5

Bir de şu iki kodun farkına bakalım:

tic
for i = 1:10000000
%   Bir şeyler yap
end
toc

tic
for i = [1:10000000]
%   Bir şeyler yap
end
toc

Elapsed time is 0.027504 seconds.
Elapsed time is 1.501059 seconds.

İlkinde C’de olduğu gibi i değişkeni sırasıyla 1′den 10000000′a kadarki değere atandı. Fakat ikinci örnekte önce 10000000′luk bir hafıza açıldı. Ardından döngüye geçildi. İlkini kullanmak daha uygun.

Peki döngü bir vektörde değil de bir matris’te olsaydı?

A = zeros(4); A(:) = 1:16

A =

     1     5     9    13
     2     6    10    14
     3     7    11    15
     4     8    12    16

O zaman sütunlar üstünde döngü kurmuş olacaktık.

i = 1; 
for c = A
    disp(c'); 
    A(:,i) = i; 
    i = i + 1; 
end

     1     2     3     4

     5     6     7     8

     9    10    11    12

    13    14    15    16

A döngü içinde değişmiş olmasına rağmen c‘ye yine statik olarak bağlandı.

A

A =

     1     2     3     4
     1     2     3     4
     1     2     3     4
     1     2     3     4

>> 2 + 1i

ans =
   2.0000 + 1.0000i

>> 3 - 5i

ans =
   3.0000 - 5.0000i

İnsanın ilk olarak aklına K eleman sayılı tüm altkümeleri sırasıyla denemek geliyor. Bunu nchoosek ile yapabiliriz.

N = 20;
K = 10;
x = rand(N,1);
C = nchoosek(x, K);

tic
min_s = realmax;
for i = 1:size(C,1)
    s = std(C(i,:));
    if s < min_s
        min_s = s;
        en_iyi_C = C(i,:);
    end
end
toc

Benim bilgisayarımda 8.33 s tuttu:

Elapsed time is 8.329337 seconds.

Altküme sayısı $\frac{20!}{10!\times 10!} = 184756$. Küçük bir sayı. Peki N 100 olsaydı, K da 50 olsaydı ne yapacaktık? Altküme sayısı $\frac{100!}{50! \times 50!} = 100891344545564150000000000000$ olacaktı. Bir hayli (!) büyük bir sayı. Buna hafıza yetmez dediğinizi duyuyorum. Evet, buna bilgisayardaki beyin yetmez. Ama bizde beyin bedava, onu kullanalım.

Önce elemanları sıralayalım:

N = 100;
K = 50;
x = rand(N,1);
tic
[x_s, ind] = sort(x);

Şimdi de her K boyutlu ardışık dizilimde standart sapmayı hesaplayalım.

min_s = realmax;
for i = 1:(N-K+1)
    s = std(x_s(i:(i+K-1)));
    if s < min_s
        min_s = s;
        en_iyi_ind = ind((i:(i+K-1)));
    end
end
toc

Algoritmamız bu kadar. Sıralamanın karmaşıklığı $O(N \log N)$, sonraki döngü $O(NK)$. Sonuçta karmaşıklık bunların küçüğü.

Artık 1000 elemanlı bir kümenin 500 elemanlı en düşük standart sapmaya ait altkümesini hesaplamak 0.070 s sürüyor!