Informatyka 1 - PB Wydział Elektryczny

Transkrypt

Informatyka 1, studia niestacjonarne I stopnia
Rok akademicki 2014/2015, Wykład nr 9
dr inż. Jarosław Forenc
2/60
Plan wykładu nr 9
Algorytmy komputerowe
Informatyka 1
sposoby opisu - przykłady
Rekurencja
Złożoność obliczeniowa
Sortowanie
Politechnika Białostocka - Wydział Elektryczny
proste wstawianie
Elektrotechnika, semestr II, studia niestacjonarne I stopnia
proste wybieranie
Rok akademicki 2014/2015
bąbelkowe
Quick-Sort
Mnożenie macierzy
Wykład nr 9 (12.06.2015)
3/60
Algorytm Euklidesa - lista kroków
Algorytm Euklidesa - największy wspólny dzielnik dwóch liczb
Dane wejściowe: niezerowe liczby naturalne a i b
4/60
Algorytm Euklidesa - przykład
NWD(1675,3752) = ?
a
b
Dane wyjściowe: NWD(a,b)
1675
3752
b/a = 3752/1675 = 2 reszta 402
b = 402
Kolejne kroki:
1675
402
a/b = 1675/402 = 4 reszta 67
a = 67
1. Czytaj liczby a i b
67
402
b/a = 402/67 = 6 reszta 0
b=0
2. Dopóki a i b są większe od zera, powtarzaj krok 3, a następnie
przejdź do kroku 4
67
0
3. Jeśli a jest większe od b, to weź za a resztę z dzielenia a przez b,
w przeciwnym razie weź za b resztę z dzielenia b przez a
4. Przyjmij jako największy wspólny dzielnik tę z liczb a i b,
która pozostała większa od zera
5. Drukuj NWD(a,b)
Dzielenie większej liczby przez mniejszą
KONIEC
NWD(1675,3752) = 67
Zamiana
5/60
Algorytm Euklidesa - schemat blokowy
6/60
Algorytm Euklidesa - pseudokod
NWD(a,b)
while a>0 i b>0
do if a>b
then a ← a mod b
else b ← b mod a
if a>0
then return a
else return b
Algorytm Euklidesa - język programowania (C)
7/60
8/60
Metoda CG - schemat blokowy
START
int NWD(int a, int b)
{
while (a>0 && b>0)
if (a>b)
a = a % b;
else
b = b % a;
if (a>0)
return a;
else
return b;
}
p ( 0) = r( 0 ) = b − A ⋅ x ( 0)
α(k ) =
r ⋅ r( k )
p
x ( k +1) = x ( k ) + α ( k ) ⋅ p ( k )
T
(k )
T
(k )
⋅ A ⋅ p(k )
r( k +1) = r( k ) − α ( k ) ⋅ A ⋅ p ( k )
r( k +1) < ε
TAK
KONIEC
NIE
β ( k +1) =
T
( k +1)
T
(k )
r
⋅ r( k +1)
r ⋅ r( k )
p ( k +1) = r( k +1) + β( k +1) ⋅ p ( k )
9/60
Metoda CG - pseudokod + program ((Matlab
Matlab))
10/60
Wartość bezwzględna liczby - schemat blokowy
function [xk]=CGM(A,b,xk,eps)
 x dla x ≥ 0
x =
− x dla x < 0
pk = rk = b - A*xk;
dotrk = rk'*rk;
k = 0;
while (1)
k = k + 1;
Ap = A*pk;
alfa = dotrk/(pk'*Ap);
xk = xk + alfa*pk;
rk = rk - alfa*Ap;
dotrk1 = rk'*rk;
tak
if norm(rk,inf)<eps
break
end
pk = rk + (dotrk1/dotrk)*pk;
dotrk = dotrk1;
end
11/60
Parzystość liczby - schemat blokowy
START
Wczytaj(x)
Wczytaj(x)
x
tak
nie
0
Drukuj(x)
Drukuj(-x)
STOP
STOP
x
0
Drukuj(x)
nie
Drukuj(-x)
STOP
12/60
Równanie kwadratowe - schemat blokowy
START
START
START
START
ax 2 + bx + c = 0
Wczytaj(x)
Wczytaj(a,b,c)
∆ = b 2 − 4ac
Wczytaj(x)
x<0
delta=b2-4ac
tak
∆ > 0:
nie
x = -x
nie
x mod 2 = 0
x>1
Drukuj
(x - nieparzyste)
tak
−b− ∆
−b+ ∆
x1 =
, x2 =
2a
2a
tak
Drukuj
(x - parzyste)
nie
tak
nie
x=0
tak
x=x-2
STOP
Drukuj
(x - nieparzyste)
Drukuj
(x - parzyste)
STOP
∆ = 0:
x1 = x2 =
−b− ∆
2a
−b+ ∆
x2 =
2a
x1 =
delta > 0
nie
tak
x1 = x2 =
−b
2a
−b
2a
delta = 0
nie
Drukuj(Brak
rozwiązania)
Drukuj(x1,x2)
Drukuj(x1,x2)
STOP
STOP
STOP
13/60
Silnia - schemat blokowy
n!= 1⋅ 2 ⋅ 3 ⋅ ... ⋅ n
Rozwiązanie danego problemu wyraża się za pomocą rozwiązań
tego samego problemu, ale dla danych o mniejszych rozmiarach
Wczytaj(n)
W matematyce mechanizm rekurencji stosowany
jest do definiowania lub opisywania algorytmów
silnia = 1
Silnia:
...
n>0
14/60
Rekurencja lub rekursja - jest to odwoływanie się funkcji lub
definicji do samej siebie
START
2!= 1⋅ 2
3!= 1⋅ 2 ⋅ 3
Rekurencja
0!= 1
1!= 1
nie
dla n = 0
1
n!= 
n(n − 1)! dla n ≥ 1
tak
Drukuj(silnia)
silnia = n · silnia
n=n-1
int silnia(int n)
{
return n==0 ? 1 : n*silnia(n-1);
}
STOP
Rekurencja - ciąg Fibonacciego
0

Fn = 1
F + F
n−2
 n −1
dla n = 0
dla n = 1
15/60
Rekurencja - algorytm Euklidesa
dla b = 0
a
NWD(a, b) = 
 NWD (b, a mod b) dla b ≥ 1
dla n > 1
int F(int n)
{
if (n==0) return 0;
else
if (n==1) return 1;
else
return F(n-1) + F(n-2);
}
int NWD(int a, int b)
{
if (b==0)
return a;
else
return NWD(b,a % b);
}
16/60
17/60
18/60
W celu rozwiązania danego problemu obliczeniowego szukamy
algorytmu najbardziej efektywnego czyli:
najszybszego
Złożoność czasowa
Jej miarą jest liczba podstawowych operacji (dominujących)
Podstawowe operacje - porównanie, podstawienie, operacja
arytmetyczna
o możliwie małym zapotrzebowaniu na pamięć
Do oceny efektywności programu służy złożoność obliczeniowa
(koszt algorytmu)
Złożoność pamięciowa
Jest miarą wykorzystania pamięci (liczba komórek pamięci)
Złożoność obliczeniowa algorytmu:
jest ilością zasobów potrzebnych do jego działania (czas, pamięć)
jest funkcją rozmiaru danych, na których pracuje algorytm
Złożoność pesymistyczna
Odpowiada danym najbardziej niesprzyjającym dla algorytmu
Złożoność średnia
Złożoność uśredniona po wszystkich możliwych zestawach danych,
występująca dla „typowych” danych wejściowych
19/60
Notacja O („duże O”)
Wyraża złożoność matematyczną algorytmu
Po literze O występuje wyrażenie w nawiasach zawierające literę n,
która oznacza liczbę elementów, na której działa algorytm
Do wyznaczenia złożoności bierze się pod uwagę liczbę
wykonywanych w algorytmie podstawowych operacji
Przykład:
O(n) - złożoność algorytmu jest prostą funkcją liczby elementów
(jeśli sortowanie 10.000 elementów zajmuje 5 s,
to sortowanie 20.000 elementów zajmie 10 s)
O(n2) - czas konieczny do wykonania algorytmu rośnie wraz
z kwadratem liczby elementów (przy podwojeniu liczby
elementów ich obsługa będzie trwała cztery razy dłużej)
20/60
Notacja O („duże O”)
Porównanie najczęściej występujących złożoności:
Elementy
O(log n)
O(n)
O(n log n)
O(n2)
O(2n)
10
3
10
33
100
1024
100
7
100
664
10 000
1,27⋅1030
1 000
10
1 000
9 966
1 000 000
1,07⋅10301
10 000
13
10 000
132 877
100 000 000
1,99⋅103010
O(log n)
- złożoność logarytmiczna
O(n)
- złożoność liniowa
O(n log n)
- złożoność liniowo-logarytmiczna (quasi-liniowa)
O(n2)
- złożoność kwadratowa
O(2n)
- złożoność wykładnicza
21/60
Sortowanie
22/60
Sortowanie
Sortowanie polega na uporządkowaniu zbioru danych względem
pewnych cech charakterystycznych każdego elementu tego zbioru
(wartości każdego elementu)
W przypadku liczb, sortowanie polega na znalezieniu kolejności
liczb zgodnej z relacją ≤ lub ≥
W przypadku słów sortowanie polega na ustawieniu ich
w porządku alfabetycznym (leksykograficznym)
Przykład:
Tablica nieposortowana:
Przykład:
Tablica nieposortowana:
Tablice posortowane:
Tablica posortowana zgodnie z relacją ≤
(od najmniejszej do największej liczby):
Tablica posortowana zgodnie z relacją ≥
(od największej do najmniejszej liczby):
23/60
Sortowanie
W praktyce sortowanie sprowadza się do porządkowanie danych
na podstawie porównania - porównywany element to klucz
Przykład:
Tablica nieposortowana (imię, nazwisko, wiek):
Tablica posortowana (klucz - nazwisko):
Tablica posortowana (klucz - wiek):
24/60
Sortowanie
Po co stosować sortowanie?
Posortowane elementy można szybciej zlokalizować
Posortowane elementy można przedstawić w czytelniejszy sposób
Klasyfikacje algorytmów sortowania
Złożoność obliczeniowa algorytmu - zależność liczby
wykonywanych operacji od liczebności sortowanego zbioru n
Złożoność pamięciowa - wielkość zasobów zajmowanych przez
algorytm (sortowanie w miejscu - wielkość zbioru danych podczas
sortowania nie zmienia się lub jest tylko nieco większa)
Sortowanie wewnętrzne (odbywa się w pamięci komputera)
i zewnętrzne (nie jest możliwe jednoczesne umieszczenie
wszystkich elementów zbioru sortowanego w pamięci komputera)
25/60
Klasyfikacje algorytmów sortowania
26/60
Proste wstawianie (insertion
(insertion sort)
Algorytm jest stabilny, jeśli podczas sortowania zachowuje
kolejność występowania elementów o tym samym kluczu
Przykład:
Funkcja w języku C:
void InsertionSort(int tab[])
{
int i,j,tmp;
Przykład:
Tablica nieposortowana (imię, nazwisko, wiek):
for (i=1; i<N; i++)
{
j=i;
tmp=tab[i];
while (tab[j-1]>tmp && j>0)
{
tab[j]=tab[j-1];
j--;
}
tab[j]=tmp;
}
Tablica posortowana algorytmem stabilnym (klucz - wiek):
Tablica posortowana algorytmem niestabilnym (klucz - wiek):
}
27/60
Proste wstawianie (insertion
(insertion sort)
Złożoność algorytmu: O(n2)
+
+
+
+
+
wydajny dla danych wstępnie posortowanych
–
mała efektywność dla normalnej i dużej ilości danych.
wydajny dla zbiorów o niewielkiej liczebności
małe zasoby zajmowane podczas pracy (sortowanie w miejscu)
28/60
Proste wybieranie (selection
(selection sort)
Przykład:
void SelectionSort(int tab[])
{
int i,j,k,tmp;
for (i=0;i<N-1;i++)
{
k=i;
for (j=i+1; j<N; j++)
if (tab[k]>=tab[j])
k = j;
tmp = tab[i];
tab[i] = tab[k];
tab[k] = tmp;
}
stabilny
prosty w implementacji
}
29/60
Proste wybieranie (selection
(selection sort)
30/60
Bąbelkowe (bubble
(bubble sort)
Sortowanie bąbelkowe (ang. bubble sort), nazywane jest także:
+
+
+
szybki w sortowaniu niewielkich tablic
sortowaniem pęcherzykowym
małe zasoby zajmowane podczas pracy (sortowanie w miejscu)
sortowaniem przez prostą zamianę (ang. straight exchange)
–
liczba porównań elementów jest niezależna od początkowego
rozmieszczenia elementów w tablicy
–
w algorytmie może zdarzyć się, że wykonywana jest zamiana
tego samego elementu ze sobą.
prosty w implementacji
Bąbelkowe (bubble
(bubble sort)
Metoda ta polega na porównywaniu dwóch kolejnych elementów
i zamianie ich kolejności jeśli jest to konieczne
31/60
Nazwa metody wzięła się stąd, że kolejne porównania powodują
„wypychanie” kolejnego największego elementu na koniec
(„wypłynięcie największego bąbelka”)
Bąbelkowe (bubble
(bubble sort)
void BubbleSort(int tab[])
{
int i,j,tmp,koniec;
do
{
koniec=0;
for (i=0;i<N-1;i++)
if (tab[i]>tab[i+1])
{
tmp=tab[i];
tab[i]=tab[i+1];
tab[i+1]=tmp;
koniec=1;
}
}
while (koniec);
}
32/60
33/60
Bąbelkowe (bubble
(bubble sort)
prosta realizacja
–
mała efektywność.
34/60
Sortowanie szybkie (Quick
(Quick--Sort
Sort)) - faza dzielenia
+
+
+
Tablica jest dzielona na dwie części wokół pewnego elementu x
(nazywanego elementem centralnym)
wysoka efektywność użycia pamięci (sortowanie w miejscu)
stabilny
Jako element centralny x najczęściej wybierany jest element
środkowy (choć może to być także element losowy)
Przeglądamy tablicę od lewej strony, aż znajdziemy element ai ≥ x,
a następnie przeglądamy tablicę od prawej strony, aż znajdziemy
element aj ≤ x
Zamieniamy elementy ai i aj miejscami i kontynuujemy proces
przeglądania i zamiany, aż nastąpi spotkanie w środku tablicy
W ten sposób otrzymujemy tablicę podzieloną na lewą część
z wartościami mniejszymi lub równymi x i na prawą część
z wartościami większymi lub równymi x
35/60
(Quick--Sort
Sort)) - faza sortowania
Zawiera dwa rekurencyjne wywołania tej samej funkcji sortowania:
dla lewej i dla prawej części posortowanej tablicy
Rekurencja zatrzymuje się, gdy wielkość tablicy wynosi 1
Przykład:
Sortujemy 6-elementową tablicę tab:
Wywołanie funkcji QS() ma postać:
QS(tab,0,5);
36/60
(Quick--Sort
Sort)) - QS(tab,0,5)
Element środkowy: (0+5)/2 = 2,
x = tab[2] = 5
Od lewej szukamy tab[i] ≥ x,
a od prawej szukamy tab[j] ≤ x,
zamieniamy elementy miejscami
Poszukiwania kończymy,
gdy indeksy i, j mijają się
Wywołujemy rekurencyjnie funkcję QS() dla elementów
z zakresów [l,j] i [i,r]:
QS(tab,0,3);
QS(tab,4,5);
37/60
(Quick--Sort
0
1
2
3
1
2
4
3
i
38/60
(Quick--Sort
x = tab[1] = 2
x = tab[2] = 3
j
zamiana
Wywołanie QS() tylko dla elementów z zakresu [2,3], gdyż
po lewej stronie rozmiar tablicy do posortowania wynosi 1:
Rozmiar obu tablic do posortowania wynosi 1 więc nie ma
nowych wywołań funkcji QS()
QS(tab,2,3);
39/60
(Quick--Sort
x = tab[4] = 6
Sortowanie szybkie (Quick(Quick-Sort)
void QuickSort(int tab[], int l, int r)
{
int i,j,x,y;
i=l;
j=r;
x=tab[(l+r)/2];
do
{
while (tab[i]<x) i++;
while (x<tab[j]) j--;
if (i<=j)
{
y=tab[i];
tab[i]=tab[j];
tab[j]=y;
i++; j--;
}
} while (i<=j);
if (l<j) QuickSort(tab,l,j);
if (i<r) QuickSort(tab,i,r);
Rozmiar obu tablic do posortowania wynosi 1 więc nie ma
nowych wywołań funkcji QS()
}
40/60
41/60
Funkcja qsort
qsort()
() w języku C
42/60
Funkcja qsort() w języku C - przykład (1/2)
Quick-Sort został zaimplementowany w języku C w funkcji:
QSORT
stdlib.h
void qsort(void *baza, size_t n, size_t size,
(*funkcja)(const void *element1, const void *element2));
funkcja qsort() sortuje metodą Quick-Sort tablicę wskazywaną
przez argument baza i zawierającą n elementów o rozmiarze size
funkcja qsort() posługuje się funkcją porównującą funkcja(),
której argumentami są wskazania do elementów tablicy baza
funkcja() powinna zwracać wartości:
< 0,
gdy
*element1 < *element2
== 0, gdy
*element1 == *element2
> 0,
gdy
*element1 > *element2
Funkcja qsort
qsort()
() w języku C - przykład (2/
(2/2
2)
43/60
#include
#include
#include
#define
<stdio.h>
<stdlib.h>
<time.h>
N 10
void generuj(int tab[])
{
int i;
srand(time(NULL));
for (i=0;i<N;i++)
tab[i]=rand()%100;
}
void drukuj(int tab[])
{
int i;
for (i=0;i<N;i++)
printf("%2d ",tab[i]);
printf("\n");
}
44/60
Funkcja qsort
qsort()
() w języku C - przykład (2/
(2/2
2)
6
7
31
22
66
89
22
27
26
int funkcja(const void *element1, const void *element2)
{
if (*(int*)element1 < *(int*)element2) return -1;
if (*(int*)element1 == *(int*)element2) return 0;
if (*(int*)element1 > *(int*)element2) return 1;
}
int funkcja(const void *element1, const void *element2)
{
if (*(int*)element1 qsort:
< *(int*)element2) return -1;
7 22 22 26 27
31 0;
52 66
if (*(int*)element1 6== *(int*)element2)
return
if (*(int*)element1 > *(int*)element2) return 1;
}
int main()
{
int tab[N];
int main()
{
int tab[N];
}
generuj(tab);
drukuj(tab);
generuj(tab);
drukuj(tab);
printf("\nqsort:\n");
qsort((void*)tab,(size_t)N,sizeof(int),funkcja);
drukuj(tab);
printf("\nqsort:\n");
qsort((void*)tab,(size_t)N,sizeof(int),funkcja);
drukuj(tab);
system("PAUSE");
return (0);
system("PAUSE");
return (0);
}
52
89
45/60
Mnożenie macierzy
c13 
c23  = N
c33 
N
(i)
 a11 a12
a
 21 a22
 a31 a32
a13  b11 b12
a23  ⋅ b21 b22
a33  b31 b32
M
K
K
c11 = a11b11 + a12b21 + a13b31
b13 
b23 
b33 
M
c13 = a11b13 + a12b23 + a13b33
c21 = a21b11 + a22b21 + a23b31
c22 = a21b12 + a22b22 + a23b32
c23 = a21b13 + a22b23 + a23b33
c31 = a31b11 + a32b21 + a33b31
c32 = a31b12 + a32b22 + a33b32
c33 = a31b13 + a32b23 + a33b33
47/60
Mnożenie macierzy - metoda Strassena
załóżmy, że macierze są kwadratowe n × n i n jest potęgą liczby 2
dzielimy każdą macierz A, B, C na cztery podmacierze o rozmiarach
n/2 × n/2
B12 
Β
B =  11
,
 B 21 B 22 
C12 
C
C =  11

 C21 C22 
obliczamy niezależnie każdą z podmacierzy Cij korzystając ze wzoru:
Cij = A i1 ⋅ B1 j + A i 2 ⋅ B 2 j , i, j = 1,2
jedno mnożenie macierzy A ⋅ B zastępowane jest zatem ośmioma
mnożeniami macierzy Aij ⋅ Bij
koszt obliczeniowy powyższego algorytmu
jest taki sam jak algorytmu standardowego:
 c11 c12
c
 21 c22
 c31 c32
c13 
c23  = N
(i)
c33 
 a11 a12
a
 21 a22
 a31 a32
K (k)
a13  b11 b12
a23  ⋅ b21 b22
a33  b31 b32
b13 
b23 
b33 
M
(j)
K (k)
M (j)
Program w języku C:
c12 = a11b12 + a12b22 + a13b32
A12 
A
A =  11
,
 A 21 A 22 
46/60
Operacja: C = A ⋅ B (A[N][M], B[M][K], C[N][K])
A[N][M] - macierz N×M - elementowa
B[M][K] - macierz M×K - elementowa
C[N][K] - macierz N×K - elementowa
N
Mnożenie macierzy
Operacja: C = A ⋅ B
 c11 c12
c
 21 c22
 c31 c32
for (i=0; i<N; i++)
for (k=0; k<K; k++)
{
C[i][k] = 0.0;
for (j=0; j<M; j++)
C[i][k] += A[i][j] * B[j][k];
}
M
cik = ∑ aij ⋅ b jk ,
j =1
i = 1,2, K, N
k = 1,2,K, K
Koszt algorytmu: O (n 3 )
48/60
Mnożenie macierzy - metoda Strassena
pomysłem na przyspieszenie algorytmu jest zmniejszenie liczby mnożeń
podmacierzy z ośmiu do siedmiu
obliczamy 7 pomocniczych macierzy mi o rozmiarze n/2 × n/2:
m1 = ( A12 − A 22 ) ⋅ (B 21 + B 22 )
m 2 = ( A11 + A 22 ) ⋅ (B11 + B 22 )
m 3 = ( A11 − A 21 ) ⋅ (B11 + B12 )
m 4 = ( A11 + A12 ) ⋅ B 22
m 5 = A11 ⋅ (B12 − B 22 )
m 6 = A 22 ⋅ (B 21 − B11 )
m 7 = ( A 21 + A 22 ) ⋅ B11
obliczamy składowe Cij macierzy wynikowej C:
C11 = m1 + m 2 − m 4 + m 6
C12 = m 4 + m 5
O(n3 )
koszt powyższego algorytmu wynosi:
C21 = m 6 + m 7
C22 = m 2 − m 3 + m 5 − m 7
O (n log 2 7 ) = O (n 2,808 )
49/60
Mnożenie macierzy
50/60
Mnożenie macierzy
na szybkość wykonywania obliczeń wpływa nie tylko liczba operacji
zmiennoprzecinkowych, ale także sposób pobierania danych z pamięci
komputera
rozpatrzmy dwa algorytmy mnożenia macierzy:
Algorytm nr 1
obecne systemy komputerowe mają hierarchiczną budowę pamięci:
for (i=0; i<N; i++)
for (k=0; k<N; k++)
for (j=0; j<N; j++)
C[i][k] += A[i][j]*B[j][k];
rejestry procesora
pamięć podręczna (cache)
pamięć operacyjna
pamięć zewnętrzna
2048 × 2048
procesor:
Intel Core i5-2410M
2,30 GHz
kompilator: Microsoft Visual C++
2008 Standard Edition
Algorytm nr 1:
Algorytm nr 2
obliczenia są efektywnie wykonywane, gdy odbywają się
na zmiennych znajdujących się w jak najszybszej pamięci
macierze:
bez optymalizacji: 268,021 [s]
for (i=0; i<N; i++)
for (j=0; j<N; j++)
for (k=0; k<N; k++)
C[i][k] += A[i][j]*B[j][k];
z optymalizacją:
Algorytm nr 2:
bez optymalizacji:
z optymalizacją:
51/60
Mnożenie macierzy
49,409 [s]
6,270 [s]
52/60
Mnożenie macierzy
Metoda przechowywania macierzy w pamięci liniowej
Algorytm nr 1
M
C
A
B
C
A
B
for (i=0; i<N; i++)
for (k=0; k<K; k++)
for (j=0; j<M; j++)
C[i][k] += A[i][j] * B[j][k];
[0][0] [0][1] [0][2] [0][3]
N
92,053 [s]
[1][0] [1][1] [1][2] [1][3]
[2][0] [2][1] [2][2] [2][3]
macierz w pamięci liniowej (wektor)
Algorytm nr 2
macierz
Pamięć podręczna (cache memory)
for (i=0; i<N; i++)
for (j=0; j<M; j++)
for (k=0; k<K; k++)
C[i][k] += A[i][j] * B[j][k];
[0][0] [0][1] [0][2] [0][3]
[1][0] [1][1] [1][2] [1][3]
[2][0] [2][1] [2][2] [2][3]
53/60
Biblioteka numeryczna BLAS
54/60
Biblioteka numeryczna BLAS
BLAS - Basic Linear Algebra Subprograms
Wyróżnia się 3 poziomy abstrakcji algorytmów BLAS
Zbiór procedur służących do wykonywania operacji
na podstawowych obiektach algebry liniowej:
BLAS Level 1
skalarach
operacje typu wektor-wektor (dodawanie wektorów,
normy wektora, iloczyn skalarny wektorów)
wektorach
y ← αx + y
macierzach
BLAS Level 2
Strona główna: http://www.netlib.org/blas
operacje typu macierz-wektor (mnożenie macierzy przez wektor)
Rok publikacji: 1979
y ← αAx + y
Oryginalnie napisana w języku Fortran 77
BLAS Level 3
Obsługuje liczby:
rzeczywiste pojedynczej i podwójnej precyzji
operacje typu macierz-macierz (mnożenie macierzy przez macierz)
zespolone pojedynczej i podwójnej precyzji
C ← αA ⋅ B + C
55/60
BLAS - Nazwy procedur
DGEMV - mnożenie macierzy przez wektor, macierz i wektor
zawierają liczby rzeczywiste podwójnej precyzji
y ← α ⋅ A ⋅ x + β ⋅ y lub y ← α ⋅ AT ⋅ x + β ⋅ y
SGEMM - mnożenie macierzy przez macierz, macierze zawierają
liczby rzeczywiste pojedynczej precyzji
y ← α ⋅ op( A) ⋅ op(B) + β ⋅ C
op( X) = X, op( X) = XT , op( X) = conjg ( XT )
SSWAP - zamiana wektorów zawierających liczby rzeczywiste
pojedynczej precyzji
x↔y
56/60
BLAS - Implementacje
Strona główna: http://www.netlib.org/blas
Strona główna zawiera niezoptymalizowaną bibliotekę BLAS
MKL (Intel)
Intel Math Kernel Library (Intel MKL) v11
https://software.intel.com/en-us/intel-mkl
ACML (AMD)
AMD Core Math Library
http://developer.amd.com/tools-and-sdks/cpu-development/amd-coremath-library-acml/
ATLAS (open source)
Automatically Tuned Linear Algebra Software
http://math-atlas.sourceforge.net/
57/60
GPGPU i CUDA
58/60
CUDA - Jak używać
używać??
GPGPU - General Purpose computing on Graphics Processing Units
Sprawdzić czy karta graficzna w komputerze obsługuje CUDA
wszystkie nowe karty graficzne NVIDIA są kompatybilne z CUDA
CUDA (Compute Unified Device Architecture)
Ściągnąć oprogramowanie CUDA (CUDA 7.0)
hardware - równoległa architektura obliczeniowa GPU
software - kompilator nvcc, biblioteki i inne narrzędzia
Network Installer - 8 MB
Local Installer - 939 MB
NVIDIA Corporation (USA)
Pierwsza wersja: luty 2007
Zainstalować oprogramowanie CUDA
Strona: http://www.nvidia.pl/object/cuda-parallel-computing-pl.html
Użyć szablonu (template project) do stworzenia własnego
programu wykorzystującego CUDA
Strona: https://developer.nvidia.com/cuda-zone
Licencja: freeware
59/60
CUBLAS
Koniec wykładu nr 9
Biblioteka CUBLAS - implementacja BLAS (Basic Linear Algebra
Subprograms) dla kart graficznych NVIDIA i środowiska CUDA
Zastosowanie CUBLAS (wersja 5.5) w programie wymaga:
inicjalizacji biblioteki CUBLAS: cublasCreate()
przydzielenia pamięci GPU na macierze: cudaMalloc ()
przesłania macierzy o pamięci GPU: cublasSetMatrix()
wywołania odpowiednich funkcji CUBLAS: cublasSgemm()
przesłania wyników obliczeń z pamięci GPU do pamięci RAM
komputera: cublasGetMatrix()
zwolnienia pamięci GPU: cudaFree()
zakończenia pracy biblioteki CUBLAS: cublasDestroy()
Dziękuję za uwagę!
60/60

Informatyka 1 - PB Wydział Elektryczny

Transkrypt

Podobne dokumenty

NAZWISKO I IMIĘ

Nazwa kierunku Zarządzanie Tryb studiów stacjonarne

Informatyka 1 - Wydział Elektryczny

WNIOSEK O WYSTAWIENIE FAKTURY VAT DO ZAPŁATY

wniosek o wystawienie faktury vat do zapłaty

Tymczasowa lista wstępnie przyjętych Akademia Morska w Gdyni

BETA A+ - 100tab BETA A+ to suplement zawierający czystą beta

Uchwyt ścienny do TV, LCD, Plazma, LED WLB018

PEDAGOGIKA, semestr letni, rok akademicki 2014/2015