echo on
#Ostatnia modyfikacje 5-10-2009
#######################################################################
#
#  Prosty skrypt octave'a z przykladami operacji na macierzach wektorach
#  z podstawowymi strukturami programistycznymi
#
#######################################################################



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

#Podstawowye 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 wiedzic tak przy kazji jak wywolac help do danej funkcji np sin
#help sin
#jak nie znamy nazwy funkcji mozna sprobowac
#help -i sin


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

#czy rozszerzyc zakres
x(6)=4.56

#trzeba uwazac z macierzami 
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]
#ale mozna popelnic blad w defniowaniu macierzy - wykomentowano bo jak 
#jest blad to wykonanie przez octave'a skryptu sie konczy
#B=[1:3 ; 1:2]

#mozna wykrawac podmacierze
A1=A(1:2 ,  2:3)
#latwo jak chcemy podmacierz np z 2 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 samch elelmentach)
[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
#flipr() odwraca kolejnosc kolumn, flipud() odwraca kolejnosc wierszy,rot90() obraca #macierz o wielokrotnosci 90 stopni itd

#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 '
x=x'
f=A*x
#Mozna mnozyc macierz przez macierz(o ile wymiary odp owiednie)
B= [ 1 2 ; 3 4]
C= [ 5 6 ; 1 1 ]
B*C
#Czy kazdy element przez odpowiedni kazdy
B.*C
#Czy macierz przez skalar
2*A
#mozna transponowac macierz kwadratowa
B=A'
# przypominamy f=A*x; prawa strona (znamy rozwiazanie)
sol=A\f;
#Czy wyszedl dokladny wynik?
blad=sol -x
#mozna policzyc norme bledu euklidesowa tzn druga
norm(blad,2) 
#czy pierwsza albo supremum
norm(blad,1)
norm(blad,'inf') 
#Czasami nie warto wypisywac wszystkeigo na ekranie srednik po komendzie 
#to zapewni
#liczymy blad residualny w normie wektorowej
#(octave oblicza trez normy macierzowe)
blres=A*sol -f;
norm(blres,2)

#Mozna obliczy uwarunkowanie macierzy
cond(A)
#mozna wygenerowac identycznosc
I=eye(10)
#czy slynne zle uwarunkowane macierze
H=hilb(10); #macierz Hilberta
cond(H)
cond(I)

# i macierz odwrotna np
Hinv=inv(H);
#Czy wyszedl dobry wynik?
norm(H*Hinv-I,2)
#nie wyszlo najlepiej mimo ze w sumie wymiar nie taki duzy
#Sprawdzmy czy lepiej rozwiazac uklad rownan Hx=f rozwiazujac 
#metoda OCtave (rozklad LU) czy mnozyc przez macierz odwrotna
sol=1:10; 
sol=sol'; 
f=H*sol;
x=H\f;
y=Hinv*f;
#Jak rozwiazujemy poprzez rozklad LU
norm(x-sol,2)
#jak mnozymy przez macierz odwrotna
norm(y-sol,2)
clear
#co wiecej?

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


#I mozna zapisac niektore obiekty w pliku
#wpierw zobaczmy co mamy
who
#mozna zapisac w pliku binarnym wszystko (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 
save -ascii dane.txt y
#mozna teraz obejrzec sobie w jakims edytorze czy more ten plik
#z linii komend more dane.dat
#czyscimy
clear 
#sprawdzamy co mamy 
who
#wczytujemy 
load dane.txt 
#powinnien pojawic sie wektor y ale pod jaka nazwa?
who
# wczytal macierz pod nazwa dane
#ale mozna zmienic nazwe np
y=dane
clear dane

#mamy w octavie podstawowe obiekty jak petle
#while(warunek) komendy endwhile
k=0;
while (k<3)
k++; #k=k+1;
endwhile
k
#do komendy until( warunek ) - przynjamniej raz sie wykona
k=0;
do 
k++;
until(k>3);
k
#petla for i= wektor wartosci komendy endfor
a=0;
for k=1:4,
 a+=k; #a=a+k;
endfor
a
#intrukcje warunkowe if 
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
#instrukcja switch (troche inna niz w C/C++)
taknie=menu("test switch","yes","no","do not know");# menu wgodne 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
#i to tyle podstawowych rzeczy ktore trzeba wiedziec o macierzach i octavie
#(i ktore przyszly mi do glowy)



