1.

Manipulacije sa listama
Veoma esto je potrebno vie razliitih izraza tretirati kao jedan objekt. Liste daju tu
mogunost u programskom paketu Mathematica. Lista je izraz koji poinje sa otvorenom
vitiastom zagradom {, a zavrava sa zatvorenom vitiastom zagradom } a izmeu koji se
navode izrazi koji su odvojeni meusobno zarezom. Na primjer:
{myName, yourName, 3.14159, a, Obala Kulina Bana}.
Svakoj listi moemo pridruiti ime. Na primjer:
myList = {a, b, c}
Elementu u listi preko imena liste pristupan tako to prvo navedemo ime liste pa
zatim u dvostrukim uglastim zagradama navedemo redni broj elementa u listi (indeks). Na
primjer, ako elimo da dobijemo drugi element iz liste myList to radimo sa sljedeom
naredbom
myList[[2]].
Elementi liste, takoer, mogu da budu i druge liste (podliste). Na primjer:
myList = {{a,b,c},{d,e,f},g,h,{k,l,m}}
Za pristup prvom elementu liste koristimo naredbu myList[[1]] i kao rezultat emo
dobiti {a,b,c}. Ako elimo da pristupimo drugom elementu prve podliste u listi myList to
radimo tako to u dvostrukim uglastim zagradama prvo navedemo indeks podliste u listi
myList a to je u naem sluaju 1, a zatim indeks odgovarajueg elementa u podlisti, pa bi
naredba izgledala ovako myList[[1,2]].
Postoji mnogo ugraenih funkcija koje omoguavaju manipulaciju sa listom. Mi emo navesti
samo one koje se najee koriste.
Naredba Length[myList] vraa duinu liste myList, a naredba Length[myList[[2]]]
vraa duinu druge podliste. Rezultat prve naredbe je 5, a druge 3. Naredba
Length[myList[[3]]] e izazvati grek jer trei element liste myList nije lista. Zato, prilikom
manipulacije sa listom treba imati na umu koji elementi liste su liste a koji obini izrazi.
Naredba Reverse[myList] vraa listu kod koje su elementi u obrnutom poretku u odnosu na
listu myList. Ako elimo da dodamo izraz Sarajevo na kraj liste, to radimo sa sljedeom
naredbom
Append[myList,Sarajevo],
Naredba Append kao prvi parametar uzima listu u koju se dodaje element na kraj, a
drugi parametar je element koji se dodaje. Treba imati na umu da se ovom naredbom ne
mijenja sama lista myList, ve se vraa lista koja nastaje dodavanjem izraza Sarajevo na kraj
liste myList, a ako elimo da lista myList postane upravo to, onda koristimo naredbu
AppendTo[myList, Sarajevo]
Analogno, ako elimo da dodamo izraz Sarajevo na prvo mjesto u listi myList,
koristimo naredbeu Prepend[myList, Sarajevo], odnosno, naredbu PrependTo[myList,
Sarajevo] ako elimo da mijenjamo listu myList.
Naredba Position[list,expression] vraa listu indeks koji odgovaraju poziciji izraza
expression u list, a naredba MemberQ[list,expression] vraa True ako je izraz expession
element liste list, a u suprotnom False. Naredbe First[list], Last[list] vraaju prvi odnosno
zadnji element iz liste respektivno. Pored naprijed navedenih funkcija postoji jo mnotvo
funkcija za manipulaciju sa listama. Navedimo jo neke.

Take[list, n]
Take[list,-n]
Take[list,{m,n}]
Drop[list,n]
Drop[list,-n]
Dop[list,{m,n}]
Rest[list]

vraa prvih n elemenata iz list

vraa zadnjih n elemenata iz list
vraa elemenata sa indeksima od m do n ukljuivo
vraa list bez prvih n elemenata
vraa list bez zadnjih n elemenata
vraa list bez elemenata sa indeksima izmeu m i n ukljuivo
vraa list bez zadnjeg elementa

Insert[ list , element , i]

Insert[ list , element , -i]
Insert[ list , element , {i, j, ... } ]
Delete[ list , i ]
Delete[ list , -i ]
Delete[ list ,{i, j, ...} ]

umee element na poziciju i u list

umee element na poziciju i u list idui od kraja liste
umee element na pozicije i, j, ... u list
brie element sa pozicije i iz list
brie element sa pozicije i iz list idui sa kraja liste
brie elemente sa pozicije i, j, ... iz list

Stavimo da je

In[1]:=t = { a, b, c, d, e, f, {aa, bb}

Out[1]={a, b, c, d, e, f, {aa, bb}}

Ovo daje zadnji element iz t

In[2]:=Last[ t ]
Out[2]={aa, bb}

Ovo daje prva tri elementa iz liste t

In[3]:=Take[ t, 3
Out[3]={a, b, c}

Ovo daje listu t bez zadnja dva elementa

In[4]:=Drop[ t, -2
Out[4]={a, b, c, d}

Ovo daje listu pozicija na kojima se

nalazi element a

In[5]:=Position[t,
Out[5]= {{1}}

a]

Ovo umee x na poziciju 2

In[6]:=Insert[ {a, b, c,
Out[6]={a, x, b, c, d}

d }, x, 2]

Ovo ispituje da li je d element liste

In[7]:= MemberQ[{a,
Out[7]=True

b, d, e, f, {c}}, d]

Sljedee naredbe su meu najkorisnijim za kreiranje liste izraza:

vraa listu imax vrijednosti od f
vraa listu vrijednosti od f kad i ide od imin do imax
vraa listu vrijednosti od f kad i ide od imin do imax sa
korakom di
Table[ f, {i, imin, imax, di} , generie multidimenzionalnu listu
{j, jmin, jmax, dj} , ... ]
Table[ f , {imax}]
Table[ f, {i, imin, imax}]
Table[ f, {i, imin, imax, di}]

Ovo kreira listu kvadrata brojeva od 1 do 10:

In[8]:=Table[i^2, {i, 1, 10}]

Out[8]={1, 4, 9, 16, 25, 36, 49,

64, 81, 100}

Sljedea naredba kreira matricu formata 2x2 i In[9]:=m = Table[i - j, {i, 1, 2}, {j, 0, 1}]
dodjeljuje joj ime m
Out[9]={{1, 0}, {2, 1}}
Ovo vraa duinu prve podliste od m

In[10]:=Length[m[[1]]]
Out[10]=2

Za kombinovanje dvije ili vie liste koristimo sljedee naredbe:

spaja date liste u jednu
kombinuje liste, izbacuje elemente koji se ponavljaju i
sortira rezultat
daje listu elemenata koji su zajedniki svim listama listi

Join[ list1 , list2 , ... ]

Union[ list1 , list2 , ... ]
Intersection[ list1 , list2 , ... ]
Ovo spaja date liste u jednu

In[11]:=Join[{1, 2}, {a, b, {1,

Out[11]={1, 2, a, b, {1, 2}, g}

2}}, {g}]

Ova naredba e ne samo spojiti liste u jednu,

In[12]:=Union[{1, 2}, {a, b, 2, {1, 2}}, {g, 1}]
ve i izbaciti duplikate i sortirati dobijenu listu Out[12]={1, 2, a, b, g, {1, 2}}
Navedimo jo neke naredbe za manipulaciju sa listama:
sortira elemente list po standardnom ureenju
vraa list u obrnutom redosljedu idui od kraja ka poetku
vraa listu svih permutacija elemenata iz list

Sort[ list ]
Reverse[ list ]
Permutations[ list]

Demonstrirajmo upotrebu tih naredbi sa sljedeim primjerima:

In[13]:=Permutations[{a, b, c}]
Out[13]={{a, b, c}, {a, c, b}, {b, a,

c}, {b, c, a}, {c, a, b}, {c, b, a}}

In[14]:=Reverse[{e, r, f, 123, "Esmir"}]

Out[14]={"Esmir", 123, f, r, e}
In[15]:=Sort[{"Edin", "Esmir", "Enis", eljko", "Anes"}]
Out[15]={"Anes", "Edin", "eljko", "Enis", "Esmir"}

2. 2D i 3D grafika u programskom paketu Mathematica

Programski paket Mathematica omoguava vrlo efikasno crtanje 2D i 3D grafikih objekata.
Za crtanje 2D grafikih objekata koristimo sljedee funkcije:
crta grafik za funkciju f za x od xmin do xmax
crta grafik za grupu funkcija zajedno
crta take {1, y1}, {2, y2}, ...
crta take {x1, y1}, {x2, y2}, ...
spaja susjedne take iz list sa linijom

Plot[ f, { x, xmin, xmax} ]

Plot[ {f1, f2, ... },{ x, xmin, xmax} ]
ListPlot[ {y1, y2, ... } ]
ListPlot[ { {x1, y1} , {x2, y2} , ... } ]
ListPlot[ list, PlotJoined->True ]

Sljedea naredba crta grafik funkcije tg(x) za x od 3 do 3:

In[1]:=Plot[Tan[x],

{x, -3, 3}]

40

20

-3

-2

-1

1
-20

-40

Moemo kombinovati vie funkcija :

In[2]:=Plot[{Sin[x]

, Sin[2 x]}, {x, 0, 2 Pi}]

1

0.5

-0.5

-1

Grafiko predstavljanje taaka u ravni:

In[3]:=ListPlot[Table[{i, Prime[i]},

{i, 1, 20}]]

70
60
50
40
30
20
10

10

15

20

Prilikom koritenja naredbe Plot postoje mnoge osobina koje se mogu specificirati.
Kao zadnji argument u funkciji Plot moemo ih ukljuiti sa naredbom oblika option
value. Za opciju za koju nismo specificirali vrijednost uzeta je podrazumijevana vrijednost.

Navedimo sada samo neke opcije koje se najee koriste:

option name
Axes
DisplayFunction
Frame
AxesLabel
AspectRatio
PlotRange

default value
Automatic
$DisplayFunction
False
None
1/GoldenRatio
Automatic

specificira da li e se ukljuiti ose na grafiku

specificira da li e se odmah iscrtati grafik
specificira da li e se crtati okvir za grafik
specificira labele za x i y osu
specificira omjer duzine podioka po x i y osi
raspon na x i y osi koji e biti ukljuen u
grafikon
Demonstrirajmo upotrebu gore navedenih opcija kroz nekoliko primjera.
Sljedea naredba crta grafik funkcije sa okvirom:
In[4]:=Plot[Sin[x],

{x, 0, 2 Pi}, Frame -> True]

1

0.5

-0.5

-1
0

Sljedeom naredbom crtamo grafik sa labelama za x i y osu:

In[5]:=Plot[x Cos[x]

+ Sin[x], {x, 0, 2 Pi},

AxesLabel -> {"x vrijednost", "y vrijednost"}]
y vrijednost
6
4
2
1

x vrijednost

-2

Prilikom crtanja grafika funkcija mogue je kombinovati zajedno vie opcija. Na primjer:
In[5]:=Plot[x Cos[x]

+ Sin[x], {x, 0, 2 Pi}, AxesLabel -> {"x vrijednost", "y vrijednost"},

PlotRange -> {-2, 4}]
y vrijednost
4
3
2
1
1

x vrijednost

-1
-2

Mathematica za bilo koji grafikon koji crta, snima sve informacije o njemu, tako da
je mogue taj grafik ponovo iscrtati. Prilikom ponovnog iscrtavanja grafika (odnosno bilo
kojeg grafikog objekta) mogue je i mijenjati neke opcije. Za ponovno iscrtavanje grafika
koriste nam sljedee naredbe:
Show[ grafik]
Show[ grafik, option - > value ]
Show[ grafik1, grafik2, ... ]
InputForm[ grafik ]

crta grafik
crta grafik sa promijenjenim opcijama
kombinuje vie grafika
prikazuje informacije koje su snimljene interno za grafik

Sljedea naredba samo rauna informacije za grafik funkcije i snima ih u promjenljivu grafik
bez crtanja grafika
In[6]:=grafik

= Plot[Sin[x/2], {x, 0, 4 Pi}, DisplayFunction -> Identity]

Sljedea naredba crta objekt koji je snimljen u promjenljivoj grafik:

In[7]:=Show[grafik,

DisplayFunction -> $DisplayFunction]

1

0.5

2
-0.5

-1

10

12

Svaki grafiki objekat u programskom paketu Mathematica koji se dobije koristei

funkcije poput Plot ili ListPlot sastoji se od grupe grafikih primitiva. Primitive su objekti
poput take, linije i poligona koji predstavljaju sastavni dio svakog grafikog objekta, kao i
direktive za debljinu, boju itd.
Sljedeom naredbom generiemo grafik liste taaka u ravni:
Int[8]:=tacke

= ListPlot[Table[Prime[i], {i, 1, 20}]]

70
60
50
40
30
20
10

10

Ako elimo vidjeti od kojih se primitiva sastoji

naredbom:

15

20

grafiki objekat koristimo sljedeu

In[9]:=InputForm[%]
Out[9]=Graphics[{Point[{1, 2}],

Point[{2, 3}], Point[{3, 5}],

Point[{4, 7}], Point[{5, 11}], Point[{6, 13}],
Point[{7, 17}], Point[{8, 19}], Point[{9, 23}],
Point[{10, 29}], Point[{11, 31}], Point[{12, 37}],
Point[{13, 41}], Point[{14, 43}], Point[{15, 47}],
Point[{16, 53}], Point[{17, 59}], Point[{18, 61}],
Point[{19, 67}], Point[{20, 71}]},
{PlotRange -> Automatic, AspectRatio ->
GoldenRatio^(-1), DisplayFunction :> $DisplayFunction,
ColorOutput -> Automatic, Axes -> Automatic,
AxesOrigin -> Automatic, PlotLabel -> None,
AxesLabel -> None, Ticks -> Automatic,
GridLines -> None, Prolog -> {}, Epilog -> {},
AxesStyle -> Automatic, Background -> Automatic,
DefaultColor -> Automatic, DefaultFont :> $DefaultFont,
RotateLabel -> True, Frame -> False,
FrameStyle -> Automatic, FrameTicks -> Automatic,
FrameLabel -> None, PlotRegion -> Automatic,
ImageSize -> Automatic, TextStyle :> $TextStyle,
FormatType :> $FormatType}]

Svaki dio grafike u programskom paketu Mathematica je predstavljen kao grafiki

objekat. Postoji nekoliko vrsta grafikih objekata, koji odgovaraju razliitim tipovima grafike.
Za svaku vrstu grafikog objekat postoji zaglavlje kojim se identifikuje njegov tip. Mi emo
raditi dva tipa koji se generiu sa funkcijama Graphics, Graphics3D, prvi je za
dvodimenzionalnu a drugi za trodimenzionalnu grafiku.
Koristei ove naredbe mi moemo kreirati vlastiti grafiki objekat. Da bi prikazali
grafiki objekat koristimo naredbu Show, koja je opisana na poetku ovog poglavlja.

U sljedeoj tabeli su date dvodimenzionalne grafike primitive:

taka sa koordinatama (x, y)
poligonalna linija koja prolazi kroz take
{x1, y1), (x2, y2), ...
ispunjeni pravougaonik
ispunjeni poligon sa datom listom vrhova
krunica sa centrom u (x, y) i poluprenika r
ispunjeni krug sa centrom u (x, y)
i poluprenika r
text expr, pri emu je donji lijevi ugao u (x, y)

Point[ {x, y} ]
Line[ { {x1, y1}, {x2, y2}, ....} ]
Rectangle[ {xmin, ymin},{ xmax, ymax}]
Polygon[{ {x1, y1}, {x2, y2}, ....} ]
Cicle[ {x, y}, r ]
Disk[{x, y}, r ]
Text[ expr, {x, y} ]

Demonstrirajmo upotrebu ovih primitiva kroz nekoliko primjera.

Generiimo take za poligonalnu liniju:
In[10]:=linije = Line[Table[{n, (-1)^n}, {n, 6}]]
Out[10]=Line[{{1, -1}, {2, 1}, {3, -1}, {4, 1}, {5,

-1}, {6, 1}}]

Da bismo je prikazali koristimo naredbu Show:

In[11]:=graf

= Show[Graphics[linije]]

Kao i kod naredbe Plot mogue je mijenjati opcije

In[12]:=Show[%,

Axes -> True]

1

0.5

-0.5

-1

Takoer je mogue kombinovati grafike objekte koji se dobiju naredbom Plot ili ListPlot sa
naim vlastitim grafikim objektima:
In[13]:=Show[tacke,

graf, PlotRange -> {-3, 10}]

10
8
6
4
2

5
-2

10

15

20

Generiimo vrhove za pravilni petougao:

In[14]:=petougao =

Table[{Sin[2 Pi n/5], Cos[ 2 Pi n/5]}, { n, 5}]

1 1

Out[14]=
(5 + 5), (-1+ 5) ,
4
2 2

1 1

1
(5 - 5), (-1- 5) ,

2 2

1
1 1

(5 - 5), (-1- 5) ,
4
2 2

1
1 1

(5 + 5), (-1+ 5) , 0,1

4

2 2
Da bismo generisali poligon koristimo primitivu Polygon, a za prikaz naredbu Show.
In[15]:=Show[Graphics[Polygon[petougao]],

AspectRatio -> Automatic]

Pored grafikih primitiva pri kreiranju dvodimenzionalnih grafikih objekata moemo

koristiti i grafike direktive. Navedimo nekoliko primjera koji pokazuju kako se
upotrebljavaju direktive GrayLevel, AbsolutePointSize i AbsoluteThickness, ije znaenje
moete vidjeti iz ovih primjera:
In[16]:=Show[Graphics[{{GrayLevel[0.5],

Rectangle[{0, 0}, {1, 1}]},

Rectangle[{1, 1}, {2, 2}]}]]

In[17]:=Show[Graphics[{Table[{AbsoluteThickness[n],

In[18]b=Show[Graphics[{AbsolutePointSize[10],

{n, 6}]}], Frame -> True]

Line[{{0, 0}, {n, 1}}]}, {n, 1,5}]}]]

Table[Point[{n, Prime[n]}],

12
10
8
6
4
2
1

Pored funkcije Plot Mathematica ima i ugraenu funkciju Plot3D. Ova funkcija
omoguava crtanje grafika funkcija od dvije promjenljive. Ima sljedeu sintaksu:
Plot3D[ f, {x, xmin, xmax}, {y, ymin, ymax }]
Prvi parametar je funkcija koja zavisi od dvije promjenljive x i y a drugi i trei
parametar odreuju raspon za promjenljive x i y. Demonstrirajmo upotrebu ove funkcije
postavljajui da je funkcija za sjenenje GrayLevel.
In[19]:=Plot3D[Sin[x y],

{x, 0, 4}, {y, 0, 4}, ColorFunction -> GrayLevel]

1
0.5

0
3

-0.5
-1
0

2
1
1

2
3
4

Prilikom crtanja trodimenzionalnih objekata veoma je vano iz kojeg pravca se

objekat posmatra. Da bi se to specificiralo koristimo opciju ViewPoint -> {x, y, z}.
Podrazumijevana taka iz koje se objekat posmatra je {1.3, -2.4, 2.}. Demonstrirajmo
upotrebu ove opcije u sljedeem primjeru:
In[20]:=Plot3D[Sin[x y],

{x, 0, 4}, {y, 0, 4}, ColorFunction -> GrayLevel,

ViewPoint -> {0, -3, 1}]
4
3
2
1
0

1
0.5
0
-0.5
-1
0

Sljedeom naredbom crtamo grafik funkcije bez mree (triangulacione podjele) koristei
opciju Mesh:
In[21]:=Plot3D[Sin[x y],

{x, 0, 4}, {y, 0, 4}, ColorFunction -> GrayLevel,

ViewPoint -> {3, -3, 2}, Mesh -> False]

1
0.5
0
-0.5
-1

4
1

3
2

2
3

1
0
4

Ako elimo samo triangulacionu podjelu grafika funkcije sa dvije promjenljive, onda
koristimo opciju Shading. Pogledajmo kroz sljedei primjer kako je moemo koristiti:
In[22]:= Plot3D[Sin[x y],

{x, 0, 4}, {y, 0, 4}, ColorFunction -> GrayLevel,

ViewPoint -> {3, -3, 2}, Shading -> False]

1
0.5
0
-0.5
-1

4
1

3
2

2
3

1
0
4

Programski paket Mathematica podrava crtanje krive i povri koje su zadane

parametarski. Krivu zadanu parametarski opisuje taka (x, y,z) u koordinatnom sistemu
ukoliko se x, y i z mijenjaju po zakonu x = (t), y = (t) i z= (t) gdje su , i neke
zadane funkcije, a t uzima vrijednosti iz nekog skupa. Povr zadanu parametarski opisuje
taka (x, y,z) u koordinatnom sistemu ukoliko se x, y i z mijenjaju po zakonu x = (u,v),
y = (u,v) i z= (u,v) gdje su , i neke zadane funkcije, a u i v uzimaju vrijednosti iz
nekog skupa. Za crtanje krive i povri zadane parametarski koristimo funkciju
ParametricPlot3D. Sljedei primjer crta grafik povri x = sin u, y = cos u i z= v za u (0, 2)
i v (0, 4):
In[22]:=ParametricPlot3D[{Sin[u], Cos[u],

v}, {u, 0, 2 Pi}, {v, 0, 4 }]

1
-1

0.5
0

-0.5

0.5

-0.5
-1
4

U sljedeem primjer crtamo krivu x = sin u, y = u cos u i z= u za u (-2, 2)

In[23]:=ParametricPlot3D[{Sin[u

], u Cos[u], u}, {u, - 2Pi, 2 Pi}]

5
0
-5
5

-5
-1 0
-0.5
0.5 1

Kao to smo rekli za dvodimenzionalne grafike objekte, i trodimenzionalni grafiki

objekti su sastavljeni od 3D grafiki primitiva i direktiva. Kako su im nazivi isti kao i kod
dvodimenzionalnih grafiki primitiva, samo to se u argumentima umjesto taaka iz 2D
navode take iz 3D, demonstrirajmo samo njihovu upotrebu kroz nekoliko primjera:
In[24]:=tacke

= Table[Point[{Random[ ], Random[ ], Random[]}], {20}];

Show[Graphics3D[{AbsolutePointSize[5], tacke}]]

In[25]:=Show[Graphics3D[

Table[Polygon[Table[{Random[ ], Random[ ], Random[]}, {3}]], {5}]]]

3. Funkcije i moduli
U svakom sloenijem programu postoje nizovi naredbi koji opisuju neki postupak
zajedniki nizu ulaznih vrijednosti. Do sada ako smo htjeli ponoviti neki postupak sa drugim
podacima, morali smo preslikati sve naredbe na sva mjesta gdje se taj postupak koristi. Mane
takvog postupka su oigledne: osim to programski kod postaje glamurozan, oteava se i
ispravka pogreki- primijeti li se pogreka u postupku, ispravku je potrebno unijeti na svako
mjesto gdje smo postupak koristili.
Kako bi se takva ponavljanja izbjegla, programski paket Mathematica nudi rjeenje
tako da se ponavljani postupak smjesti u zasebne cjeline funkciju, te se pozove na mjestu
gdje je to potrebno.
Funkciju je mogue pozvati i iz neke druge funkcije , pa ak i iz sebe same. Svaka se
funkcija moe pozvati neogranien broj puta. Kao ni varijable, ni funkcije nije potrebno
deklarisati, ve samo definisati.
Sintaksa za funkciju ima sljedei oblik:
Ime_funkcije[ arg1_ , arg2_ , ... ] := ( tijelo_funkcije )
Argumenti unutar uglastih zagrada iza imena funkcije su podaci koji se predaju
funkciji prilikom njenog poziva. Broj tih argumenata moe biti proizvoljan, s tim da funkcija
moe biti i bez argumenata Znak _ na lijevoj strani argumenta je jako vaan, i arg1_ ima
znaenje jednog jednostavnog izraza izraz ije je ime arg1. Ako se tijelo_funkcije sastoji od
vie naredbi, onda se svaka od njih treba da zavri sa znakom taka-zarez ;. Ako se
tijelo_funkcije sastoji samo od jedne naredbe onda se mogu izostaviti zagrade ( ). Kao rezultat
ove funkcije vraa se zadnja naredba iz bloka tijelo_funkcije. Kad smo definisali funkciju,
moemo je pozvati na bilo kojem mjestu u programu tako to navedemo ime funkcije i u
uglastim zagradama [ ] specificiramo argumente.
Na primjer, sljedea funkciju ima jedan argument, i za dati izraz x rauna njegov kvadrat
In[1]:=Kvadrat[

x_ ] := x^2;

Pogledajmo sad kroz dva primjera kako moemo pozvati funkciju

In[2]:=Kvadrat[a+1]
2
Out[2]=(1+a)
In[3]:=Kvadrat[4]
Out[3]=16

Funkciju Kvadrat moemo koristiti kao i bilo koju ugraenu funkciju. Na primjer:
In[4]:=Expand[Kvadrat[(x+1+y)]]
2
2
Out[4]= 1 + 2x + x + 2y + 2 x y + y

Ako elimo da vidimo definiciju funkcije, onda ispred naziva funkcije koristimo znak ?.

Na primjer:
In[5]:= ?Kvadrat
Out[5]=Global Kvadrat

Kvadrat[ x_ ] := x^2;

Ako znamo da nam nije vie potrebna funkcija koju smo definisali, onda je uvijek
dobro datu funkciju izbrisati. Ako to ne uradimo onda moemo imat problema u kasnijem
radu ako koristimo isti naziv za funkciju sa drugom definicijom. Da bismo to uradili
koristimo funkciju Clear koja kao svoj argument uzima naziv funkcije koju briemo. Tako
ako elimo izbrisati funkciju Kvadrat onda to radimo sa sljedeom naredbom:
In[6]:=Clear[Kvadrat]

Navedimo sad jedan primjer funkcije koja poziva drugu funkciju koju smo ranije definisali, i
ije se tijelo sastoji od vie naredbi:
n

Sljedea funkcija za dato n rauna proizvod

( x i) :
i 1

In[7]:= Proizvod[n_] :=

Expand[Product[x + i, {i, 1, n}]]

Poziv funkcije za n=3 bi izgledao ovako:

In[8]:=Proizvod[3]
2
Out[8]= 6 + 11 x + 6 x

+ x3

Sljedea funkcija za dato n i i rauna Proizvod[n] i vraa koeficijent uz xi.

In[9]:= coef[n_,

i_] := (t = Proizvod[n]; Coefficient[t, x^i])

Ako elimo da dobijemo koeficijent od polinoma Proizvod[3] uz x2 , to dobijemo sljedeom

naredbom
In[10]:=coef[3,
Out[10]=6

2]

Programski paket Mathematica podrazumijeva da su sve varijable koje koristimo

globalne. To znai svaki put kad koristimo promjenljivu, recimo, sa imenom x, programski
paket Mathematic podrazumjeva da se to odnosi na isti objekat.
Meutim, kad piemo program, ne elimo da nam sve varijable budu globalne. Moda
elimo da nam se ime x odnosi na dva razliita objekta u dva razliita programa. U tom
sluaju , trebamo promjenljivu x tretirati kao lokalnu.
Da bismo stavili da nam neka varijabla bude lokalna koristimo module. U svakom
modulu navodimo listu varijabli za koje elimo da budu tretirane kao lokalne promjenljive u
tom modulu.
Sintaksa za modul sa lokalnim promjenljivim x, y itd. je sljedea:
Module[{ x , y, ... }, body ]
Definiimo globalnu promjenljivu t da ima vrijednost 17,
In[11]:= t=17
Out[11]=17

Ako sad koristimo varijablu t unutar modula ona e biti tretirana nezavisno od globalne
varijable t, to vidimo iz sljedeeg primjera:
In[12]:=Module[{
Out[12]=8

t }, t=8; Print[ t ]]

Globalna promjenljiva t e i dalje imati vrijednost 17

In[13]:=t
Out[13]=17

Veoma est nain koritenja modula je sa funkcijama. Sve varijable koje se javljaju u tijelu
funkcije stavljamo da budu lokalne, stavljajui da tijelo funkcije bude tijelo modula. Ako
funkciju coef napiemo preko modula dobijemo:
In[14]:=ceof[n_, i_] :=

Module[{t}, t = Proizvod[n]; Coefficient[t, x^i] ]

Poslije poziva
In[15]:=coef[3,
Out[15]=6

2]

Globalna promjenljiva t i dalje ostaje ista

In[16]:=t
Out[16]=17

4. Naredbe za kontrolu toka programa

U veini realnih problema tok programa nije pravolinijski i jedinstven pri svakom
izvoenju. Redovno postoje potrebe da se pojedini dijelovi programa ponavljaju (programski
dijelovi koji se ponavljaju nazivaju se petljama). Ponavljanje moe biti unaprijed odreeni
broj puta, na primjer, ako elimo izraunati proizvod brojeva od 1 do 100. Meutim, broj
ponavljanja moe zavisiti i od rezultata neke operacije. Kao primjer uzmimo uitavanje
podataka iz datoteke- datoteka se ita podatak po podatak, sve dok ne doemo do oznake za
kraj. Duina datoteke pritom moe da varira zavisno od datoteke do datoteke.
Gotovo uvijek se javljaju potrebe za grananjem toka izvoenja naredbi, tako da se zavisno
od postavljenih uslova u jednom sluaju izvodi jedan dio koda, a u drugom sluaju drugi dio.
Grananje toka i ponavljane dijelova koda omoguavaju posebne naredbe za kontrolu toka.

Grananje toka naredbama If i Switsh

Naredba If omoguava uslovno grananje toka izvravanja programa zavisno da li je ili nije
ispunjen uslov naveden iza kljune rijei If. Najjednostavniji oblik naredbe za grananje je:
If[ test, then, else]
Ako je vrijednost izraza test jednaka True izvodi se blok naredbi then. U suprotnom ako je
vrijednost izraza test False izvodi se blok naredbi else. Na primjer:
In[1]:=a =
Out[1]=5

In[2]:=If[

a < 0, Print["Broj a je negativan"], Print[" Broj a je pozitivan" ]]

Broj a je pozitivan

Trebamo napomenuti da su naredbe u blokovima then i else meusobno razdvojene zarezom.

Kada izraz uslova daje vie razliitih vrijednosti, a za svaku od njih treba izvriti
odgovarajue odsjeke programa, tada umjesto If naredbe esto koristimo naredbu Switch.
Kod tog grananja se prvo izrauna neki izraz. koji daje neki rezultat. Zavisno od tog rezultata,
tok programa se preusmjerava na neku od grana unutar Switch bloka. Opta sintaksa Switch
grananja izgleda ovako:
Switch[ izraz , form1, vrijednost1, form2, vrijednost2, ... , _ , def ]
Prvo se izrauna izraz koji daje neki rezultat. Zatim se taj rezultat poredi sa form1,
form2, ... i im se naleti na neki formi koji je jednak tom rezultatu vraa se vrijednost koja je

asocirana za taj formi. Ako izraz daje rezultat koji nije jednak ni jednom od izraza formi tada
se izvodi blok naredbi def. Evo i konkretnog primjera Switch grananja:
In[3]:=r[x_]:=Switch[Mod[x,3],

0, a, 1, b, 2, c]

Definisali smo funkciju koja zavisi od vrijednost ostatka dijeljenja svog argumenta sa 3. Kako
je Mod[7, 3]=1 to imamo da je
In[4]:=r[7]
Out[4]=b

Naredbe za ponavljanje (petlje)

esto u programu treba ponavljati dijelove koda. Ako je broj ponavljanja poznat prije ulaska
u petlju, najprikladnije je koristiti For petlju. To je najopenitija vrsta petlje i ima sljedei
sintaksu:
For[start, test, increment, body ]

Iza kljune rijei For, unutar uglastih zagrada [ ], navode se etiri grupe naredbi,
meusobno odvojenih znakom zareza ,. Postupak izvoenja For-bloka je sljedei
1. Izraunava se start. Najee je to pridruivanje poetne vrijednosti brojau kojim e
se kontrolirati ponavljanje petlje.
2. Izraunava se test. Ako je rezultat jednak False preskae se blok naredba body i
program se nastavlja prvom naredbom iza uglaste zagrade ].
3. Ako je rezultat jedna True izvodi se blok naredbi body.
4. Na kraju se izraunava blok naredbi increment . Program se vraa na poetak petlje,
te se ona ponavlja od take 2.
Kao primjer za For petlju napiimo Modul koji rauna faktorijel od n (faktorijel od n je
proizvod svih brojeva od 1 do n) .
In[5]:=faktorijel[n_] :=

Module[{pro = 1, i},
For[i = 1, i <= n, i++, pro = pro*i];
pro

]
Ako pozovemo ovaj modul za broj 6 dobiem vrijednost od 3!.
In[6]:=faktorijel[3]
Out[6]=6

Prije ulaska u petlju stavljamo da nam je poetna vrijednost pro u koju emo gomilati
proizvod jednaka 1. Na ulasku u petlju stavljamo broja petlje i na 1. Unutar same petlje
mnoimo sa brojaem i proizvod pro , a na kraju tijela petlje uveam broja za jedan. Petlju
ponavljamo sve dok je broja manji ili jednak od broja koji smo prenijeli kao argument
funkcije.
Druga petlje kojom raspolae programski paket Mathematica jeste While petlja. Ona se koristi
uglavnom za ponavljanje dijelova koda kod kojeg broj ponavljanja nije unaprijed poznat.
Sintaksa While naredbe je sljedea:
While[test, body]
Tok izvoenja While bloka je sljedei:
1. Izrauna se izraz test
2. Ako je rezultat jednak False, preskae se body i program nastavlja od prve naredbe
iza uglaste zagrade ].

3. Ako je rezultat jedna True izvodi se blok naredbi body . Potom se program vraa na
While naredbu i izvodi od take 1.
Demonstrirajmo upotrebu ove naredbe na primjeru Eratostenovog sita. Najefikasniji algoritam
za generisanje tabele svih prosti brojeva koji su manji ili jednaki datom broju n koji je danas
poznat, je algoritam koji je bio poznat i Erathosthen-u od Cyrene ( u dananjoj Libiji).
Poinje postavljanjem liste L={ 2, 3, . . . , n}. Prvi element liste , broj 2, je prost. Precrtamo
sve sadrioce broja 2 koji su vei od 2. prvi element liste koji je vei od 2 i nije precrtan,
dakle broj 3, je prost broj. Precrtamo sve sadrioce broja 3 koji su vei od 3. Onda idemo na
sljedei element liste koji nije precrtan, itd.
Sljedei modul za dati prirodan broj n vraa listu prostih brojeva koji su manji ili jednaki od n
In[7]:=Eratosten[n_]:= Module[{k=1,j,a=Table[i,{i,2,n}]},

While[k<Length[a],
For[j=k+1,jLength[a],j++,
If[Mod[a[[j]],a[[k]]]0 && a[[j]]a[[k]], a=Drop[a,{j}]
]];
k++;
];
a
]
Ako pozovemo ovu funkciju za n=50 dobijemo sljedee:
In[8]:=Eratosten[5]
Out[8]={2, 3, 5, 7, 11,

13, 17, 19, 23, 29, 31, 37, 41, 43, 47}

Navedimo sad nekoliko problema i njihova rjeenja u programskom paketu Mathematica.

5. Generator sluajnih brojeva

U stvarnosti raunar ne moe sam stvarati sluajne brojeve. U stvari sluajni brojevi
koje generie raunar su potpuno odreeni nekim poetnim parametrima. Zbog toga se za
sluajne brojeve koristi i naziv pseudo-sluajni, gdje pseudo treba da upozori na to da su
brojevi samo prividno sluajni. Razne programerske firme su razvile razne algoritme za
generisanje sluajnih brojeva, meutim dre ih u tajnosti. Naime, ako bi algoritam bio javan,
tada bi svako mogao da tano odredi koji e slijedei sluajan broj generisan tim
programom biti.
U programskom paketu Mathematica sluajni brojevi se generiu uz pomo naredbe
Random[] koja daje sluajan broj iz segmenta [0, 1]. U sluaju da nam je potreban sluajan
prirodan broj iz nekog opsega tada koristimo naredbu Random[Integer, {i1,i2}]], gdje i1 i i2
predstavljaju granice segmenta iz kojeg se bira sluajan broj.
In[1]:=Table[Random[],{10}]

Izvravanjem ove naredbe dobijamo slijedei izlaz:

Out[1]={0.185898,

0.242848, 0.20331, 0.0515874, 0.440317, 0.239615, 0.817663, 0.23069,

0.986929, 0.262161}

Ako elimo cijele sluajne brojeve unesimo:

In[2]:=Table[Random[Integer, {10,100}],{10}]
Out[2]={34, 55, 15, 65, 98, 27, 41, 22, 78, 86}

Ponovnim izvravanjem prethodne naredbe dobijamo:

In[3]:=Table[Random[Integer, {10,100}],{10}]
Out[3]={74, 45, 100, 63, 74, 79, 45, 39, 36, 36}

Naredbom RandomSeed[n] moemo postavljati poetni uslov za generisanje sluajnih

brojeva. Pri tome n predstavlja bilo koji prirodan broj. Ako ostavimo prazne zagrade tada
Mathematica za n uzima trenutno vrijeme. Tako npr. ako elimo dvije identine liste suajnih
brojeva moemo koristiti
In[4]:=SeedRandom[135];

Table[Random[Integer, {10,100}],{10}]
45, 98, 49, 28, 87, 61, 33, 91, 19}

Out[4]={15,

Sada ako ponovo izvrimo istu naredbu

In[5]:=SeedRandom[135];

Table[Random[Integer, {10,100}],{10}]
45, 98, 49, 28, 87, 61, 33, 91, 19}

Out[5]={15,

dobijamo isti niz sluajnih brojeva. To je upravo zato to smo oba puta koristili iste poetne
parametre pri generisanju sluajnih brojeva.
Da bi na raunaru proizvodili sluajne brojeve potrebno je na neki nain generisati
brojeve koji pokazuju statistika svojstva sluajnosti. Dva najvanija ovakva svojstva su
ravnomjerna rasporeenost i neperiodninost.
Ravnomjerna rasporeenost sastoji se u tome da se generisani brojevi moraju
ravnomjerno rasporediti na cijeli interval. Tako npr. ako interval iz kojega se trebaju
generisati sluajni brojevi podijelimo na k jednakih dijelova, tada u svakom dijelu treba da se
nalazi priblino isti broj sluajnih brojeva.
Meutim uslov ravnomjernosti nije dovoljan. Naime oigledno brojevi
1,2,3,1,2,3,...,1,2,3 zadovoljavaju princip ravnomjerne rasporeenosti, ali mi znamo da nakon
2 dolazi 3, nakon 3 dolazi 1 i nakon 1 dolazi 2, pa dakle, ovaj niz brojeva nije niz sluajnih
brojeva, jer se ovi brojevi periodino ponavljaju. Sluajni brojevi ne smiju biti periodini.
Ispitivanje neperiodinosti je vrlo sloen problem i sastoji se u ispitivanju mustri. Uzima se
dio niza (podniz) sluajnih brojeva i provjerava se da li se ovaj dio niza ponavlja u nekom
drugom dijelu niza. Nakon toga se uzima drugi podniz i ispitivanje se vri i za ovaj podniz itd.
Upravo metoda kongruencije koju je 1948. godine objavio D.H.Lehmer daje ovakve brojeve.
Bit ove metode je slijedea formula:
zn+1= (azn +b) mod m,
gdje x modul y predstavlja ostatak pri dijeljenju x sa y, a je multiplier i njegova vrijednost je
izmeu 2 i m-1, b je increment i njegova vrijednost je manja od m. Takoer se uzima da je
vrijednost z0 izmeu 0 i m.
Slijedei kod napisan u programskom paketu Mathematica predstavlja jedan linearni
kongruentni generator sluajnih brojeva. Kao poetne vrijednosti potrebne su nam etiri
vrijednosti: a-multiplier, m-modul, n-broj sluajnih brojeva koje generiemo i seed-sjeme
generatora. Na poetku modula formirati emo listu od n elemenata. Zatim emo za prvi
element liste postaviti ostatak dijeljenja sjemena seed sa m. Vrijednost svakog slijedeeg
elementa definiimo uz pomo elementa koji mu prethodi, tako to emo za njegovu
vrijednost uzeti ostatak pri dijeljenju, proizvoda prethodnog elemenata sa a, sa m. Kao
vrijednost funkcije vratimo output.

In[6]:=ran[a_, m_,

n_, seed_] := Module[{i, output={}},

output = Table[0, {n}];
output[[1]] = Mod[seed, m];
For[i = 2, i <= n, i++,
output[[i]] = Mod[a*output[[i - 1]], m]
];
output
]

Pozovemo li ovu funkciju za a=6, m=13, n=20 i speed=2 dobijemo:

In[7]:=ran[6, 13, 20, 2]
Out[7]={2, 12, 7, 3, 5, 4, 11, 1,

6, 10, 8, 9, 2, 12, 7, 3, 5, 4, 11, 1}

Dobili smo 20 sluajnih brojeva u rasponu od 0 do 12. Primijetimo da za m moramo izabrati

neki prost broj (to vei to bolji). Naime, u sluaju da ovaj broj nije prost tada dobijamo npr.
In[8]:=ran[6,12,20,2]
Out[8]={2, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}

Da bismo generisali realne sluajne brojeve iz intervala (0,1) potreban nam je

slijedei algoritam: na poetku algoritma pozivamo funkciju ran koja u myRandom smjeta
traeni broj sluajnih brojeva iz intervala (0,m), a nakon toga svaki od ovih brojeva dijeli sa
m, ime dobijamo sluajne brojeve u iz intervala (0,1).
In[9]:=uran[a_, m_,

n_, seed_] := Module[{i},

myRandom = ran[a, m, n, seed];
output = Table[0, {n}];
output[[1]] = Mod[seed, m]/m;
For[i = 2, i <= n, i++,
output[[i]] = myRandom[[i]]/m
];
N[output]

]
Pozivanjem ove funkcije sa
In[10]:=uran[6,

13, 20, 2]

dobijamo:
Out[10]={0.153846,

0.923077, 0.538462, 0.230769, 0.384615, 0.307692, 0.846154, 0.0769231,

0.461538, 0.769231, 0.615385, 0.692308, 0.153846, 0.923077, 0.538462, 0.230769,
0.384615, 0.307692, 0.846154, 0.0769231}

6. Trouglovi sa cjelobrojnim stranicama

Sutina ovoga problema se sastoji u slijedeem: Neka je dat neki pozitivan cijeli broj.
Treba odrediti sve trouglove sa cjelobrojnim stranicama teko da taj broj bude obim tih
trouglova. Neka su a, b i c stranice trougla i neka je 0 a b c . Tada je obim trougla dat
sa p a b c . Da bi postojao trougao ije su stranice a, b i c dovoljno je da bude
c a b (ostale dvije nejednakosti su automatski tane). Imamo da vrijedi:
p a b c 3c

c p / 3 c p / 3

To mora biti c p / 2 jer bismo imali p 2c , pa je a b p c 2c c c , to nije tano.

Posmatrajmo sada stranicu a: p a b c 3a 1 a p / 3

Meutim, kako je a b p a c a ( p c ) / 2 , analogno kako je b p c a c a p 2c .

Na osnovu ovoga razmatranja moemo napisati modul koja e nam raunati sve trouglove
datog obima koji imaju cjelobrojne stranice.
In[1]:=Trouglovi[p_]:=Module[{a,b,c,x={},broj=0},

For[c=Ceiling[p/3],c<Ceiling[p/2],c++,
For[a=p-2*c,aFloor[(p-c)/2],a++,
b=p-c-a;
broj++;
AppendTo[x,{a,b,c}];
];
];
Return[x];
];
Navedimo nekoliko primjera:
In[2]:=Trouglovi[17]
Out[2]={{5, 6, 6}, {3,

7, 7}, {4, 6, 7}, {5, 5, 7}, {1, 8, 8}, {2, 7, 8},{3, 6, 8}, {4, 5, 8}}

In[3]:=Trouglovi[40]
Out[3]={{12, 14, 14}, {13,

13, 14}, {10, 15, 15}, {11, 14, 15}, {12, 13, 15}, {8, 16,16},
{9, 15, 16}, {10, 14, 16}, {11, 13, 16}, {12, 12, 16}, {6, 17, 17}, {7, 16, 17},
{8, 15, 17}, {9, 14, 17}, {10, 13, 17}, {11, 12, 17}, {4, 18, 18}, {5, 17, 18},
{6, 16, 18}, {7, 15, 18}, {8, 14, 18}, {9, 13, 18}, {10, 12, 18}, {11, 11, 18},
{2, 19, 19}, {3, 18, 19}, {4, 17, 19}, {5, 16, 19}, {6, 15, 19}, {7, 14, 19},
{8, 13, 19}, {9, 12, 19}, {10, 11, 19}}

7. Tornjevi Hanoja
Problem Tornjevi hanoja sastoji se u slijedeem: Data su tri stuba i proizvoljan broj
diskova razliitih veliina stavljen je na jedan od stubova i to tako da se na svakom disku
nalazi manji od njega. Zadatak je prebaciti sve diskove sa jednog stuba na drugi uz potovanje
odreenih pravila:
1. Moe se prebacivati samo jedan po jedan disk.
2. Nikada se vei disk ne moe staviti na manji.
Rjeenje ovog problema mogue je uz koritenje rekurzivnog1 algoritma. Njegova
implementacija je data sa:
In[1] :=

hanoi[n_, r_, s_] := Module[{},

If[n == 1,
Print["prebaci sa ", r, " na ", s],
hanoi[n - 1, r, 6 - r - s];
hanoi[1, r, s];
hanoi[n - 1, 6 - r - s, s] ]

U sluaju da je ostao samo jedan disk na stubu prebaci ga na odredini stub. U

protivnom prebaci n-1 disk na pomoni stub, onaj preostali disk prebaci na odredini stub i
prebaci n-1 disk sa pomonog stuba na odredini stub.
Izvravanjuem ovog algoritma dobijamo slijedei output:

To je proces kada funkcija poziva samu sebe.

In[2]:=hanoi[3,1,3]
prebaci sa 1 na 3
prebaci sa 1 na 2
prebaci sa 3 na 2
prebaci sa 1 na 3
prebaci sa 2 na 1
prebaci sa 2 na 3
prebaci sa 1 na 3

Ovaj algoritam moemo malo modifikovati, tako da umjesto ispisa sa kojeg na koji stub
prebacuje diskove, ne ispisuje nita, ve samo broji potrebne poteze.
In[3]:=hanoi1[n_,r_,s_]:=Module[{},

If[n==1,
potez++,
hanoi1[n-1,r,6-r-s];
hanoi1[1,r,s];
hanoi1[n-1,6-r-s,s]
];
]
Algoritam se nije u biti promijenio osim to umjesto Print sada imamo potez++ to je
ekvivalentno sa potez = potez+1
Izvravenjem ovog algoritma dobijamo slijedee:
In[4]:= potez=0;
Out[4]:=7

hanoi1[3,1,3]; potez

Ovo znai da je za prebacivanje tri diska potrebno sedam poteza.

Formirajmo tabelu koja e se sastojati od ureenoh parova iji prvi lan predstavlja broj
diskova, a drugi broj poteza potrebnih za prebacivanje tih diskova.
In[5]:=w={};

Table[potez=0;hanoi1[n,1,3];AppendTo[w,{n,potez}],{n,3,10}];
Kompajliranjem ovog dijela i izvravanjem dobijemo
In[6]:=w
Out[6]={{3,

7}, {4, 15}, {5, 31}, {6, 63}, {7, 127}, {8, 255}, {9, 511}, {10, 1023}}

Predstavimo ovu tabelu u obliku grafika koristei se naredbom ListPlot:

In[7]:=u=ListPlot[w, PlotStyle

-> {PointSize[0.02], Hue[ 0.7 ]}]

1000
800
600
400
200

10

Moe se dokazati da je broj poteza za prebacivanje n diskova jednak 2 n 1 . Crtajui

zajedno take iz liste w i funkciju 2 n 1 , dobijemo da take iz liste w zaista lee na grafiku
funkciji 2 n 1 , to se vidi iz sljedeeg grafika:
In[8]:=Show[u, Plot[2^n

- 1, {n, 1, 12}]]

2500
2000
1500
1000
500

10

12

8. Linearno programiranje Simplex maina

U jednoj fabrici se proizvode proizvodi x i y svaki na tri maine, zvaemo ih maine A, B i C.
Da bi maine radile potrebno je obezbijediti gorivo i to za svaku mainu posebnu vrstu
goriva. Na poetku proizvodnje imamo 84 litra goriva za mainu A, 132 litra goriva za
mainu B i 84 litra goriva za mainu C. Da bi proizveli 1 komad proizvoda x potrebno je
potroiti po tri litra goriva na mainama B i C, meutim maina A proizvede 3 litra goriva
za samu sebe. Za 1 komad proizvoda y potrebno je potroiti na mainama A, B i C
respektivno 7 litara, 5 litara i 1 litar. Postavlja se pitanje koliko komada proizvoda x i y
treba proizvesti tako da zarada fabrike bude maksimalna, ako znamo da se proizvod x
prodaje po 0,75 novanih jedinica po komadu, a proizvod y 1 novanu jedinicu po komadu.
Rjeenje ovakvog problema spada u linearno programiranje, i ovakvi problemi su esti ne
samo u industriji, ve i u ekonomiji, menagmentu itd. Ovaj problem moemo formulisati i na
slijedei (apstraktan) nain:
Neka je data objektna funkcija f = y + 3/4 x i neka su dati uslovi:
7 y - 3 x 84
5 y + 3 x 132
y + 3 x 84
Potrebno je odrediti vrijednosti x i y, takve da funkcija ima najveu moguu vrijednost
i takve da uslovi budu zadovoljeni.
Uopte formulacija ovakvih problema glasi:
Neka je data neka objektna funkcija f(x1,x2,,xn) = a1 x1+a2 x2+ +an xn od n
nepoznatih i neka je dato m nejednakosti oblika
ci1 x1+ ci2 x2+ +cin xn bi,
i 1, n
koje se zovu uslovi (ogranienja). Potrebno je odrediti ureenu n-torku (x1,x2,,xn),
pri emu xi 0 i, za koju funkcija f ima najveu vrijednost i ispunjava sve uslove.

Ovaj se problem moe rijeiti i grafikom metodom u sluaju da je broj promjenjivih

jednak 2, jer tada problem moemo predstaviti u ravni. Uopte, problem sa n promjenjivih
moe se rijeiti u n-dimenzionalnom prostoru. Poto na problem iz uvoda ima dvije
promjenjive to ga moemo rijeiti grafikom metodom.
Radi lakeg rada prvo emo definisati funkcije c1, c2, c3 koje e predstavljati uslove.
Pri tome emo znak nejednakost zamijeniti znakom jednakosti i izraziti y kao funkciju od x-a.
Za svaki od tri uslova definiimo funkcije:
In[1]:=c1[x_] :=

3/7x + 12;

In[2]:=c2[x_] :=

-3/5x + 132/5;

In[3]:=c3[x_] :=

-3 x + 84;

I za svaku od njih definiimo grafike:

In[4]:=g1

= Plot[c1[x], {x, 0, 14 }, DisplayFunction -> Identity];

In[5]:=g2

= Plot[c2[x], {x, 14, 24}, DisplayFunction -> Identity];

In[6]:=g3

= Plot[c3[x], {x, 24, 28}, DisplayFunction -> Identity];

Pri tome intervale u kojima crtamo grafike odreujemo tako to nalazimo take u kojima se
pojedine prave sijeku, npr. za prave c1 i c2 presjena taka je
In[7]:=Solve[c1[x]
Out[7]={x->14}

== c2[x], x]

Sada moemo iscrtati ova tri grafika koristei naredbu:

In[8]:=Show[{g1,

g2, g3}, DisplayFunction -> $DisplayFunction]

17.5
15
12.5
10
7.5
5
2.5
5

10

15

20

25

Povrina unutar petougla (konveksan prostor) predstavlja prostor dozvoljenih rjeenja.

Sada moramo da odredimo najveu vrijednost objektne funkcije koju on uzima unutar ovog
prostora. To moemo uraditi tako to emo crtati objektnu funkciju f = y + 3/4 x mijenjajui
vrijednost funkcije. (Uzimaemo da je f{10,20,30,40}. Prvo emo funkciju transformisati u
eksplicitni oblik. Zatim emo za svaku od ovih funkcija prikazati grafiki i smjestiti ih u
gf1,, gf4.
In[9]:=f1[x_]

:= -3/4 x + 10;

In[10]:=f2[x_]

:= -3/4 x + 20;

In[11]:=f3[x_]

:= -3/4 x + 30;

In[12]:=f4[x_]

:= -3/4 x + 40;

In[13]:=gf1

= Plot[f1[x], {x, 0, 13}, DisplayFunction -> Identity];

In[14]:=gf2

= Plot[f2[x], {x, 0, 26}, DisplayFunction -> Identity];

In[15]:=gf3

= Plot[f3[x], {x, 0, 40}, DisplayFunction -> Identity];

In[16]:=gf4

= Plot[f4[x], {x, 0, 53}, DisplayFunction -> Identity];

Crtajui ove grafike zajedno sa skupom dozvoljenih rijeanja sa naredbom:

In[17]:=Show[{g1,

g2, g3,gf1,gf2,gf3,gf4}, DisplayFunction -> $DisplayFunction]

dobijemo
Vidimo da trea prava
dodiruje konveksni prostor u taki
(24,14) i da pomjeranjem funkcije
prema etvrtoj funkciji bi sve take
koje joj pripadaju leale izvan
konveksnog prostora. Stoga je
(24,14) optimalno rjeenje naeg
problema.

40

30

20

10

Sliku moemo jo malo uljepati

dodajui komentare:
10

20

30

40

50

In[18]:=prostor

= Graphics[
Text[FontForm["Prostor dozvoljenih rjeenja", {"Tahoma", 12}], {12, 6}]];

In[19]:=optimum =
In[20]:=komentar

Graphics[{PointSize[0.03], Point[{24, 12}]}]

= Graphics[Text[FontForm[{24, 12}, {"Tahoma", 9}], {28, 12}]]

Pored toga dodajmo jo i neke atribute naoj slici: Frame, PlotLabel. Nakon svih dodataka
dobijamo:
In[21]:=Show[{g1,

g2, g3, gf1, gf2, gf3, gf4, optimum, prostor, komentar},

DisplayFunction -> $DisplayFunction, AspectRatio -> 1, PlotLabel -> "My Simplex
Machine", Frame -> True]
My Simplex

Machine

40

30

20

824, 12<
10

Prostor dozvoljenih rjeenja

0
0

10

20

30

40

50

Rjeenje ovog problema mogue je nai i koristei naredbu Maximize[].

Maximize[f,{c1,c2,,cn},{x1,x2,,xn}], gdje f predstavlja objektnu funkciju, c1,,cn uslove,
x1,,xn promjenjive funkcije f, vraa {f(x1,x2,,xn),{x1->x1,x2->x2),,xn->xn}} koja
predstavlja globalni maksimum funkcije f u oblasti odreenoj uslovima.

Koritenjem ove naredbe za rjeenje naeg problema dobijamo:

In[22]:=Maximize[y + 3/4x, {7 y
Out[22]={30, {x -> 24, y -> 12}}

- 3 x <= 84, 5y + 3x <= 132, y + 3x <= 84}, {x, y}]

Dakle optimalno rjeenje dobijamo za x=24 i y=12 i pri tome je vrijednost objektne funkcije
30.
Optimalno rjeenje zavisi od ove funkcije, tako da za razliite funkcije moemo dobiti
razliita rjeenja. Koristei naredbu Maximize ovo moemo demonstrirati.
In[23]:=k

= {3/4, 0, -1, 10};

Table[Flatten[{"koeficijent uz x je:", k[[i]],
Maximize[y + k[[i]] x, {7 y - 3 x <= 84, 5y + 3x <= 132, y + 3x <= 84}, {x,y}]}]
, {i, 1, Length[k]}]

Izvravanjem ovog koda dobijamo:

Out[23]=

3
4

{"koeficijent uz x je:", ,30,x24,y12},

{"koeficijent uz x je:",0,18,x14,y18},
{"koeficijent uz x je:",-1,12,x0,y12},
{"koeficijent uz x je:",10,280,x28,y0}}

Dakle u sluaju da je objektna funkcija f=3/4 x+y optimum je za x = 24, y =12. U sluaju da
je objektna funkcija f = 0 x + y, optimum je za x =14, y = 18 i iznosi 18, itd.

9. Gausss circle problem

Neka r(n) oznaava broj naina na koji se prirodan broj n moe predstaviti kao suma
dva kvadrata a2 + b2. Postavlja se pitanje koliko iznosi broj r(n) za dati prirodan broj n ako
smatramo da su reprezentacije a2 + b2 i b2 + a2 razliite?
Na primjer,
n = 5 = (1)2 + (2)2 r(5) = 8
n = 6 r(6) = 0, etc.
Problem odreivanja vrijednosti izraza

1
N

iN

r (i )

zove se Gausss Circle Problem.

i 0

Navedimo sad implementaciju naivnog algoritam koji rauna r(n) :

In[1]:=Gauss[n_]:=Module[{i,latis=0,v=Sqrt[n],j},

For[i=0,iFloor[v],i++, j = Sqrt[n - i^2];

If[IntegerQ[j], latis= latis + 4]
];
If[IntegerQ[v], latis= latis -4];
latis
]
Pozivajui ovu funkciju za n=100 dobijemo
In[2]:=Gauss[17]
Out[2]=8

Postoji grafika ilustracija ovog rezultata za prvi kvadrant. Crtajui krunicu sa centrom u
taki {0,0} i poluprenika 17 u prvom kvadrantu imamo:

In[2]:=Show[Graphics[{PointSize[0.04],

Circle[{0, 0}, Sqrt[17], {0, Pi/2}],

Point[{1, 4}], Point[{4, 1}]}], AspectRatio -> 1/1,
GridLines -> {Table[i, {i, 0, Ceiling[Sqrt[17]]}],
Table[i, {i, 0, Ceiling[Sqrt[17]]}]}]

Uzimajui da n ide od 0 do 19 dobijamo sljedeu tabelu:

n

r(n)

iN

1
N

1
5
9
9
13
21
21
21
25
29
37
37
37
45
45
45
49
57
61
61

5.00
4.50
3.00
3.25
4.20
3.50
3.00
3.13
3.22
3.70
3.36
3.08
3.46
3.21
3.00
3.06
3.35
3.39
3.21

i 0

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

1
4
4
0
4
8
0
0
4
4
8
0
0
8
0
0
4
8
4
0

iN

r (i )

r (i )
i 0

Ono to je interesantno jeste da vrijedi sljedei teorem:

1
N N

Theorem: lim

iN

r (i )

i 0

Neka je C(n) skup svih taaka u xy-ravni, koje lee unutar ili na krunici x2 + y2 = N. Kako je
iN

r(n) broj taaka sa cjelobrojnim koordinatama na krunici x2 + y2 = n, vidimo da je

r (i )
i 0

jednako broju taaka sa cjelobrojnim koordinatama iz C(n). Ilustrujmo to za sluaj n=17

(moete date take prebrojati runo...)

Navedimo sad modul koji za prirodan broj n crta krunicu poluprenika

cjelobrojnim koordinatama koje lee u datoj krunici

n i take sa

In[3]:=LaticePoint[n_]:=Module[{latticePoints

= {},v = Sqrt[n],x,y,w,
horizon={},vertical={},qq1,qq2,stars},
For[x = 0, x <=Floor[v], x++,
w = Sqrt[n - x^2];
For[y = 0, y <= Floor[w], y++,
If[IntegerQ[y], AppendTo[latticePoints, {x, y}];
AppendTo[latticePoints, {-x, y}];
AppendTo[latticePoints, {-x, -y}];
AppendTo[latticePoints, {x, -y}]]
]];
latticePoints = Union[latticePoints];
stars = Map[Point, latticePoints];
qq1 = Sqrt[n]; qq2 = Ceiling[qq1];
horizon = Table[Line[{{-qq2, i}, {qq2, i}}], {i, -qq2, qq2}];
vertical = Table[Line[{{i, -qq2}, {i, qq2}}], {i, -qq2, qq2}];
Show[Graphics[{PointSize[0.03], stars, Point[{0, 0}], horizon,
vertical, Thickness[0.01], Circle[{0, 0}, qq1]}],
AspectRatio -> Automatic];
]

Pozivajui ovaj modul za n=70 imamo:

In[4]:=LaticePoint[70]

Provjerimo sad teorem koji smo naprijed naveli. Sljedei modul za prirodan broj n rauna
iN

r (i ) .
i 0

In[5]:=pii[x_]:=Module[{i,sigma=0},

For[i=0,ix,i++,
sigma=sigma+Gauss[i]
];
Return[ N[(sigma+1)/x] ]
]
Pozivajui ovaj modul za n=2000 dobijemo:
In[6]:=pii[2000]
Out[6]=3.1465

10. Zig-Zag
Uzmimo horizontalnu liniju duine 100 i dva ugla i , za koje pretpostavimo da su
cijeli brojevi razliiti od nule, u stepenima, i uzmimo du duinu l ( ili R). Na kraju
horizontalne linije duine 100 docrtamo drugu horizontalnu liniju duine l. Sada poinjemo sa
zig-zagom (cik-cak) docrtavajui sekvencu linija duine 100, l, 100, l, 100, l,... u smjeru
suprotnom od kretanja kazaljke na satu i pod uglovima , , 2, 2 , 3, 3 ,... u odnosu na
horizontalu (Sl. 1.). Sve linije duine 100 nazivamo zig ili cik a sve linije duine l nazivamo
zags ili cak. Interesantna je stvar da se konstrukcija zig_zags uvijek zatvara. Broj koraka, gdje
je jedan korak =jedan zig +jedan zag, potrebnih za zatvaranje zigzaga je dat formulom:
360
.
NZD(360, , )

10
0

100

10

sl.1
Naredni modul iscrtava zig-zag-ove za dato (l, , ) na nain kako je prethodno
opisano koristei funkciju Rotat2D koja se nalazi u paketu Rotations, kojeg uitavamo sa
sljedeom naredbom:
<<Geometry`Rotations`
ZigZag[al_,ua_,ub_]:=Module[{aa=ua,bb=ub,a={},b={},k,l={},p,j},
b={100,0};
a={al,0};l={};
k={a[[1]]+b[[1]],0};
AppendTo[l,Line[{{0,0},{a[[1]],0}}]];
AppendTo[l,Line[{{a[[1]],0},{a[[1]]+b[[1]],0}}]];
For[j=1;i=3,j360/GCD[360,Abs[aa],Abs[bb]],j++,
p=Rotate2D[k+b,-(i-2)*Pi*aa/180,k];
AppendTo[l,Hue[0.7]];AppendTo[l,Line[{k,p}]];
k=p;p=Rotate2D[k+a,-(i-2)*Pi*bb/180,k];
AppendTo[l,Hue[0.1]];AppendTo[l,Line[{k,p}]]; k=p; i++;
];
Show[Graphics[l],AspectRatioAutomatic]
]

Trojke koje crtaju estougao, krug i elipsu su sljedee (0,60,120), (0,10,60), (30,1,-1)

(0,60,120)

(0,10,60)

(30,1,-1)

Za trojke (100,90,-40), (100,62,-60), (100,19,-20), (200,5,6), (200,299,46), (100,175,185),

(100,55,22) (100,20,207), (500,155,300) dobijemo redom sljedee figure:

(100,90,-40)

(200,5,6)

(100,55,22)

(100,62,-60)

(200,299,45)

(100,20,207)

(100,19,-20)

(100,175,185)

(500,155,300)

11. Problem trgovakog putnika

Problem trgovakog putnika moe se lijepo ilustrovati jednim primjerom.
Pretpostavimo da jedan trgovaki putnik stanuje u nekom gradu. On dobije zadatak da obie
odreen broj gradova i u svakom od njih predstavi proizvod svoje firme. Njemu su poznate
udaljenosti izmeu svaka dva grada i poznato mu je vrijeme za koje moe prei ove
udaljenosti. Postavlja se pitanje: kojim redoslijedom treba posjeivati gradove tako da obavi
svoj zadatak u najkraem moguem vremenu i opet vrati u polazni grad.
Ovaj problem je jedan od najinteresantnijih problema informatike i razvijane su razne metode
za njegovo rjeavanje, meutim sve su zavrile na pokuaju.
Problem se na lagan nain moe prevesti u svijet grafova2. Pri tome svaki vor
predstavlja jedan grad, a ivice koje spajaju vorove puteve izmeu tih gradova. Pri tome
svaka ivica ima svoju teinu u zavisnosti od udaljenosti gradova, tj. vremena potrebnog da se
ova udaljenost pree. Naime jednaka udaljenost ne povlai uvijek i isto vrijeme. Pri tome je
bitno napomenuti da su svaka dva vora povezana, tj. radi se o potpunom grafu.
Prvo emo rijeiti ovaj problem koristei se funkcijom TravelingSalesman iz paketa
DiscreteMath`Combinatorica`, a zatim emo provjeriti tanost rjeenja tako to emo
pjeke pronai najkrai put.
Meutim prije nego ponemo, prvo emo formirati matricu pripadnosti vorova koji emo
nazvati matrica. Pri tome e mjesto presjeka i-te vrste i j-te kolone sadravati vrijeme
potrebno za prelaenje udaljenosti od i-tog do j-tog vora (grada). Koristiemo naredbu
Table[].
In[1]:=matrica = Table[If[i == j, 0, Random[Integer, {10, 50}]], {j,
Out[1]= {{0, 26, 42, 27, 20}, {50, 0, 31, 40, 44}, {10, 14, 0, 30, 22},

1, 5}, {i, 1, 5}]

{30, 23, 33, 0, 45}, {27, 48, 27, 23, 0}}

Da bismo preglednije predstavili ovu matricu moemo koristiti naredbu:
In[2]:=MatrixForm[matrica]

0
50

Out[2]= 10
30
27

26

42 27 20

31 40 44

14

30 22

23 33

48 27

23

45
0

Sad u matrici imamo smjetene ivice. Meutim, paket moe raditi sa specijalnim skupovima
oblika Graph[skup ivica (matrica), skup vorova]. Da bismo na graf predstavili u takvom
obliku iskoristiemo naredbu Vertices[CompleteGraph[5] ].
Vertices[graf] vraa vorove graf-a u obliku koordinata svakog vora u grafu.
Edges[graf] vraa ivice graf-a u obliku matrice pripadnosti vorova.
In[3]:=mojGraf

= Graph[matrica, Vertices[CompleteGraph[5]]];

Sada mojGraf sadri sve potrebne podatke o naem grafu i sve je spremno za pozivanje
funkcije TravelingSalesman.
In[4]:=tour = TravelingSalesman[mojGraf]
Out[4]={1, 5, 4, 2, 3, 1}
2

Neka je X neprazan skup a U neka binarna relacija u X. Tada ureeni par G=(X ,U) nazivano grafom.
Elementi skupa X su vorovi grafa , a elementi skupa U su grane grafa.

Dakle, dobili smo najkrai put kojim treba obilaziti vorove. Da bismo izraunali koliko je
vremena potrebno za obilazak grafa ovim redosljedom potreban nam je slijedei kod.
In[5]:=

cost = 0;
For[i = 1, i <= 5, i++,
cost = cost + matrica[[tour[[i]], tour[[i + 1]]]]
];
cost

Za svaku ivicu izmeu dva vora oitavamo teinu ivice iz matrice i dodajmo je promjenjivoj
cost. Na kraju e promjenjiva cost sadravati ukupnu teinu puta.
Primijetimo da je ovaj kod mogue napisati i na drugi nain koristei naredbu Sum.
In[6]:=cost=Sum[matrica[[tour[[i]],tour[[i+1]]]],{i,1,5}]
Out[6]=107

Izvravanjem bilo kojeg od ova dva koda dobijamo kao rezultat 107. Pa vidim da je najkraa
duina puta 107 jedinica.
Da bismo se uvjerili u tanost ove funkcije iz paketa, napiimo kod koji e traiti najkrai put
tako to e raunati duine svih moguih puteva kroz graf. Pri tome emo korisiti naredbu
Permutations.
U skup allTours smjestimo permutacije puteva kroz graf. Inicijalizirajmo prazan skup
w. Za svaku permutaciju raunajmo teinu puta. Poto skup permutacija ne sadri vezu
izmeu zadnjeg i poetnog vora, moramo nakon svakog raunanja na sumu dodati i teinu
zavrnog puta, tj. teinu puta izmeu petog i prvog vora. Svaku izraunatu duinu puta
dodajmo skupu w.
Izvravanjem sljedeeg koda
In[7]:=allTours = Permutations[{1, 2, 3, 4, 5}];
w = {};
For[i = 1, i <= 120, i++,
cost1 = 0;
For[j = 1, j <= 4, j++,
cost1 = cost1 + matrica[[allTours[[i, j]], allTours[[i, j + 1]]]]
];
cost1 = cost1 + matrica[[allTours[[i, 5]], allTours[[i, 1]]]];
AppendTo[w, cost1]
]
i izvravanjem
In[8]:=w

dobijamo slijedei output:

Out[8]={159,

132, 148, 148, 157, 136, 168, 153, 166, 215, 182, 160, 130, 131, 145, 180, 161,
163, 159, 151, 131, 150, 107, 140, 215, 160, 180, 163, 150, 140, 161, 107, 159, 159, 130, 132,
182, 131, 151, 148, 168, 148, 166, 145, 131, 157, 153, 136, 148, 136, 131, 161, 151, 107, 163,
140, 131, 168, 145, 153, 157, 159, 150, 166, 159, 215, 148, 130, 180, 182, 132, 160, 132, 157,
153, 182, 159, 131, 160, 150, 107, 130, 166, 131, 136, 151, 140, 145, 148, 180, 159, 168, 215,
161, 148, 163, 159, 148, 168, 166, 130, 145, 215, 180, 161, 159, 182, 151, 148, 131, 163, 131,
157, 150, 132, 153, 160, 107, 136, 140}
Najkrai put kroz graf je prema tome:
In[9]:=Min[w]
Out[9]=107

Dakle, funkcija TravelingSalesman daje rjeenje koje se podudara sa rjeenjem koje

smo mi dobili. Da bismo odredili poredak posjete vorova odredimo na kojim mjestima u
skupu se nalazi ova najmanja teina puta kroz graf, tj. kojim permutacijama ona odgovara:
In[10]:=Position[w, Min[w]]
Out[10]={{23}, {32}, {54}, {81},

{118}}

Dakle, 23, 32, 54, 81, 118 su permutacije osnovnog puta kroz graf koje daju put najkrae
duine. Ispiimo sada koji su to putevi. Da bismo to izveli potreban nam je slijedei kod.
u = Flatten[Position[w, Min[w]]];
Table[allTours[[u[[i]]]], {i, 1, Length[u]}]

In[11]:=

U skup u smjestimo ispeglan prethodni skup. Sada formirajmo skup koji e sadravati
one permutacije puteva koje se nalaze na mjestima najkraih puteva.
Kada izvrimo ovaj kod dobijamo slijedee:
Out[11]={{1,

5, 4, 2, 3}, {2, 3, 1, 5, 4}, {3, 1, 5, 4, 2}, {4, 2, 3, 1, 5}, {5, 4, 2, 3, 1}}

Vidimo da postoji pet puteva kroz graf koji svi imaju istu duinu. Meutim kada bolje
pogledamo uoavamo da su svi ovi putevi ekvivalentni i da im je jedina razlika poetni vor,
tj. da se samo razlikuju jedan od drugog po tome koji vor je izabran za polaznu taku.

12. Kodiranje tajnih poruka sa RSA algoritmom

Jedna od veoma znaajnih primjena teorije brojeva jeste i slanje tajnih poruka u ifrovanoj
formi. U 1978 R. Rivest, A. Shamir i A.M. Adelman su otkrili veoma efikasan metod ( i
odgovarajui algoritam) za ifrovanje i deifrovanje tekstualnih poruka. Rije efikasan se
odnosi na injenicu da je veoma teko otkriti klju da bi se razbila ifra. To se bazira na
injenici da je veoma teko faktorisati veoma velike prirodne brojeve, te specijalno faktore
broja koji je proizvod dva veoma velika prosta broja.

RSA algoritam
Pretpostavimo da osoba A treba da poalje osobi B poruku koja koja je od velike vanosti za
osobu B, a pri tome je niko drugi ne smije proitati. Na primjer:

Veceras ce u ponoc napasti. Nadjimo se na starom mjestu u 21:00.

Prvo, osoba A mora pretvoriti poruku u broj (ili u niz brojeva ako je poruka preduga). To se
moe uraditi na mnogo naina, na primjer, koritenjem ASCII ifre znakova u poruci.
U programskom paketu Mathemtica postoje dvije ugraene funkcije koje string znakova
konvertuju u niz ASCII kodova i obrnuto. (ToCharacterCode i FromCharacterCode).
In[1]:=m

= ''Veceras ce u ponoc napasti. Nadjimo se na starom mjestu u 21:00''

In[2]:=u =

ToCharacterCode[m] 31

Out[2]={

55, 70, 68, 70, 83, 66, 84, 1, 68, 70, 1, 86, 1, 81, 80, 79, 80, 68, 1, 79, 66, 81, 66, 84,
85, 74, 15, 47, 66, 69, 75, 74, 78, 80, 1, 84, 70, 1, 79, 66, 1, 84, 85, 66, 83, 80, 78, 1, 78, 75,
70, 84, 85, 86, 1, 86, 1, 19, 18, 27, 17, 17 }
Pretpostavimo da osoba B ima dva velika prosta broja, p i q, i da je uinila javnim
njihov proizvod. Osoba B, takoer, mora uzeti, eksponent za kriptovanje nazvan e, koji je,
takoer, javan, pri emu, e mora biti relativno prosto sa (p-1) (q-1). Osobi B nije teko da
nae takav broj jer poznaje brojeve p i q. Ureeni par (n, e) naziva se javnim kljuem i on je
jedino potreban da osoba A poalje poruku osobi B. Iako je klju (n, e) javan, osoba B je

jedina koja zna p i q, pa moe da izrauna vrijednost (n) Eulerove funkcije. Navedimo sad
definiciju Eulerove funkcije (n) , Eulerov teorem i jednu Lemu koje e nam koristiti za
deifrovanje poruke.
Definicija: Neka je n 0 i neka (n) oznaava broj prirodnih brojeva x za koje vrijedi
1 x n i koji su uzajamno prosti sa n. Funkciju (n) nazivamo Euler-ovom funkcijom.
Teorem (Euler): Ako je m 0 i (a, m) 1 , tada je a ( m) 1(mod m) .
Lema: Pretpostavimo da je s relativno prost sa a i b i da je a b(mod (n)) . Tada je

s a s b (mod n) .
Osoba A e uzeti svoju poruku i pretvorit je u broj na nain da lista u predstavlja cifre
broja u bazi 100 (pretpostaviemo da nee biti vie od 100 razliitih znakova u poruci m), a
zatim izraunati s = me (mod n) te dobijeni broj poslati otvorenom linijom osobi B.
Kako je e relativno prosto sa (p-1) (q-1) osoba B e moi da izrauna broj d takav da je
de 1(mod (n)) . Broj d emo zvati klju za deifrovanje. Kako je de 1(mod (n)) , to
na osnovu prethodne Leme i Euler-ovog teorema dobijemo da je s d m(mod n)
Da bismo izraunali s = me (mod n) koristimo ugraenu funkciju u programsko paketu
Mathematica PowerMod[a,b, n] koja rauna ab (mod n ) , a ako je b negativan onda odreuje
broj k takav da je kab 1(mod n ) .
Navedimo sad modul koji vraa prvi prost broj koji je vei od datog broja, kao i modul koji za
prirodan broj n vraa sluajan prost broj koji ima barem n cifara.
In[3]:=

nextPrime[n_] := Module[{j = n},

While[! PrimeQ[j], j += 1]; j]

Na primjer, za n=10 imamo

In[4]:= nextPrime[10]
Out[4]=11
In[5]:=moveRandomPrime[d_] :=

Module[{qq, ww},

qq = Table[Random[Integer, {0, 9}], {d}];

qq = FromDigits[qq];
qq = nextPrime[qq];
While[Length[IntegerDigits[qq, 10]] != d, moveRandomPrime[d]];
qq
]
Za d=10 dobijemo sluajan prost broj sa 10 cifara:
In[6]:= moveRandomPrime[10]
Out[6]= 4937034409

Formirajmo sada broj od cifara iz liste u bazi 100. To emo uraditi sa sljedeim naredbama
In[7]:=v

= Reverse[Range[0, Length[u] - 1]];

w = 100^v;
codedMessage = u.w

i odgovarajui broj je

Out[7]=557068708366840168700186018180798068017966816684857415476669757478800

1847001796601848566838078017875708485860186011918271717
Generiimo sad proste brojeve p i q od 100 i 50 cifara redom
In[8]:=p =

moveRandomPrime[100]

Out[8]=4831265603021480184849695498786959608096231314439085549007367345780277

997438500411764013855846850561
In[9]:=q =

moveRandomPrime[50]

Out[9]=13859881529304149621457447513785297873362935672349

Stavimo da je
In[10]:=e

= 17
n = p*q

Out[10]=66960768894479887408557170376531472206086037851181149808380768837212

927617820407809366608416479690376665026667118847384673050870196885426130662
837789
Izraunajmo s i d:
In[11]:=s

= PowerMod[codedMessage, e, n]

Out[11]=363403241455381445689760372647172565889677240871404661577472393529172

807497527062144229765846442721420571896375030116858930985481552997730538132
77712
In[12]:=d

= PowerMod[e, -1, (p - 1) (q - 1)]

Out[5]=4332755634348698597024287494952036436864390684487879435120913064278287

394973751937337315494334222141469514796912694660808234196564694464282533432
1393
Izraunajmo sad m koristei s i d
In[13]:=desifrat

= PowerMod[s, d, n]

Out[13]=557068708366840168700186018180798068017966816684857415476669757478800

1847001796601848566838078017875708485860186011918271717
In[14]:=z =

IntegerDigits[desifrat, 100]

Out[14]={55,

70, 68, 70, 83, 66, 84, 1, 68, 70, 1, 86, 1, 81, 80, 79, 80, 68, 1, 79, 66, 81, 66, 84,
85, 74, 15, 47, 66, 69, 75, 74, 78, 80, 1, 84, 70, 1, 79, 66, 1, 84, 85, 66, 83, 80, 78, 1, 78, 75,
70, 84, 85, 86, 1, 86, 1, 19, 18, 27, 17, 17}
In[15]:=FromCharacterCode[z + 31]
Out[15]= Veceras ce u ponoc napasti.Nadjimo se

na starom mjestu u 21:00

Pa vidimo da se deifrovana poruka podudara sa porukom koju je osoba A poslala osobi B.

13. Modeliranje problema diferentnim jednainama i njihovo

rjeavanje primjenom programskog paketa Mathematica
Poslije ubojstva (ili smrt prouzrokovane na neki drugi nain), jedna od prvih stvari
koju forenziar uradi jeste da izmjeri temperaturu tijela unesreenog. Malo kasnije
temperatura se opet mjeri kako bi se stvorila slika o brzini hlaenja tijela. Ove dvije, ili vie
injenica se mogu iskoristiti da se odredi kad se smrt desila.
Pretpostavimo da je tijelo otkriveno u motelskoj sobi u pono, i njegova temperatura
je iznosila 80F. Temperatura sobe je odravana konstantno na 60F. Dva sata kasnije
izmjerena je temperatura tijela i iznosila je 75F. Potrebno je odrediti vrijeme smrti.
Iz eksperimentalnih pokusa je poznato da je brzina promjene temperature na povrini
objekta proporcionalna razlici izmeu njegove temperature i temperature okoline. Ovo je
poznato kao Njutnov zakon hlaenja.
Ako sa T(n) oznaimo temperaturu tijela poslije 2n sati iza ponoi dati problem moemo
modelirati sa sljedeom diferentnom jednainom

T (n 1) T (n) k (T (n) 60)

pri emu je k 0 koeficijent proporcionalnosti kojeg trebamo odrediti.
Kako je T (0) 80 i T (1) 75 to za n 0 data jednaina postaje 75 80 k (80 60) ,
pa dobijemo da je k 0.25
Da bismo odredili T(n) koristiemo funkciju RSolve koja ima slijedeu sintaksu
RSolve[equ, a[n], n] rjeava rekurzivnu jednainu equ po a[n]
RSolve[{ equ1, equ2, ... } , { a1[ n ], a2[ n ], ... } , n ] rjeava sistem rekurzivnih jenaina
equ1, equ2,...
Odnosno, za nau jednainu imamo
In[1]:=RSolve[{a[n +

1] - a[n] == -k( a[n] - 60), a[0] == 80}, a[n], n]

I kao rezultat izvravanja ove naredbe dobijemo:

Out[1]={{a[n] 20(-30-1-k)

)}}

Kako je k 0.25 i temperatura tijela u trenutku smrti 98.6 F (to je normalna temperatura
tijela) to treba odrediti n tako da bude

60 0.75n 20 98.6
Da bismo odredili n koristiemo naredbu NSolve kojom emo rijeiti datu jednainu po n pa
imamo slijedei kod
In[2]:= NSolve[60

+ 20 * 0.75^n == 98.6, {n}]

i kao rezultat dobijrmo

Out[2]={{n-2.285578650463187`}}

Kao samo sa T(n) oznaili temperaturu poslije 2n sati nakon ponoi, to imamo da je smrt
nastupila prije 2 * 2.28558 4.57116 sati prije ponoi, tj. oko 19 : 26h .