Sabtu, 09 Juni 2018


TUGAS UAS ALGORITMA GENETIKA


%Mengubah bil Interger menjadi bilangan biner
%Masukan 
%BilInterger : bilangan interger
%JumBit : Jumlah bit yang diinginkan
%keluaran
%BilBiner : bilangan biner, matrix berukuran 1xJumBit

function BilBiner = Int2Bin(BilInterger,JumBit);
for ii=1:JumBit,
    if mod(BilInterger,2)==0,
        BilBiner(JumBit+1-ii)=0;
    else
        BilBiner(JumBit+1-ii)=1;
    end
    BilInterger=fix(BilInterger/2);
end

Share:

Senin, 21 Mei 2018


Penjelasan Listing program algoritma genetik implementasi Matlab
(TOOLBOX MATLAB)
function [B,A]=GadposE0(gen,pop,Jenis); %mendeklarasikan fungsi lokal GadposE0 dengan 3 variabel yaitu generasi,populasi, dan jenis
% Program Optimalisasi model kontrol PID servomotor dengan GA
% Output arguments berupa koefisien PID (KP, KI, KD) , A dan KTach
% Input argument berupa kontrol ‘posisi’
global inpxOpts inpmOpts inpselectOps inpbounds bounds; % input argumen global yaitu koefisien ceossover, koefisien mutasi, dan koefesien seleksi
  
rand('seed',0); r %random

switch lower(Jenis) %memeriksa nilai ‘jenis’
case 'posisi', disp('Keofisien posisi') %jika input adala ‘posisi’ maka akan muncul ‘Koefisien Posisi’
   GadEvalposE0(0); % memanggil fungsi GadEvalposE0

function [sol,val] = GadEvalposE0(sol,options) %membuat fungsi dengan nama GadEvalposE0 dengan dua variabel yaitu sol dan options
global inpxOpts inpmOpts inpselectOps inpbounds; %input fungsi global yaitu koefisien crossover, koefisien mutasi, dan koefisien seleksi
  
inpxOpts = [2 0;2 3;2 0];               %nilai Koefisien Crossover
inpmOpts = [2 0 0;2 0 0];              %nilai Koefisien Mutasi
inpselesctOps = [0.04];                 %nilai Koefisien Seleksi
if nargin==2
% Note: 1 oz-in = 7.0615e-3 N.m          
        Ebalik=0.0708;                      %nilai Ebalik motor                
        Torsi=10.02*7.0615e-3;        %nilai torsi motor
        B=9.55e-4*7.0615e-3;          %nilai B motor
        Resistan=1.64;                      %nilai resistansi motor
        ilitan=3.39e-3;                       %jumlah lilitan motor
        J=0.0108*7.0615e-3;            %nilai J motor
     jarak=1.57;                               %nilai jarak motor
  k=0;                     %memisalkan varibel k dengan nilai 0
   for t=0:0.001:0.1 %untuk t=0, 0.001, dan 0.1   
      k=k+1;                        %maka nilai k sekarang sama dengan nilai k sebelumnya ditambah 1
      if t>0.01   %jika t besar dari 0.1
          G(k)=jarak;  %maka nilai G(k) samadengan nilai jarak
          GG(k)=G(k);  %nilai GG(k) sama dengan G(k)         
      Else %jika tidak
          G(k)=jarak*(t/0.01);%maka nilai G(k)=jarak*(t/0.01)
          GG(k)=G(k); %nilai GG(k) sama dengan G(k)         
      end      %logika if berakhir           
   end;    %logika for berakhir
c1=(jarak*sol(4)*Torsi*sol(3));      %-(0.01*ilitan);
           c2=(jarak*sol(4)*Torsi*sol(1));       %-(0.01*Resistan);

           c3=jarak*sol(4)*Torsi*sol(2);

           u1=(ilitan*J);
           u2=ilitan*B+Resistan*J;
           u3=Resistan*B+(sol(4)*Torsi*sol(5))+(Ebalik*Torsi)+(sol(4)*Torsi*sol(3));
           u4=sol(4)*Torsi*sol(1);
           u5=sol(4)*Torsi*sol(2);
  
   T=0:0.001:0.1;
   %G
   num={[c1 c2 c3]};
   den={[u1 u2 u3 u4 u5]};
   h=tf(num,den);
   F=step(h,T);

   FF=F';
   HH=FF;
   %HH
   Er1=HH-G;
   Er2=GG-HH;
   Err1=Er1.^2;
   Err2=Er2.^2;
   Error1=Err1*ones(k,1);
   Error2=Err2*ones(k,1);
   val=10/(Error1+Error2);
end 
bt1=[0 200]; 
bt2=[0 2

00];
bt3=[0 1]; 
bt4=[2 200]; 
bt5=[0.01 1];

inpbounds = [bt1;bt2;bt3;bt4;bt5];


  evalFn = 'GadEvalposE0'; %pemberian nilai variabel
   jumpop=pop; %inisialisasi varibel jumlah populasi=populasi
      bounds = inpbounds; %membuat variabel bounds = fungsi global baounds
      gaOpts=[1e-6 1 1]; %koefisien ga optimasi
      startPop = initializega(jumpop,bounds,'GadEvalposE0',[1e-6 1]); %membuat variabel satrtpop = menginisialisasi beberapa variabel

otherwise, disp('Jenis tak diketahui') %jika tidak sesuai maka akan ditampilkan ‘jenis tak diketahui’
end %logika swicth berakhir

%flops(0);

% Crossover Operators
xFns = 'arithXover heuristicXover simpleXover'; %inisialisasi operator-operator Crossover yaitu arith Crossover, Heuristic Crosover, dan Simple Crosover


function [c1,c2] = arithXover(p1,p2,bounds,Ops) %membuat fungsi arithXover dengan 4 variabel
%p1 – orangtua pertama
%p2- orangtua kedua
% bounds - batas matriks untuk ruang solusi
% Ops - Pilihan matriks untuk arit crossover [gen #ArithXovers]
% Pilih jumlah mix acak
a = rand; %membuat variabel a dengan nilai = random

% Buat anak-anak
c1 = p1*a     + p2*(1-a); %nilai anak pertama
c2 = p1*(1-a) + p2*a;              %nilai anak kedua

function [c1,c2] = heuristicXover(p1,p2,bounds,Ops)
% p1 - orang tua pertama ([nilai fungsi string solusi])
% p2 - induk kedua ([nilai fungsi string solusi])
% bounds - batas matriks untuk ruang solusi
% Ops - Pilihan untuk crossover heuristik, [gen #heurXovers number_of_retries]
retry=Ops(3);                                      % Number of retries
i=0;
good=0;
b1=bounds(:,1)';
b2=bounds(:,2)';
numVar = size(p1,2)-1;
% Tentukan orang tua terbaik dan terburuk
if(p1(numVar+1) > p2(numVar+1))
  bt = p1;
  wt = p2;
else
  bt = p2;
  wt = p1;
end
while i<retry
% Pilih jumlah mix acak
  a = rand;
 % Buat anak
  c1 = a * (bt - wt) + bt;
 
  % Periksa untuk melihat apakah anak dalam batas
  if (c1(1:numVar) <= b2 & (c1(1:numVar) >= b1))
    i = retry;
    good=1;
  else
    i = i + 1;
  end
end



% Jika anak baru tidak layak kembalikan anak baru
if(~good)
  c1 = wt;
end

% FungsiCrossover mengembalikan dua anak sehingga mengembalikan yang terbaik
% dan anak baru dibuat
c2 = bt;

function [c1,c2] = simpleXover(p1,p2,bounds,Ops)   %membuat fungsi simpleXover
% p1 - orang tua pertama ([nilai fungsi string solusi])
% p2 - induk kedua ([nilai fungsi string solusi])
%bounds- batas matriks untuk ruang solusi
% Ops - Pilihan matriks untuk crossover sederhana [gen #SimpXovers].
numVar = size(p1,2)-1;                                   % Dapatkan jumlah variabel
% Pilih titik potong secara acak dari 1-angka vars
cPoint = round(rand * (numVar-2)) + 1;
a
c1 = [p1(1:cPoint) p2(cPoint+1:numVar+1)]; % Buat anak-anak
c2 = [p2(1:cPoint) p1(cPoint+1:numVar+1)];

xOpts = inpxOpts; %membuat variabel xopts=koefisien Crossover

% Mutation Operators

mFns = 'boundaryMutation unifMutation'; %inisialisasi operator-operator mutasi yaitu boundary mutasi dan unif mutasi

function [parent] = boundaryMutate(parent,bounds,Ops)    %membuat fungsi boundari mutasi
% parent - orang tua pertama ([nilai fungsi string solusi])
%bounds- batas matriks untuk ruang solusi
% Ops - Opsi untuk boundaryMutation [gen #BndMutations]
numVar = size(parent,2)-1;              % Dapatkan jumlah variabel
% Pilih variabel untuk bermutasi secara acak dari 1-angka vars
mPoint = round(rand * (numVar-1)) + 1;
b = round(rand)+1;                           % Pilih yang terikat untuk pindah
newValue = bounds(mPoint,b);                    % Sekarang bermutasi titik itu
parent(mPoint) = newValue;                        % Buat anak itu



function [parent] = uniformMutate(parent,bounds,Ops) %membuat fungsi uni mutasi
% parent  - orangtua pertama ([nilai fungsi string solusi])
% bounds  - matriks batas untuk ruang solusi
% Ops     - Opsi untuk uniformMutation [gen #UnifMutations]


df = bounds(:,2) - bounds(:,1);         % Rentang variabel
numVar = size(parent,2)-1;              % Dapatkan jumlah variabel
% Pilih variabel untuk bermutasi secara acak dari 1-angka vars
mPoint = round(rand * (numVar-1)) + 1;
newValue = bounds(mPoint,1)+rand * df(mPoint); % Sekarang bermutasi titik itu
parent(mPoint) = newValue;                        % Buat anak itu



mOpts = inpmOpts; %membuat variabel mopts=koefisien mutasi

% Termination Operators

termFns = 'maxGenTerm'; %inisialisasi operator terminasi yaitu maxgenterm
function [done] = maxGenTerm(ops,bPop,endPop)
% ops    - vektor opsi [current_gen maximum_generation]
% bPop   - matriks solusi terbaik [generation_found solution_string]
% endPop - generasi solusi saat ini

currentGen = ops(1);
maxGen     = ops(2);
done       = currentGen >= maxGen;



termOps = gen; % Generations

% Selection Function

selectFn = 'roulette'; %inisialisasi operator seleksi yaitu roulette

function[newPop] = roulette(oldPop,options)
%newPop  - populasi baru yang dipilih dari oldPop
%oldPop  - populasi saat ini
%options - options [gen]

% Dapatkan parameter populasi
numVars = size(oldPop,2);
numSols = size(oldPop,1);

% Hasilkan probabilitas seleksi relatif
totalFit = sum(oldPop(:,numVars));
prob=oldPop(:,numVars) / totalFit;
prob=cumsum(prob);

rNums=sort(rand(numSols,1));                    % Hasilkan angka acak

% Pilih individu dari oldPop ke yang baru
fitIn=1;newIn=1;
while newIn<=numSols
  if(rNums(newIn)<prob(fitIn))
    newPop(newIn,:) = oldPop(fitIn,:);
    newIn = newIn+1;
  else
    fitIn = fitIn + 1;
  end
end



selectOps = inpselectOps; % membuat variabel selectopts=koefisien seleksi

% Evaluation Function (option)
evalOps = []; %fungsi evaluasi

% Lets run the GA


[x endPop bestPop trace]=ga(bounds,evalFn,evalOps,startPop,gaOpts,...

    termFns,termOps,selectFn,selectOps,xFns,xOpts,mFns,mOpts); %menjalankan program GA.m

function [x,endPop,bPop,traceInfo] = ga(bounds,evalFN,evalOps,startPop,opts,...
termFN,termOps,selectFN,selectOps,xOverFNs,xOverOps,mutFNs,mutOps)
%   x            - solusi terbaik yang ditemukan selama perjalanan
%   endPop       - populasi terakhir
%   bPop         - jejak populasi terbaik
%   traceInfo    - matriks terbaik dan sarana ga untuk setiap generasi
%
% Input Arguments:
%   bounds       - matriks batas atas dan bawah pada variabel
%   evalFN       - nama evaluasi .m function
%   evalOps      - pilihan untuk lolos ke fungsi evaluasi ([NULL])
%   startPop     - matriks solusi yang dapat diinisialisasi
%                  from initialize.m
%   opts         - [epsilon prob_ops display] perubahan diperlukan untuk
%                       mempertimbangkan dua
%                       solusi berbeda, prob_ops 0 jika Anda ingin menerapkan
%                       operator genetik secara probabilistik untuk setiap solusi, 1 jika
%                       Anda menyediakan jumlah operator deterministik
%                       aplikasi dan tampilan adalah 1 untuk menghasilkan keluaran 0 untuk
%                       diam. ([1e-6 1 0])
%   termFN       - nama dari .m termination function (['maxGenTerm'])
%   termOps      - string opsi untuk diteruskan ke fungsi penghentian
%                  ([100]).
%   selectFN     - name of the .m selection function (['normGeomSelect'])
%   selectOpts   - string opsi yang akan dilewatkan untuk dipilih setelahnya
%                  select(pop,#,opts) ([0.08])
%   xOverFNS     - string yang berisi nama kosong dipisahkan dari Xover.m
%                  files (['arithXover heuristicXover simpleXover'])
%   xOverOps     - Sebuah matriks opsi untuk dilewatkan ke file Xover.m dengan
%                               kolom pertama adalah jumlah yang akan dilakukan xOver
%                               serupa untuk mutasi ([2 0;2 3;2 0])
%   mutFNs       - string yang berisi nama kosong dipisahkan dari mutation.m
%                  files (['boundaryMutation multiNonUnifMutation ...
%                           nonUnifMutation unifMutation'])
%   mutOps       - Sebuah matriks opsi untuk dilewatkan ke file Xover.m dengan
%                               kolom pertama adalah jumlah yang akan dilakukan xOver
%                               serupa untuk mutasi ([4 0 0;6 100 3;4 100 3;4 0 0])
n=nargin;
if n<2 | n==6 | n==10 | n==12
  disp('Insufficient arguements')
end
if n<3 % Pemilihan evalasi default.
  evalOps=[];
end
if n<5
  opts = [1e-6 1 0];
end
if isempty(opts)
  opts = [1e-6 1 0];
end
if any(evalFN<48) % Tidak menggunakan a .m file
  if opts(2)==1 % Float ga
    e1str=['x=c1; c1(xZomeLength)=', evalFN ';']; 
    e2str=['x=c2; c2(xZomeLength)=', evalFN ';']; 
  else % Biner ga
    e1str=['x=b2f(endPop(j,:),bounds,bits); endPop(j,xZomeLength)=',...
          evalFN ';'];
  end

 else % Sedang menggunakan file .m
  if opts(2)==1 %Float ga
    e1str=['[c1 c1(xZomeLength)]=' evalFN '(c1,[gen evalOps]);']; 
    e2str=['[c2 c2(xZomeLength)]=' evalFN '(c2,[gen evalOps]);']; 
  else % Biner ga
    e1str=['x=b2f(endPop(j,:),bounds,bits);[x v]=' evalFN ...
      '(x,[gen evalOps]); endPop(j,:)=[f2b(x,bounds,bits) v];']; 
  end
end

if n<6 % Informasi penghentian default
  termOps=[100];
  termFN='maxGenTerm';
end
if n<12 % Informasi mutasi default
  if opts(2)==1 %Float GA
  mutFNs=['boundaryMutation multiNonUnifMutation nonUnifMutation unifMutation'];
    mutOps=[4 0 0;6 termOps(1) 3;4 termOps(1) 3;4 0 0];
  else % GA Biner
    mutFNs=['binaryMutation'];
    mutOps=[0.05];
  end
end
if n<10 % Binary GA% Informasi crossover default
  if opts(2)==1 %Float GA
    xOverFNs=['arithXover heuristicXover simpleXover'];
    xOverOps=[2 0;2 3;2 0];
  else %Binary GA
    xOverFNs=['simpleXover'];
    xOverOps=[0.6];
  end
end
if n<9 % Pilih Default hanya memilih i.e. roullete wheel.
  selectOps=[];
end
if n<8 %Default select info
  selectFN=['normGeomSelect'];
  selectOps=[0.08];
end
if n<6 % Informasi penghentian default
  termOps=[100];
  termFN='maxGenTerm';
end
if n<4 % Tidak ada populasi awal yang diberikan
  startPop=[];
end

if isempty(startPop) % Hasilkan suatu populasi secara acak
  %startPop=zeros(80,size(bounds,1)+1);
  startPop=initializega(80,bounds,evalFN,evalOps,opts(1:2));
end

if opts(2)==0 % biner
  bits=calcbits(bounds,opts(1));
end
 xOverFNs=parse(xOverFNs);
mutFNs=parse(mutFNs);

xZomeLength  = size(startPop,2);    % Panjang dari xzome=numVars+fittness
numVar       = xZomeLength-1;                    % Jumlah variabel
popSize      = size(startPop,1);         % Jumlah individu dalam pop
endPop       = zeros(popSize,xZomeLength); % Matriks populasi sekunder
c1           = zeros(1,xZomeLength); % Seorang individu
c2           = zeros(1,xZomeLength); % Seorang individu
numXOvers    = size(xOverFNs,1); % Jumlah operator Crossover
numMuts      = size(mutFNs,1);                    % Jumlah operator Mutasi
epsilon      = opts(1);                 % Threshold untuk dua kebugaran berbeda
oval         = max(startPop(:,xZomeLength)); % Nilai terbaik di mulai pop
bFoundIn     = 1;                               % Jumlah waktu terbaik telah berubah
done         = 0;                       % Selesai dengan evolusi simulasi
gen          = 1;                                   % Nomor Generasi Saat Ini
collectTrace = (nargout>3); % Haruskah kami mengumpulkan info setiap gen
floatGA      = opts(2)==1;              % Aplikasi probabilistik ops
display      = opts(3);                 % Kemajuan tampilan

while(~done)
  %Elitist Model
  [bval,bindx] = max(startPop(:,xZomeLength)); % Terbaik dari pop saat ini
  best =  startPop(bindx,:);

  if collectTrace
    traceInfo(gen,1)=gen;                             % generasi saat ini
    traceInfo(gen,2)=startPop(bindx,xZomeLength);       %fitnes terbaik
    traceInfo(gen,3)=mean(startPop(:,xZomeLength));     %Avg fittness
    traceInfo(gen,4)=std(startPop(:,xZomeLength));
  end
  
  if ( (abs(bval - oval)>epsilon) | (gen==1)) % Jika kita memiliki sol terbaik baru
    if display
      fprintf(1,'\n%d %f\n',gen,bval);          % Perbarui layar
    end
    if floatGA
      bPop(bFoundIn,:)=[gen startPop(bindx,:)]; % Perbarui bPop Matrix
    else
      bPop(bFoundIn,:)=[gen b2f(startPop(bindx,1:numVar),bounds,bits)...
            startPop(bindx,xZomeLength)];
    end
    bFoundIn=bFoundIn+1;                      % Perbarui jumlah perubahan
    oval=bval;                                % Perbarui val terbaik
  else
    if display
      fprintf(1,'%d ',gen);                       % Atau hanya memperbarui gen num
    end
  end
  endPop = feval(selectFN,startPop,[gen selectOps]); %Select
   if floatGA % Berjalan dengan model di mana parameter adalah jumlah ops
    for i=1:numXOvers,
      for j=1:xOverOps(i,1),
            a = round(rand*(popSize-1)+1);         % Pilih orang tua
            b = round(rand*(popSize-1)+1);         % Pilih orang tua lain
            xN=deblank(xOverFNs(i,:));   % Dapatkan nama fungsi crossover
            [c1 c2] = feval(xN,endPop(a,:),endPop(b,:),bounds,[gen xOverOps(i,:)]);
           
            if c1(1:numVar)==endPop(a,(1:numVar)) % Pastikan kami membuat yang baru
              c1(xZomeLength)=endPop(a,xZomeLength); %solusi sebelum mengevaluasi
            elseif c1(1:numVar)==endPop(b,(1:numVar))
              c1(xZomeLength)=endPop(b,xZomeLength);
            else
              [c1(xZomeLength) c1] = feval(evalFN,c1,[gen evalOps]);
              eval(e1str);
            end
            if c2(1:numVar)==endPop(a,(1:numVar))
              c2(xZomeLength)=endPop(a,xZomeLength);
            elseif c2(1:numVar)==endPop(b,(1:numVar))
              c2(xZomeLength)=endPop(b,xZomeLength);
            else
              [c2(xZomeLength) c2] = feval(evalFN,c2,[gen evalOps]);
              eval(e2str);
            end     
           
            endPop(a,:)=c1;
            endPop(b,:)=c2;
      end
    end
 
    for i=1:numMuts,
      for j=1:mutOps(i,1),
            a = round(rand*(popSize-1)+1);
            c1 = feval(deblank(mutFNs(i,:)),endPop(a,:),bounds,[gen mutOps(i,:)]);
            if c1(1:numVar)==endPop(a,(1:numVar))
              c1(xZomeLength)=endPop(a,xZomeLength);
            else
              [c1(xZomeLength) c1] = feval(evalFN,c1,[gen evalOps]);
              eval(e1str);
            end
            endPop(a,:)=c1;
      end
    end
else %Kami menjalankan model operator genetik probabilistik
    for i=1:numXOvers,
      xN=deblank(xOverFNs(i,:));         % Dapatkan nama fungsi crossover
      cp=find(rand(popSize,1)<xOverOps(i,1)==1);
      if rem(size(cp,1),2) cp=cp(1:(size(cp,1)-1)); end
      cp=reshape(cp,size(cp,1)/2,2);
      for j=1:size(cp,1)
            a=cp(j,1); b=cp(j,2);
            [endPop(a,:) endPop(b,:)] = feval(xN,endPop(a,:),endPop(b,:),...
              bounds,[gen xOverOps(i,:)]);
      end
    end
 for i=1:numMuts
      mN=deblank(mutFNs(i,:));
      for j=1:popSize
          endPop(j,:) = feval(mN,endPop(j,:),bounds,[gen mutOps(i,:)]);
          eval(e1str);
      end
    end
  end
 
  gen=gen+1;
  done=feval(termFN,[gen termOps],bPop,endPop); % Lihat apakah ga selesai
  startPop=endPop;                          % Tukar populasi
 
  [bval,bindx] = min(startPop(:,xZomeLength)); % Simpan solusi terbaik
  startPop(bindx,:) = best;                 % ganti dengan yang terburuk
end

[bval,bindx] = max(startPop(:,xZomeLength));
if display
  fprintf(1,'\n%d %f\n',gen,bval);        
end

x=startPop(bindx,:);
if opts(2)==0 %binary
  x=b2f(x,bounds,bits);
  bPop(bFoundIn,:)=[gen b2f(startPop(bindx,1:numVar),bounds,bits)...
      startPop(bindx,xZomeLength)];
else
  bPop(bFoundIn,:)=[gen startPop(bindx,:)];
end

if collectTrace
  traceInfo(gen,1)=gen;                     % generasi saat ini
  traceInfo(gen,2)=startPop(bindx,xZomeLength); %fittnes terbaik
  traceInfo(gen,3)=mean(startPop(:,xZomeLength)); %Avg fittness
end

% x adalah solusi terbaik yang ditemukan
x;
% Tekan kembali untuk melanjutkan
nn=max(size(x));
for j=1:nn-1
   fprintf('\nNilai Variabel sol(%1.0f) =%8.8f\',j,x(j));
   sol(j)=x(j);
end

% jejak adalah jejak nilai terbaik dan nilai rata-rata dari generasi
jejak;
% Tekan kembali untuk melanjutkan
% jeda

% Plot yang terbaik dari waktu ke waktu
% clf
% plot (trace (:, 1), trace (:, 2));
% Tekan kembali untuk melanjutkan
%berhenti sebentar

switch lower(Jenis)
case 'posisi'
                   
% Note: 1 oz-in = 7.0615e-3 N.m          
        Ebalik=0.0708;                    
        Torsi=10.02*7.0615e-3;      
        B=9.55e-4*7.0615e-3;         
        Resistan=1.64;
        ilitan=3.39e-3;
        J=0.0108*7.0615e-3;           
     jarak=1.57;
    
     b1=(jarak*sol(4)*Torsi*sol(3));             %-(0.01*ilitan);
     b2=(jarak*sol(4)*Torsi*sol(1));            %-(0.01*Resistan);
     b3=jarak*sol(4)*Torsi*sol(2);
     
     a1=ilitan*J;
     a2=ilitan*B+Resistan*J;  
     a3=Resistan*B+sol(4)*Torsi*sol(5)+Ebalik*Torsi+sol(4)*Torsi*sol(3);
     a4=sol(4)*Torsi*sol(1);
     a5=sol(4)*Torsi*sol(2);
    
otherwise
end

num={[b1 b2 b3]};
den={[a1 a2 a3 a4 a5]};
h=tf(num,den);
             
           [Y,T]=step(h,0.2);
           plot(T,Y);
           axis([0 0.1 0 1.8])
grid on;


2.    Initializega.m
function [pop] = initializega(num, bounds, evalFN,evalOps,options)
% pop            - populasi awal, dievaluasi, acak
% populatoinSize - ukuran populasi, yaitu jumlah yang harus dibuat
% variableBounds - matriks yang berisi batasan setiap variabel, yaitu.
%                  [var1_high var1_low; var2_high var2_low; ....]
% evalFN         - evaluasi fn, biasanya nama file .m untuk Evaluasi
% evalOps        - opsi apa saja yang akan diteruskan ke default fungsi eval []
% options        - pilihan untuk fungsi inisialisasi, yaitu
%                  [type prec] di mana eps adalah nilai epsilon
%               dan opsi kedua adalah 1 untuk float dan 0 untuk biner,
%               prec adalah ketepatan default variabel [1e-6 1]


if nargin<5
  options=[1e-6 1];
end
if nargin<4
  evalOps=[];
end

if any(evalFN<48) %Not a .m file
  if options(2)==1 %Float GA
    estr=['x=pop(i,1); pop(i,xZomeLength)=', evalFN ';']; 
  else %Binary GA
    estr=['x=b2f(pop(i,:),bounds,bits); pop(i,xZomeLength)=', evalFN ';'];
  end
else %A .m file
  if options(2)==1 %Float GA
    estr=['[ pop(i,:) pop(i,xZomeLength)]=' evalFN '(pop(i,:),[0 evalOps]);'];
  else %Binary GA
    estr=['x=b2f(pop(i,:),bounds,bits);[x v]=' evalFN ...
      '(x,[0 evalOps]); pop(i,:)=[f2b(x,bounds,bits) v];']; 
    end
end


numVars     = size(bounds,1);                  %Number of variables
rng         = (bounds(:,2)-bounds(:,1))'; %The variable ranges'

if options(2)==1 %Float GA
  xZomeLength = numVars+1;                 %Length of string is numVar + fit
  pop         = zeros(num,xZomeLength);   %Allocate the new population
  pop(:,1:numVars)=(ones(num,1)*rng).*(rand(num,numVars))+...
    (ones(num,1)*bounds(:,1)');
else %Binary GA
  bits=calcbits(bounds,options(1));
  xZomeLength = sum(bits)+1;                 %Length of string is numVar + fit
  pop = round(rand(num,sum(bits)+1));
end

for i=1:num
  eval(estr);
end

3.    Parse.m
function [x] = parse(inStr)
% parse is a function which takes in a string vector of blank separated text
% and parses out the individual string items into a n item matrix, one row
% for each string.
%
% function [x] = parse(inStr)
% x     - the return matrix of strings
% inStr - the blank separated string vector

sz=size(inStr);
strLen=sz(2);
x=blanks(strLen);
wordCount=1;
last=0;
for i=1:strLen,
  if inStr(i) == ' '
    wordCount = wordCount + 1;
    x(wordCount,:)=blanks(strLen);
    last=i;
  else
    x(wordCount,i-last)=inStr(i);
  end

end
Share: