echo on
#Ostatnia modyfikacje 28-06-2011
##############################################
#
#   Prosty skrypt octave'a mobasic.m z przykladami 
#   operacji na macierzach 
#   wektorach z podstawowymi 
#   strukturami programistycznymi
#
##############################################



############################################
#
#                 WAZNE
#
#  skrypt w octavie zawiera  dowolna 
#  sekwencje komend octave'a 
#  tak jakby pisanych z linii komend ale
#  NIE MOZE ZACZYNAC SIE OD SLOWA KLUCZOWEGO 
#   function 
#
#  (gdyz, wowczas jest to tzw. plik funkcyjny 
#   czy m-plik, i pelni role funkcji )
#
############################################

#Podstawowe obiekty - macierze
#generujemy macierze w roznej postaci
#wprost ; - oddziela wiersze  
#spacja albo , kolumny 
A=[1,2;4,5;6 7]

#Mozna odwolywac sie do elementu
A(1,2)

#Mozna definiowac macierz inaczej
B=[1 2 
4 5 
6 7]
#mozna obliczac wspolrzedne za pomoca wzoru
x=[1+2, sqrt(2), 15/7]

#mozna policzyc funkcje od wektora
sin(x)
#warto dowiedzic sie jak wywolac help
# do danej funkcji np sin
#help sin
#Jak nie znamy nazwy funkcji mozemy sprobowac
#help -i sin


#mozna zmienic element macierzy
A(1,1)=-3

#czy rozszerzyc zakres
x(6)=4.56

A(1,7)=10

#mozna obejrzec jakie obiekty sa w pamieci
who
#ze szczegolami
whos
#obejrzec obiekt B
B
#usunac obiekt
clear B
#usunac wszystko 
clear 
who

#mozna wygenerowac wektor (macierz) 
#przy pomocy operatora a:h:b
#(generuje wektor o elementach 
#od a do b z krokiem h tzn.
# x(i)=a +(i-1)*h 
#dla  i=1,2,... takie ze a+i*h <=b)
#tu domyslny krok h=1
x=1:5
y=0:0.1:1
A=[1:4 ; 0 5:7; -3:0]

#Mozna popelnic blad w 
#definiowaniu macierzy - 
#wykomentowano bo jesli wystapi blad, to wykonanie 
#skryptu przez octave'a skryptu  konczy sie.
#B=[1:3 ; 1:2]

#mozna wykrawac pod-macierze
A1=A(1:2 ,  2:3)
#Jesli chcemy pod-macierz np. 
#z dwoma pierwszymi wierszami
A2=A(1:2,:)
#Mozna z macierzy budowac macierz 
#dodajemy kolumne do A2
[A2 , [1;2]]
#dodajemy wiersz do A2
[A2 ; 1:4 ]
#albo jeszcze inaczej
[A2 ; A2]
[A2,A2]
[A2 ,A2;A2,A2]

#Mozna z macierzy zbudowac 
#nowa macierz w innym formacie 
#(ale o tych samych elementach)
[m,n]=size(A2) 
# dostaniemy wymiary macierzy A2
#Budujemy wektor  o elementach z macierzy A2 
#- kolumnowo tzn
#w wektorze beda kolejne kolumny z A2
reshape(A2,m*n,1)
#i z powrotem - tu ans wynik ostatniej operacji
reshape(ans,m,n)

#Inne funkcje zmieniajace porzadek w macierzy to 
#np.:
#fliplr() odwraca kolejnosc kolumn, 
#flipud() odwraca kolejnosc wierszy,
#rot90() obraca macierz o wielokrotnosci 90 stopni
B=[1 2; 3 4]
fliplr(B)
flipud(B)
rot90(B)


#Jak widac mamy sporo mozliwosci.
#Mozna mnozyc macierze przez siebie 
#o ile wymiary sie zgadzaja:
#np. macierz przez wektor 
x=1:4

#Trzeba miec wektor pionowy 
#(macierz jednokolumnowa) 
#wiec transponujemy uzywajac "'":
x=x'
f=A*x

#Mozna mnozyc macierz przez macierz
#(o ile wymiary odpowiednie):
B= [ 1 2 ; 3 4]
C= [ 5 6 ; 1 1 ]
B*C

#Czy kazdy element pierwszej
#macierzy przez odpowiedni 
#element drugiej:
B.*C

#Czy macierz przez skalar:
2*A
#Mozna transponowac macierz kwadratowa:
B=A'

#Mozna policzyc norme euklidesowa
#tzn. druga wektora:
norm(x,2) 
#Czy pierwsza albo supremum:
norm(x,1)
norm(x,'inf') 
#Czasami nie warto wypisywac wszystkiego
#na ekranie - srednik ';' po komendzie 
#to zapewni:
y=A*x;
norm(y,2)


#mozna wygenerowac identycznosc
I=eye(10)
#czy slynne macierze
H=hilb(10); #macierz Hilberta



#mozna przeniesc dlugie wyrazenia
y=[1,2,3, ...
5 6 7]


#I mozna zapisac niektore obiekty w pliku.
#Najpierw zobaczmy co mamy w pamieci 
#sesji

who

#Mozna zapisac w pliku binarnym wszystkie
#zmienne 
#(nie mozna obejrzec  danych poza octavem)
save -binary dane.bin

clear

who

load dane.bin
# Czy pojawil sie znowu y? Sprawdzamy:
who

#Zapisujemy konkretna macierz w pliku tekstowym 
#o danej nazwie  dane.txt:
save -ascii dane.txt y

#Mozna teraz obejrzec ten plik 
#w jakims edytorze 
#lub przy pomocy programu  more
#z linii komend: np.: more dane.dat

#Czyscimy zmienne z pamieci:
clear 
#Sprawdzamy teraz zmienne w pamieci: 
who
#Wczytujemy zmienne z pliku: 
load dane.txt 

#Powinnien pojawic sie wektor y ale pod jaka nazwa?
who

#Octave wczytal macierz pod nazwa 'dane',
#ale mozna zmienic nazwe np.:
y=dane
clear dane

#W octavie mozna uzywac podstawowych obiektow
#takich jak  petle:
#while(warunek) 
#
#  komendy 
#
#endwhile
#Przyklad uzycia:
k=0;
while (k<3)
k++; #k=k+1;
endwhile
k
#Kolejna petla to:
#do 
#
#   komendy 
#
#until( warunek )

#Petla ta zawsze przynajmniej 
#raz sie wykona.
#Przyklad:
k=0;
do 
k++;
until(k>3);
k
#Trzecia petla to:
#for i= wektor wartosci 
#
#  komendy 
#
#endfor
#Przyklad:
a=0;
for k=1:4,
 a+=k; #a=a+k;
endfor
a
#Istnieja tez inne podstawowe 
#struktury programistyczne jak:
#Intrukcja warunkowe 
#if
#
# komendy
#
#else (opcja)
#
# komendy
#
#endif 
#Przyklad:
k=input("podaj wartosc k=?\n"); 
#teraz czeka na input
if(k<10)
 disp("k<10"); #disp wyswietla string na ekranie
else 
  disp("k >=10");
endif

#Tu warto poznac operatory logiczne octave'a
#ogolnie wartosc rozna od zera jest uznawana za prawde 
#zero za nieprawde
if(2)
 a=3
else 
 a=1;
endif
#&& - AND logiczne "i"
i=0;
(i<=10)&&(i>-10)
(i<10)&&(i>1)
(i<-1)&&(i>1)
#||- OR logiczne "lub"
(i<10)||(i>-10)
(i<10)||(i>1)
(i<-1)||(i>1)
#! - negacja (opcjonalnie ~)
!(i>0)
!(i<=0)
#operator rownosci - nie-bycia rownym jak w C
# = ta sam wartosc; !=  rozna wartosc
(5==4) 
(5==(3+2))
(5!=6)
(5!=(3+2))


#Kolejna struktura warta poznania
#to instrukcja switch (troche inna niz w C/C++)
#switch(zmienna)
# case {wartosci zmiennej}
#   komendy
#
# case {wartosci zmiennej}
#   komendy
#
#otherwise
#
#   komendy
#
#endswitch
#Przyklad:
taknie=menu("test switch","yes","no","do not know");
# menu wygodna funkcja  gdy oczekujemy wybrania opcji
switch(taknie)
 case {1} 
  disp("yes");
 case {2}
  disp("no");
 case {3}
  disp("don't know");
endswitch
#inna instrukcja na wprowadzanie danych z klawiatury to 
#kbhit

#funkcje
#najprostsza
function y=f(x)
  y=x+sin(x);
endfunction
#wywolujemy
f(0)
f(1)
#funkcja anonimowa 
f=@(x) 1+x+sin(x)
#Formalnie f tu jest 
#uchwytem do funkcji ale 
#wywolanie jest takie same:
#Wywolujemy:
f(0)

#prosta grafika
#siatka rownomierna na [0,3]
x=linspace(0,3);
#wektorowo wartosci sin na siatce
y=sin(x);
#i cos
z=cos(x);
#najprostszy wykres
plot(y);
pause(1);
#pause - aby nie zniknelo od razu

#Plot rysuje wykres 
#wartosci y wzgledem indeksow
#Lepiej narysowac wykres y 
#wzgledem punktow siatki:
plot(x,y);
pause(1);

#Mozemy zamiescic 
#dwa wykresy na jednym rysunku
plot(x,y,x,z);
pause(2);

#Mozemy wykres podpisac
plot(x,y,";sin;",x,z,";cos;");
pause(2);

#I mozemy ustalic kolor wykresu:
plot(x,y,"k;sin;",x,z,"g;cos;");
pause(2);
#Oczywiscie kolory sa w jezyku angielskim
#r - red; b - blue; k - black; g - green
#m - magenta; c - cyan; w - white

#Czy zmienic styl wykresy - 
#zaznaczymy punkt przeciecia przez czerwony plus:
zx=pi/4;zy=cos(pi/4);
plot(x,y,"k;sin;",x,z,"g;cos;",zx,zy,"r+;pkt przec.;");
pause(2);

#i to tyle podstawowych rzeczy ktore trzeba 
#wiedziec o macierzach i octavie
#(i ktore przyszly mi do glowy)
echo off



