Imię ..........Piotr
Nazwisko ........Lewicki
Wiek ..
Wzrost 72.4409449 inch
Waga ...2574.9728 oz
Narodowość .........Polska

01-02-2011

Smok na maturze z informatyki 2009 – Smok Heighwaya – fraktal java

Filed under: Java — Tagi: , , , — Levik @ 13:39

No i tak przyszło mi w 2009 roku pisać maturę rozszerzoną z informatyki. Zadania były jak pamiętam bardzo trudne. Wczoraj za sprawą komentarza Kamila do poprzedniego posta, wróciłem pamięcią do arkusza z przed 2 lat i smok nie wydał się taki trudny jak kiedyś :-)

Na wiki smok Heighwaya jest definiowany na płaszczyźnie zespolonej, ale w arkuszu dla maturzystów nikt by na to nie poszedł. Pomimo tego idea generowania smoka jest dość ciekawa. Pojawiają się w niej liczby pseudolosowe, co nadaje ciekawego kolorytu sprawie. No ale w matematyce raczej nie ma przypadku… Nie będę wysilał się na uczoną polemikę po prostu wklejam poniżej polecenie:

Zadanie 4. Iteracje (14 pkt)
Poniższe dwa układy równań liniowych, zastosowane wielokrotnie do przekształcania
współrzędnych punktu (x, y) (przynajmniej kilka tysięcy razy) na przemian, w losowej
kolejności, generują ciekawy obraz, znany jako smok Heighwaya. Zmienne x′ i y′ oznaczają
nowe wartości współrzędnych x i y.

Do wygenerowania obrazu smoka Heighwaya może posłużyć następujący algorytm:

1. Przyjmij dowolne wartości początkowe x i y.
2. Powtórz wielokrotnie (przynajmniej kilka tysięcy razy):
2.1. Oblicz nowe wartości x i y:

  • wybierz losowo z jednakowym prawdopodobieństwem jeden z dwóch podanych układów równań,
  • oblicz x′ i y′ , stosując wybrany układ równań.

2.2. Zaznacz na wykresie kolejny punkt (x, y).

Wykorzystując dostępne narzędzia informatyczne, wykonaj poniższe polecenia. Wyniki z podpunktów a, c, d zapisz w pliku o nazwie zad_4.txt. Wyniki do każdego podpunktu poprzedź literą oznaczającą ten podpunkt.

a) Zaczynając od x = 1 i y = 1 i wybierając za każdym razem losowo jeden z dwóch
podanych układów równań, oblicz pierwsze 5000 wartości x i y z kolejnych iteracji.

b) Na podstawie swoich obliczeń sporządź obraz smoka Heighwaya. Pomiń wyniki
ze 100 pierwszych iteracji. Zadbaj o czytelność i przejrzystość obrazu. Otrzymany
obraz zapisz w pliku o nazwie smok.*, w którym * oznacza rozszerzenie pliku zgodne
z wybranym przez Ciebie formatem pliku użytym do zapamiętania obrazu.

c) Oblicz środek masy smoka, to znaczy: średnie wartości x i y z zaokrągleniem
do jednej cyfry dziesiętnej po przecinku. Przy obliczaniu średnich pomiń wyniki
ze 100 pierwszych iteracji.

d) Oblicz rozmiary powstałego smoka, to znaczy podaj (z zaokrągleniem do jednej cyfry
dziesiętnej po przecinku) minimalne i maksymalne wartości x oraz y. Pomiń wyniki
uzyskane w pierwszych 100 iteracjach obliczeń.

Nie chciało mi się walczyć z  nudnymi podpunktami po prostu skupiłem się na narysowaniu smoka :-) 





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import javax.swing.JApplet;
import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
 
public class Dragon extends JApplet {
 
	JButton generate = new JButton("Generuj");
	DragonImage panel = new DragonImage();
	ArrayList<Pixel> pixelList = new ArrayList<Pixel>();
	JTextField textField = new JTextField();
	JTextField xCor = new JTextField();
	JTextField yCor = new JTextField();
	JLabel iterLab = new JLabel("Iteracje: ");
	JLabel xLab = new JLabel("x: ");
	JLabel yLab = new JLabel("y: ");
	JLabel zoomLab = new JLabel("zoom: ");
	double x,y;
	JSlider zoomSlider = new JSlider();
	int zoom=100;
 
	public void init(){
		try {
			SwingUtilities.invokeAndWait(new Runnable() {
				public void run() {
					setLayout(null);
					setSize(650, 410);
 
					iterLab.setBounds(418,40,50,20);
					add(iterLab);		
					xLab.setBounds(455,70,50,20);
					add(xLab);
					yLab.setBounds(455,100,50,20);
					add(yLab);
					zoomLab.setBounds(430,130,80,20);
					add(zoomLab);
 
					textField.setBounds(470,40,75,25);
					add(textField);
					xCor.setBounds(470,70,35,25);
					add(xCor);
					yCor.setBounds(470,100,35,25);
					add(yCor);
					generate.setBounds(470, 10, 100, 25);
					generate.addActionListener(new GenButtonListener());
					add(generate);
 
					zoomSlider = new JSlider(1, 1000,100);
					zoomSlider.setBounds(430, 150, 200, 20);
					add(zoomSlider);
					zoomSlider.addChangeListener(new ZoomSliderListener());
 
					add(panel);
					panel.setBounds(5, 5, 400, 400);
					panel.setBackground(Color.white);
					panel.repaint();
				}
			});
		} catch(Exception e){
			JOptionPane.showMessageDialog(null,e.toString(),"Błąd",JOptionPane.ERROR_MESSAGE);
		}
	}
 
	class ZoomSliderListener implements ChangeListener {
		public void stateChanged(ChangeEvent arg0) {
			zoom = zoomSlider.getValue();
			zoomLab.setText("zoom: "+zoom);
			panel.repaint();
		}
	}
 
	class GenButtonListener implements ActionListener{
		public void actionPerformed(ActionEvent arg0) {
			if(xCor.getText().equals("") || yCor.getText().equals("") || textField.getText().equals("") || Integer.parseInt(textField.getText())<100){
				JOptionPane.showMessageDialog(null,"iteracje > 100"+'\n'+"x,y dowolne","Błąd - błędne dane wejściowe",JOptionPane.ERROR_MESSAGE);
			}else{
				int option=0;
				double xp=0,yp=0;
				x = Double.parseDouble(xCor.getText());
				y = Double.parseDouble(yCor.getText());
 
				pixelList.clear();
 
				for(int i=0;i<Integer.parseInt(textField.getText());i++){
					option = (int)Math.round(Math.random());
					if(option==1){
						xp=-0.4*x-1;
						yp=-0.4*y+0.1;
						pixelList.add(new Pixel(xp, yp));
						x=xp;
						y=yp;
					}else{
						xp=0.76*x-0.4*y;
						yp=0.4*x+0.76*y;
						pixelList.add(new Pixel(xp, yp));
						x=xp;
						y=yp;
					}
				}
				for(int i=0;i<100;i++)
					pixelList.remove(0);
 
				panel.repaint();
			}
		}
 
	}
 
	class DragonImage extends JPanel {
 
		public void paint(Graphics g){
			super.paint(g);
			int dx = panel.getWidth()/2;
			int dy = panel.getHeight()/2;
 
			g.setColor(Color.white);
			g.fillRect(0, 0, 300, 300);
 
			g.setColor(Color.LIGHT_GRAY);
			for(int i=1;i<8;i++)
				g.drawLine(50*i, 0, 50*i, 450);
			for(int i=1;i<8;i++)
				g.drawLine(0, 50*i, 450, 50*i);
 
			g.setColor(Color.red);
			for(Pixel pixel:pixelList){
				g.fillRect((int)(pixel.x*zoom)+dx, (int)(pixel.y*zoom)+dy, 1, 1);
			}
		}
	}
 
	class Pixel {
		double x,y;
 
		Pixel(double X,double Y){
			x=X; y=Y;
		}
 
		public void set(double X,double Y){
			x=X; y=Y;
		}
	}
}

Pozdrawiam!!! Piter!

29-01-2011

Niekończąca się opowieść czyli o fraktalach słów kilka – Dywan Sierpińskiego

Filed under: Java — Tagi: , , , — Levik @ 15:24

Podczas zajęć z Algorytmów i struktur danych, prowadzący zaproponował nam zadanie dodatkowe. Mianowicie dotyczyło ono wygenerowanie fraktali. (Zbiory Mandelbrota i L-systemy). Jak to często w moim przypadku bywa skończyło się na poczytaniu tego i owego. Musiałem dopilnować innych zajęć i nie znalazłem czasu na zabawę z fraktalami. Nie mniej jednak temat jest szalenie ciekawy, a i programowanie tego typu zadań sprawia dużo frajdy. Wszelakie wizualne zmiany na ekranie komputera, bądź generowanie obrazów za sprawą kodu programu jest niezłą zabawą, zwłaszcza że kryje się za tym czysta matematyka. To tak jakby ubrać w słowa jakąś wybitną myśl. Ja „ubrałem w słowa” dywan Sierpińskiego. Jest to chyba najprostszy fraktal. Jak widać wrzuciłem applet na blog. Znalazłem też fajną stronę o fraktalach. Oto link: Fraktale

Zachęcam do poczytania na ten temat…



17-12-2010

Język multi-paradygmatowy Oz – przykłady Mozart/Oz

Filed under: Funkcyjne — Tagi: , — Levik @ 22:26

Przyszło mi się zmierzyć z nowym paradygmatem programowania, mianowicie programowaniem funkcyjnym. Od kilku lat zajmuje się programowaniem. Na początku pisałem imperatywnie, później obiektowo, ale nigdy nie funkcyjnie. Przyznam, że musiałem zmienić odrobinę spojrzenie na kod i samo programowanie. Jednak po krótkiej, ale jakże ciekawej batalii stoczonej na płaszczyźnie mojej klawiatury muszę powiedzieć, że udało się. Jednak spokojna głowa ten paradygmat nie trafi do mojego TOP 3.

Na zajęciach piszemy w języku OCaml i Oz (o pierwszym z nich napiszę później). Teraz skupmy się na języku Oz. Jest to język multi-paradygmatowy, czyli wspomaga kilka paradygmatów. W tym przypadku są jest to:

1. Programowanie w logice
2. Programowanie funkcyjne
3. Programowanie imperatywne
4. Programowanie obiektowe
5. Programowanie deklaratywne

Początki Oz’a sięgają 1991 roku jak to często bywa stworzył go student. Od 1996 roku pieczę nad projektem ma konsorcjum Mozart (często możemy zauważyć w sieci pisownię Oz/Mozart). Projekt jest udostępniany na licencji open source. Składnia języka na początku wydała mi się dość przyjemna, ale z czasem dała ostro popalić. Z języka korzystałem tylko do celów edukacyjnych dlatego nie jestem wstanie powiedzieć wam nic nowego czego nie przeczytacie w dokumentacji i tutorialu (ahhh to co tygryski lubią najbardziej)

Jako, że w internecie jest bardzo mało przykładów związanych z językiem Oz postanowiłem to zmienić. Oto kilka prostych programów.

Funkcja Rev (reverse – przyjmuje jako argument listę) odwracająca listę (rekursja ogonowa).

1
2
3
4
5
6
7
8
9
10

declare fun {Rev L}
	   local fun {Pom L Acc}
		    case L of
		       nil then Acc
		    [] H|T then {Pom T H|Acc}
		    end
		 end
	   in {Pom L nil}
	   end
	end

Funkcja Length która zwraca długość listy przyjętej jako argument.

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

declare fun {Length Lst}
	   local fun {Length_acm Lst Acm}
	      if Lst==nil then Acm
	      else {Length_acm Lst.2 Acm+1}
	      end
	   end
	   in {Length_acm Lst 0}
	   end
	end
 
%przykładowa tablica
declare L = 1|2|3|4|5|nil
 
%wydrukowanie wyniku
{Show {Length L}}

Dalej przedstawię zadania z list ćwiczeń, które to rozwiązywałem na zajęciach, niestety nie wszystkie zadania są optymalne obliczeniowo, wiele z nich można usprawnić:

1. Zdefiniuj funkcję Flatten1, która dla argumentu będącego listą list tworzy listę złożoną z elementów wszystkich podlist z zachowaniem ich kolejności, np. {Flatten1 [[5 6] [1 2 3]]} zwraca [5 6 1 2 3], czyli spłaszcza listę o jeden poziom.

1
2
3
4
5
6
7
8
9
10
11

declare fun {Flatten1 L}
	   if L==nil then
	      nil
	   else
	      {Append L.1{Flatten1 L.2}}
	   end
end
 
declare Lst = [[5 6 1 2 3] nil [3 4 3] [3]]
 
{Show {Flatten1 Lst}}

2. Zdefiniuj funkcję Count obliczającą ile razy dany obiekt występuje w danej liście, np. {Count ‘a’ ['a' 'l' 'a']} zwraca 2.

1
2
3
4
5
6
7
8
9
10

declare fun {Count Z Lst}
	   if Lst==nil then 0
	   else
	      if Z==Lst.1 then 1+{Count Z Lst.2}
	      else 0+{Count Z Lst.2}
	      end
	   end
end
 
{Show {Count 'a' a|b|a|b|a|b|nil}}

3. Zdefiniuj funkcję Duplicate powtarzającą dany obiekt określoną liczbę razy i zwracającą wynik w postaci listy, np. {Duplicate ‘la‘ 3} →['la' 'la' 'la'].

1
2
3
4
5
6
7

declare fun {Duplicate O N}
	   if N==0 then nil
	    else O|{Duplicate O N-1}
	   end
	end
 
{Show {Duplicate 'a' 6}}

4. Zdefiniuj funkcję Sqr_list podnoszącą do kwadratu wszystkie elementy danej listy liczb, np. {Sqr_list [1 2 ~3]} → [1 4 9].

1
2
3
4
5
6
7
8
9
10

declare fun {Sqr_list Lst}
	   if Lst==nil then nil
	   else
	      Lst.1*Lst.1|{Sqr_list Lst.2}
	   end
	end
 
declare L = 3|4|nil
 
{Show {Sqr_list L}}

5. Zdefiniuj funkcję Palindrome sprawdzającą, czy dana lista jest palindromem, tj. równa się sobie samej przy odwróconej kolejności elementów, np. {Palindrome ['a' 'l' 'a']} zwraca true.

1
2
3
4
5
6
7
8
9
10

declare fun {Palindrome Lst}
	   if Lst==nil then nil
	   else
	      Lst=={Reverse Lst}
	   end
end
 
declare L = k|a|j|a|k|nil
 
{Show {Palindrome L}}

6. Zdefiniuj funkcję ListLength obliczjącą długość dowolnej listy.

1
2
3
4
5
6
7
8
9
10

declare fun {ListLength Lst}
	   if Lst==nil then 0
	   else
	      1+{ListLength Lst.2}
	   end
	end
 
declare L = 1|2|3|4|nil
 
{Show {ListLength L}}

7. Liczby Fibonacciego są zdefiniowane następująco:
f(0) = 0
f(1) = 1
f(n+2) = f(n) + f(n+1)
Napisz dwie funkcje, które dla danego n znajdują n-tą liczbę Fibonacciego: pierwszą opartą bezpośrednio na powyższej definicji i drugą, wykorzystującą rekursję ogonową. Porównaj ich szybkość wykonania, obliczając np. 37-mą liczbę Fibonacciego.

1
2
3
4
5
6
7
8
9

declare fun {Fib N}
	    if N==0 then 0
	    else
	       if N==1 then 1
	       else {Fib N-1}+{Fib N-2}
	       end
	    end
	 end
{Show {Fib 37}}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

declare fun { Fib_tail N}
	   local fun {Fib N1 N2 I}
		    if I=&lt;2 then N2
		    else
		       local Next = N1+N2 in
			  {Fib N2 Next I-1}
		       end
		    end
		 end
	   in {Fib 1 1 N}
	   end
	end
 
{Show {Fib_tail 37}}

8. Zdefiniuj funkcję Initsegment : ‘a list * ‘a list -> bool sprawdzającą w czasie liniowym, czy pierwsza lista stanowi początkowy segment drugiej listy. Każda lista jest swoim początkowym segmentem, lista pusta jest początkowym segmentem każdej listy.

1
2
3
4
5
6
7
8
9
10
11

declare fun {Initsegment L1 L2}
	   case L1 of
	      nil then true
	   [] H|T then
	               if H==L2.1 then {Initsegment T L2.2}
		       else false
		       end
	   end
	end
 
{Show {Initsegment 2|3|nil 1|2|3|4|nil}}

OK myślę, że na razie te kila przykładów wystarczy, mam w zanadrzu jeszcze kilka mini-programików, myślę że z czasem je udostępnię. Jak sami widzicie jestem jeszcze dość zielony w paradygmacie funkcyjnym, ale powoli nabieram zrozumienia wobec tej „filozofii”. Mam szczerą nadzieję, że analiza tych kilku programów pozwoli wam szybciej oswoić się z nowym językiem, a przede wszystkim paradygmatem.

Pozdrawiam PL

30-06-2010

Binary search – wyszukiwanie binarne – język java

Filed under: Java — Tagi: , , , — Levik @ 11:59

Ja na pierwszym roku studiów musiałem chyba około 3 razy napisać wyszukiwanie binarne na różnego rodzaju laboratoriach poczynając od podstawach programowania, a kończąc na Algorytmach i strukturach danych. Także myślę, że ktoś może z tego przykładu skorzystać. Dodam tylko, że wyszukiwanie binarne można rozwiązać w sposób rekurencyjny. Dość naturalny do wyobrażenia w tym przypadku. Kod poniżej prezentuje właśnie to podejście.

Co do samego algorytmu jak zawsze nie będę się przemęczał (nie dlatego, że mi się nie chce, ale inni opisali go już setki razy)

Wyszukiwanie binarne



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class BinarySearch {
 
	public static int tab[] = {3,5,12,20,28,34,38,41,55,67,71,78,81,85,94,99,102};
 
	//funkcja zwraca indeks elementu, jeśli go nie ma zwróci -1
	public static int binSearch(int find,int left,int right){
		//System.out.println("Szukam "+find+" lewy: "+left+" a prawy: "+right);
		int index=(left+right)/2;
 
		if(tab[index]==find){
 
			return index;
 
		} else {
 
			if(left>right){
 
				//System.out.println("Nie ma takiej liczby!");
				return -1;
 
			} else {
 
				if(tab[index]<find){
 
					return binSearch(find,index+1,right);
 
				} else {
 
					return binSearch(find,left,index-1);
				}
			}
		}
	}
 
	public static void main(String[] args){
		System.out.println(binSearch(67,0,16));
	}
 
}

Pozdrawiam Piotr!!!

28-06-2010

Sortowanie przez kopcowanie – Kopiec zupełny – HeapSort – Java

Filed under: Java — Tagi: , , — Levik @ 17:00

Hej, dzisiaj zaliczyłem ostatni przedmiot, kurs. Także sesja GAME OVER czytaj. „Mission Accomplished”. Tekst rodem z RED ALERT.

sesja zaliczona

Zapewne wrzucę jeszcze kilka swoich kodów na stronkę. Dzisiaj sortowanie przez kopcowanie zaimplementowane obiektowo. Struktura kopca zupełnego znajduje się w pliku heap.java, a jego przykładowe zastosowanie (tutaj sortowanie) w pliku test.java.

Oto kod:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//********************************
//wierzchołek   1
//lewy potomek  2*i
//prawy potomek 2*i+1
//********************************
public class Heap {
 
	private int tab[];
	private int size = 0;
 
	public Heap(int size){
		tab = new int[size+1];
	}
 
	public void insert(int val){
		tab[++size]=val;
		up();
	}
 
	public void up(){
		int temp=tab[size];
		int n=size;
 
		while( (n!=1) && (tab[n/2]<=temp) ){
			tab[n] = tab[n/2];
			n=n/2;
		}
		tab[n]=temp;
	}
 
	public int getFirst(){
		int temp=tab[1];
		tab[1]=tab[size--];
		down();
		return temp;
	}
 
	public void down(){
		int i=1;
		while(true){
			int pos=2*i;
 
			if(pos>size)
				break;
 
			if(pos+1<=size)
				if(tab[pos]<tab[pos+1])
					pos++;
 
			if(tab[i]>=tab[pos])
				break;
 
			int temp = tab[pos];
			tab[pos]=tab[i];
			tab[i]=temp;
 
			i=pos;
		}
	}
}

…a teraz kod przykładu…

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

public class Test {
 
	public static void main(String[] args){
		int tab[] = {32,43,2,46,23,1,0,-34,54,230};
 
		Heap heap = new Heap(10);
 
		for(int i=0;i<tab.length;i++)
			heap.insert(tab[i]);
 
		for(int i=tab.length;i>0;i--)
			tab[i-1]=heap.getFirst();
 
		System.out.println("Tablica posortowana");
 
		for(int i=0;i<tab.length;i++)
			System.out.println(tab[i]);
	}
 
}

28-05-2010

Assembler – MIPS – Mnożenie macierzy

Filed under: Security — Tagi: , , — Levik @ 17:02

Hej, oto kod prezentujący mnożenie macierzy, na studiach w ramach kursu Architektura systemów komputerowych kodzimy w asemblerze. Na warsztacie mamy mikroporcesor MIPS:

[...]MIPS (Microprocessor without Interlocked Piped Stages) jest to architektura komputerowa (w szczególności procesor typu RISC) rozwijana przez firmę MIPS Technologies. Istnieje zarówno w wersji 32- jak i 64-bitowej.[...]

Procek ten jest 2 na liście najczęściej wykorzystywanych procesorów, a to za sprawą jego komercyjnego sukcesu, chociaż nie tylko. Można go spotkać np. w PSP, albo PS2. =)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101

###################################################
#
# Krótkie omówienie: 
# Program mnoży macierze. Poniżej mały przykład, aby zobrazowac ideę zapisu macierzy jako 
# tablicy w asm. (wiersz po wierszu). Należy również podać wymiary macierzy.
#
###################################################
#            ASCII ART <^_^>
#
#	A.       B.		   C.
#	| 1 0 2| |3 1|     |5 1|
#	|-1 3 1| |2 1|  =  |4 2|
#	         |1 0|
#
 
.data
	macierzA: .byte 1,0,2,-1,3,1											
	macierzB: .byte 3,1,2,1,1,0
 
	newLine:  .asciiz "\n"
	spacja :  .asciiz " "
	wynik  :  .asciiz "macierz C:\n"
.text
main:
 
############# WYMIARY MACIERZY ###########
	li $s0,2	# wiersze macierzy A	
	li $s1,3	# kolumny macierzy A	
 
	li $s2,3	# wiersze macierzy B	
	li $s3,2	# kolumny macierzy B	
##########################################
 
	bne $s1,$s2,koniec # aby pomnożyć macierze liczba kolumn macierzy A. musi być równa liczbie wierszy macierzy B. 
 
	move $s4,$s0	   # wiersze macierzy C
	move $s5,$s3	   # kolumny macierzy C
 
	la $t8,macierzA
	la $t9,macierzB
 
	li $v0,4
	la $a0,wynik
	syscall
 
	li $t0,0          # inicjalizacja liczniaka petli
for1:
 
	li $t1,0	   # inicjalizacja liczniaka petli	
	for2:
 
		move $a0,$t8
		move $a1,$t9
 
		jal mnozenie   # wywołanie procedury mnozenie jej kod zostal zaczerpniety z poprzedniego cwiczenia
 
		li $v0,1
		move $a0,$t6
		syscall
 
		li $v0,4
		la $a0,spacja
		syscall
 
		add $t9,$t9,1 # dodajemy jeden aby przejsc na następną kolumne
 
		add $t1,$t1,1
		bne $t1,$s3,for2
 
	li $v0,4
	la $a0,newLine
	syscall
 
	la $t9,macierzB    # ponownie ustawiamy adres macierzy B
	add $t8,$t8,$s1    # dodajemy do adresu liczbę kolumn macierzy a aby przejsc do nastepnego wiersza
 
	add $t0,$t0,1
	bne $t0,$s0,for1
 
koniec:
	li $v0,10
	syscall
 
mnozenie:
	li $t3,0 #licznik petli
	li $t6,0 #wynik
 
for3:
	lb $t4,0($a0)
	lb $t5,0($a1)
 
	mul $t4,$t4,$t5        # mnożenie składowych
	add $t6,$t6,$t4	  # sumowanie wyniku
 
	add $a0,$a0,1	         # przesuwamy sie na nastepny element macierzy A
	add $a1,$a1,$s3	  # przesuwamy sie na nastepny element macierzy B	
 
	add $t3,$t3,1
	bne $s1,$t3,for3
 
jr $ra

Pozdrawiam Levik

- by levik@wp.pl L3VIK -

Jesteś gościem numer - Twój adres IP to: 38.107.179.211