Predavanje 10: Glava 29

FlipView[{Text[Style[" Branko Urošević, imqfbrankourosevic@gmail.com ",20,"Text",Italic]],Text[Style[" Faculty of Economics, University of Belgrade, NBS and CESIfo Munich",20,"Text", Italic]]}]

29. Više o čistim funkcijama i rekurzijama

Array

Videli smo kako možemo da pravimo liste pomoću Table. Postoji još jedan način koji koristi čiste funkcije, preko Array. Mada ova funkcija ne daje ništa što ne možemo da uradimo pomoću Table, korisna je da se pomoću nje uvedu čiste funkcije sa više promenljivih.

Generišimo Array dimenzije 10 za apstraknu funkciju f:

f/@Range[10]

Array[f,10]

Primetimo da je to zapravo isto što i

Array[f[#]&,10]

Koristeći Table to bismo mogli da  uradimo ovako:

Table[f[i],{i,10}]

Primeri Array u jednoj dimenziji

Sintaksa, u slučaju Array, u jednoj dimenziji jeste da broj koji stavimo posle zareza definiše dimenziju liste koja se generiše. Takođe, odbrojavanje počinje od 1 (kao i u slučaju Table po defoltu, mada kod Table to možemo da menjamo).

Nađimo pomoću Array brojeve od 1 do 10 kao i kvadrate tih brojeva:

(#^2+4#)&@5

?

Array[(#^2+4#)&,5,10]

Array[#&,10]

Array[#^2&,10]

Pomoću Table pišemo to ovako:

Table[i,{i,10}]

Table[(i^2),{i,10}]

Pravljenje matrica pomoću Array

Ukoliko želimo da koristimo Array da pravimo matrice, u principu moramo da koristimo čiste funkcije sa dve promenljive. Evo primera kada to nije striktno neophodno (jer WL to podrazumeva). Konstruišimo matrice f[i,j] gde indeks i ide od 1 do 3, a indeks j ide od 1 do 4. Pomoću Table to radimo ovako:

Table[f[i,j],{i,3},{j,4}]

Ukoliko stavimo u Grid dobijamo

Table[f[i,j],{i,3},{j,4}]//Grid

To isto možemo da uradimo pomoću Array ovako

Array[f,{3,4}]//Grid

Prost način da napravimo tablicu množenja i tablicu sabiranja

Ukoliko je funkcija f funkcija Times, Array daje tablicu množenja:

Array[((#)^2)+4#&,6,{5,10}]

Array[Times,{10,10}]//Grid

Grid[Array[Times,{10,10}]]

A evo i tablice sabiranja

Grid[Array[Plus,{10,10}]]

Pomoću Table to postižemo na sledeći način:

Grid[Table[i j,{i,10},{j,10}]]

Grid[Table[i+ j,{i,10},{j,10}]]

Čiste funkcije sa više argumenata

Function[{x,y},Sin[x y]+(Sqrt[x+2y])][10,20]

Function[{x,y},Sin[x y]+(Sqrt[x+2y])][(a^2),c-3]

Sin[#1 #2]+(Sqrt[#1+2 #2])&[10,20]

Šta da radimo ako želimo da koristimo, ekplicitno, čistu funkciju umesto Times ili Plus? Pošto sada imamo 2 argumenta ovde, potrebno nam je da znamo kako rade čiste funkcije sa dva ili više argumenata. U slučaju čiste funkcije sa dva argumenta, #1 predstavlja prvi argument, #2 predstavlja drugi argument itd. Ovde je prvi argument 42 a drugi 32.

f[#1,#2]&[42,32]

U punoj formi, ova čista funkcija se definiše ovako:

Function[{x,y},f[x,y]][42,32]

Dakle, prvo imamo naziv Function, onda listu parametera funkcije {x,y} i najzad telo funkcije, f[x,y]. Prvi argument koji dajemo primenjuje se na mestu x, a drugi na mestu y.

Function[{x,y},f[x,y]][42,32]

Primer čiste funkcije sa dva argumenta

Razmotrimo sada funkciju

(2 ((#1)^2)+#1*#2+((#2)^2))&

To je funkcija koja ima dva argumenta i koja vrednost prvog argumenta množi sa drugim, i tome dodaje kvadrat vrednosti drugog argumenta. U punoj formi, ona se piše ovako:

Function[{x,y},2 (x^2)+x y +(y^2)]

Ukoliko je prvi argument jednak 10 a drugi jednak 5, trebalo bi da oba izraza daju

10 5 +(5^2)

Naravno, to i dobijamo

(#1*#2+((#2)^2))&[10,5]

Function[{x,y},x y +(y^2)][10,5]

Sa čistim funkcijama više promenljivih može da se radi kao i predefinisanim funkcijama

Na primer, možemo da grafički predstavimo ovu funkciju

Plot3D[(2 ((#1)^2)+4Sin[#1*#2]+((#2)^2))&[x,y],{x,-3,3},{y,-5,5}]

(2 ((#1)^2)+#1*#2+((#2)^2))&

Plot3D[(#1*#2+((#2)^2))&[x,y],{x,-3,3},{y,-5,5}]

a to isto možemo da postignemo i koristeći punu formu

Plot3D[Function[{x,y},x y +(y^2)][a,b],{a,-3,3},{b,-5,5}]

Naravno, ne moramo da koristimo a i b nego opet x i y ako želimo

Plot3D[Function[{x,y},x y +(y^2)][x,y],{x,-3,3},{y,-5,5}]

Primena čistih funkcija sa dve promenljive u Array

Razmotirmo Array koji pokazuje matrične elemente matrice 4x4.

Array[{#1,#2}&,{4,4}]

Array[{#1,#2}&,{4,4}]//Grid

Vidimo da je prvi slot zamenjen sa prvim argumentom, a drugi sa drugim. Razmotrimo Array dimenzija 4x4 kod koga je  vrednost prvog argumenta veća od drugog. U tom slučaju:

ArrayPlot[Boole[Array[#1>=#2&,{100,100}]]]

ArrayPlot[Boole[Array[#1>#2&,{4,4}]]]

Boole[Array[#1>#2&,{4,4}]]

Array[#1>#2&,{4,4}]//Grid

Pošto je kod elementa (1,1) prvi element jednak drugom, dobija se False. Pošto je kod (1,2), (1,3) itd prvi element manji od drugog opet dobijamo False. Ali, (2,1) daje True, pošto je prvi element (2) veći od drugog (1). Ovo je može predstaviti na razne ekvivalentne načine:

Array[Greater[#1,#2]&,{4,4}]//Grid

Array[Function[{prvi,drugi},prvi>drugi],{4,4}]//Grid

Array[Greater,{4,4}]//Grid

Pretvaranje logičkih True i False u 1 i 0 pomoću funkcije Boole

Ukoliko želimo da logičke True i False pretvorimo u brojeve (1 odnosno 0) možemo da koristimo Boole

{Boole[True],Boole[False]}

Pošto je Boole Listable funkcija

Table[If[i>j,1,0],{i,4},{j,4}]//ArrayPlot

ona se automatski mapira sa svaki element neke složene liste koja se sastoji od True i False elemenata. Na primer

Array[#1>#2&,{4,4}]

Boole[Array[#1>#2&,{4,4}]]

Pomoću Table to isto možemo dobiti i ovako:

Table[If[i>j,1,0],{i,4},{j,4}]//Grid

Načini vizualizacije bulovih matrica

Koristeći Grid

Boole[Array[#1>#2&,{4,4}]]//Grid

Drugi način je da iskoristimo ArrayPlot:

ArrayPlot[Boole[Array[Greater,{4,4}]]]

Treći je da koristimo MatrixForm

?a

Clear[a]

3a

a=Table[If[i>j,1,0],{i,4},{j,4}];MatrixForm[a]

MatrixForm[2Table[If[i>j,1,0],{i,4},{j,4}]]

2MatrixForm[Table[If[i>j,1,0],{i,4},{j,4}]]

MatrixForm[Table[If[i>j,1,0],{i,4},{j,4}]]

Pravljenje jedinične matrice na razne načine

Evo jednog načina da dobijemo jediničnu matricu dimenzija 5x5. Koristimo predefinisanu funkciju IdentityMatrix.

DiagonalMatrix[{3,-2,4,5}]//MatrixForm

IdentityMatrix[5]

Kako bismo mogli da je generišemo pomoću Array? Na mnogo načina:

Boole[Array[Equal,{5,5}]]

Array[#1==#2&,{5,5}]

Boole[Array[#1==#2&,{5,5}]]

ili

Boole[Array[Function[{prvi,drugi},prvi==drugi],{5,5}]]

Kako generisati vektor ili matricu sa konstantnim elementima

Evo kako možemo generisati vektor ili matricu sa identičnim elementima jednakim 1/10

ConstantArray[1/10,{12}]

ConstantArray[1/10,{3,5}]

Koristeći Table to isto možemo da uradimo ovako

Table[1/10,12]

Table[1/10,{i,3},{j,5}]

Sada sistematičnije o čistim funkcijama sa više argumenata

f[#1,#2]&[55,66]

#1 uvek predstavlja prvi argument, a  #2 predstavlja drugi:

f[#2,#1,{#2,#2,#1}]&[55,66]

U punoj formi, ovu drugu funkciju možemo da napišemo ovako:

Function[{x,y},f[y,x,{y,y,x}]][55,66]

Već smo videli neke primere kako #1 i #2 možemo da koristimo unutar funkcije Array. Evo još primera

Array[f[#1,#2]&,{3,4}]

Array[#1*#2&,{10,10}]//Grid

Malo složeniji primeri konstrukcije Array pomoću čiste funkcije

Ukoliko je prvi argument jednak drugom funkcija dodeljuje uramljenu vrednost x, inače radi tablicu množenja:

Array[If[#1==#2,Framed[x],#1*#2]&,{10,10}]//Grid

U punoj formi ovaj izraz bi bio:

Array[Function[{a,b},If[a==b,Framed[x],a*b]],{10,10}]//Grid

A evo kako bismo ovo mogli uraditi preko Table:

Table[If[i==j,Framed[x],i*j],{i,10},{j,10}]//Grid

NestList i Nest: podsetnik

Prethodno smo naučili nešto o NestList. Kao prvi argument u NestList koriste se čiste funkcije sa jednim argumentom. Pre nego što pređemo na FoldList gde koristimo čiste funkcije sa dva argumenta, obnovimo neke stvari vezane za NestList. NestList uzima jednu funkciju, recimo f, i primenjuje je više puta:

Pretpostavimo da na  broj 100 primenimo prirodni logaritam 1, 2, .., do 5 puta. Kakve brojeve dobijamo? Zanimaju nas numeričke vrednosti pa je zgodno početi od 100. a ne od egzaknog broja 100. U tom slučaju će output biti numerički (brojevi sa decimalnim zarezom).

NestList[Log,100,5]

NestList[Log,10000000,6]//N

Vidimo da u poslednjoj iteraciji imamo logaritam negativnog broja. To nije definisano na skupu realnih brojeva. Stoga smo kao rezultat dobili kompleksni broj (ovi brojevi su uopštenje skupa realnih brojeva).

Ukoliko nas zanima da odmah vidimo rezultat 4. iteracije koristimo Nest.

Nest[Log,100.,4]

Iteracije funkcije (x^2)-2 x.

ListLinePlot[NestList[((#)^2)-2#&,0.5,30]]

FixedPoint[((#)^2)-2#&,0.5,30]

NestList[((#)^2)-2#&,0.5,30]

FixedPoint[((#)^2)-2#&,0]

NestList[((#)^2)-2#&,0,10]

NestList i Nest su veoma moćne funkcije. Pretpostavimo da hoćemo da 10 puta primenimo funkciju (x^2)-2 x počevši od vrednosti x=1. U tom slučaju:

FixedPoint[((#)^2)-2#&,1]

NestList[((#)^2)-2#&,1,10]

Primetimo da ovde postoji fiksna tačka za ovo mapiranje i jednaka je x=3.

Fiksna tačka pomoću FixedPoint

Ovu fiksnu tačku možemo dobiti odmah, na sledeći način.

FixedPoint[((#)^2)-2#&,1]

Ali to nije jedna jedina fiksna tačka. Naime, pretpostavimo da smo počeli od x=0. U tom slučaju uvek bismo ostali na 0. Naime

NestList[((#)^2)-2#&,0,10]

FixedPoint[((#)^2)-2#&,0]

Da li ćemo dospeti u fiksnu tačku zavisi od toga odakle krenemo

Šta bismo dobili ukoliko počeli od, npr, 0.5?

NestList[((#)^2)-2#&,0.5,10]

Vidimo da x=0.5 nije fiksna tačka ali ni ne konvergiramo ka fiksnoj tački ako krenemo od 0.5. Probajmo naime:

FixedPoint[((#)^2)-2#&,0.5]

Drugim rečima, pojam fiksne tačke je dosta zeznut. Čak i jednostavne funkcije mogu imati više od jedne fiksne tačke a da li ćemo u neku od njih dospeti zavisi od toga odakle počnemo!

Primena NestList u geometriji: rotiranje trougla

Važno je napomenuti da možemo raditi iteracije potpuno različitih stvari. Evo, šta na primer, dobijamo ako počnemo od nekog trougla.

tri=Triangle[{{0,0},{1,0},{1/2,(Sqrt[3])/2}}];

Koristeći Directives (direktive) možemo definisati malo lepšte vizualnu formu objekta:

Graphics[{LightBlue,EdgeForm[Red],tri}]

Rotate[#,π/13,RegionCentroid[tri]]&[Graphics[{LightBlue,EdgeForm[Red],tri}]]

Pretpostavimo da sada hoćemo da rotiramo ovaj trougao oko njegovog centra mase (RegionCentroid) za ugao π/13. I to hoćemo da uradimo više puta. Da bismo to postigli možemo da definišemo sledeću čistu funkciju

Rotate[#,π/13,RegionCentroid[tri]]&

Rotate[#,π/13,RegionCentroid[tri]]&[Graphics[{LightBlue,EdgeForm[Red],tri}]]

Iterativna primene prethodno definisanje funkcije rotacije

Evo kako će izgledati kada tu funkciju primenimo iterativno 5 puta. Ovde ćemo prvo napraviti listu trouglova, pa onda primeti Graphics tako da ćemo dobiti samo jednu sliku umesto liste slika pojedinačnih rotiranih trouglova). Da bismo bolje razlikovali trouglove, napravićemo veću prozračnost (Opacity)

NestList[Rotate[#,π/13,RegionCentroid[tri]]&,Graphics[{LightBlue,Opacity[0.5],EdgeForm[Red],tri}],5]

Graphics[{LightBlue,Opacity[0.5],EdgeForm[Red],NestList[Rotate[#,π/13,RegionCentroid[tri]]&,tri,5]}]

Paralelni pomeraj (translacija)

Razmotrimo sada paraleni pomeraj (Translate). Definišimo vektore paralelnog pomeraja na sledeći način:

vecs=(1/2){{0,0},{1,0},{1/2,(Sqrt[3])/2}};

Ova čista funkcija definiše paralelno pomeranje u tri pravca definisana sa vektorima-podlistama u vecs. Jedan od njih ništa ne pomera (vektor {0,0}).

Translate[#,vecs]&

Evo kako bismo sada to iterirali:

Graphics[{Opacity[0],EdgeForm[Gray],NestList[Translate[#,vecs]&,tri,1]}]

NestWhileList i NestWhile

Funkcije NestList i Nest specifikuju funkciju koja mora da se iterira, početnu vrednost na koju se primenjuje funkcija kao i broj iteracija. Često nije najbolja ideja unapred zadati broj iteracija. Umesto toga, želimo da se zaustavimo onda kada se za to ispuni određeni uslov. Evo primera:

Naći broj iteracija funkcije Log potreban da iterativna primena Log na broj 10000 da broj koji je manji od 0. U tu svrhu postoji NestWhileList. Sintaksa je da prvo pišemo funkciju koju iteriramo, onda početnu tačku, i na kraju uslov za nastavak iteracije (While).

NestWhileList[Log,10000000.,Log[#]>=0&]

NestWhileList[Log,10000.,Log[#]>=0&]

Primetimo da se ovo može napisati i na sledeće načine (imamo na dva mesta odvojene definicije čistih funkcija jednog parametra):

NestWhileList[Log[#]&,10000.,Log[#]>=0&]

Evo i drugog načina da se to napiše

NestWhileList[Function[{x},Log[x]],10000.,Function[{y},Log[y]≥ 0]]

Prva naredna iteracija bi dala broj manji od 0. Stoga je potreban broj iteracija u ovom slučaju

NestWhileList[Log,10000.,Log[#]>0&]

Length[NestWhileList[Log,10000.,Log[#]>0&]]-1

Primetimo da NestWhile daje odmah krajnji izraz dobijen putem iteracije.

NestWhile[Log[#]&,10000.,Log[#]>=0&]

Iteracije funkcije (x^2)-2 x

Ukoliko počnemo od broja 4, koliko bi nam trebalo iteracija dok vrednost funkcije ne postane veća od milion? Prvo, primetimo da ako napravimo 10 iteracija:

NestList[(((#)^2)-2 #)&,4.,10]

NestWhileList[(((#)^2)-2 #)&,4.,#≤1000000&]

Koristeći NestWhileList dobijamo

NestWhileList[(((#)^2)-2 #)&,4.,(((#)^2)-2 #)≤1000000&]

Znači, treba nam 3 iteracije da dobijemo broj veći od milion ukoliko počnemo sa brojem 4.

Kombinacija više stvari istovremeno

Fibonacci niz se dobija tako što se saberu dva prethodna elementa. Počevši od 1 i 2, prvih 10 ćlanova tog niza su:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Naći samo one članove Fibonacci niza koji ne prelaze 4 miliona. Da bismo to uradili, prvo nađimo koliko ima takvih članova niza.

NestWhile[#+1&,1,Fibonacci[#]<4000000&]

Ti Fibonacci brojevi su, stoga

Fibonacci/@Range[34]

Poslednji broj je veći od 4 miliona pa ga treba odbaciti. Imamo, dakle, sledeći niz brojeva:

Most[Fibonacci/@Range[34]]

Naći sumu parnih brojeva prethodno dobijene liste Fibonacci brojeva

Prvo ćemo izdvojiti parne brojeve iz liste pomoću Select

Most[Fibonacci/@Range[34]]

Select[Most[Fibonacci/@Range[34]],EvenQ]

Najzad naći ćemo sumu tih parnih brojeva:

Total[Select[Most[Fibonacci/@Range[34]],EvenQ]]

Nesting konstrukcije sa dva argumenta: FoldList i Fold

NestList primenjuje neku funkciju na prethodno dobijeni rezultat. FoldList radi to isto ali takođe svaki put ubacuje (pošto ima dva argumenta) po jedan element od neke zadate liste. Za razliku od NestList, FoldList (i Fold) rade rekurzije čistih funkcija sa dve promenljive. Evo primera:

FoldList[f[#1,#2]&,{a,b},{1,2,3}]

Clear[f]

FoldList[f[#1,#2]&,x,{1,2,3}]

Hajde da vidimo kako radi FoldList sa apstraktnom funkcijom f. Neka je početni element x. Onda u prvoj rekurziji taj element ubacujemo u slot #1, a u slot #2 ubacujemo prvi element liste, to jest 1. U drugoj iteraciji to što smo dobili u prvoj iteraciji ubacuje se u #1, a drugi element liste, 2, ubacuje se u #2. I td.

Nastavak uvodnog primera

Dakle, u prve dve rekurzije imamo

f[#1,#2]&[x,1]

f[#1,#2]&[f[#1,#2]&[x,1],2]

f[#1,#2]&[f[#1,#2]&[f[#1,#2]&[x,1],2],3]

itd.

Ovo je izuzetno moćna funkcija samo kada se malo naviknemo da radimo sa njom. Evo jedne jednostavne primene.

Prost primer FoldList

a=RandomVariate[NormalDistribution[0.0001,0.02],10]

FoldList[(0.06 ((#2)^2)+0.94 #1)&,(0.02^2),a]//Sqrt

Fold[#1#2&,{{a,1},{b,2},{c,3},{d,4}}]

FoldList[#1#2&,{{a,1},{b,2},{c,3},{d,4}}]

FoldList[#1+#2&,{{a,1},{b,2},{c,3},{d,4}}]

Fold[#1#2&,{a,b,c,d}]

120!

FoldList[#1#2&,{a,b,c,d}]

Accumulate[{a,b,c,d}]

FoldList[#1+#2&,{a,b,c,d}]

FoldList[#1+#2&,0,{a,b,c,d}]

Evo kako ovo radi. Prvi element je 0. Drugi element je

#1+#2&[0,a]

Treći element je

#1+#2&[#1+#2&[0,a],b]

#1+#2&[#1+#2&[#1+#2&[0,a],b],c]

Ovo je veoma slično tome što daje Accumulate

Vidimo da je ovo veoma slično

Accumulate[{a,b,c,d}]

Razlika je u samo u tome što na početku sa FoldList imamo 0. Umesto toga, možemo da uradimo sve isto osim što izostavimo početnu vrednost (0). U tom slučaju:

FoldList[#1+#2&,{a,b,c,d}]

To je zato što, ukoliko izostavimo početnu vrednost, FoldList (i Fold) uzima kao početnu vrednost prvi element liste, a. Drugi element je onda

#1+#2&[a,b]

treći element je

#1+#2&[#1+#2&[a,b],c]

itd.

Evo i numeričkog primera

Vidimo da je početna vrednost zapravo opcioni argument (i veoma koristan u praksi) ali ne i neophodan. Evo i numeričkog primera. Ukoliko je lista

Range[10]

Total[Range[10]]

Fold[#1+#2&,Range[10]]

FoldList[#1+#2&,Range[10]]

Primetimo da je prvi element 1, drugi je

#1+#2&[1,2]

treći je

#1+#2&[#1+#2&[1,2],3]

itd

Kako od cifara sklopiti broj koji odgovara tim ciframa

Pretpostavimo da imamo listu cifara

{8,7,6,1,2,3,9,8,7}

Kako iz nje naći broj koji joj odgovara. Naravno, možemo da primenimo funkciju FromDigits

FromDigits[{8,7,6,1,2,3,9,8,7}]

A kako to uraditi sa FoldList odnosno Fold?

Fold[10 #1+#2&,{8,7,6,1,2,3,9,8,7}]

FoldList[10 #1+#2&,{8,7,6,1,2,3,9,8,7}]

Ukoliko želimo samo krajnji rezultat onda bismo koristili Fold, a ne FoldList

Fold[10 #1+#2&,{8,7,6,1,2,3,9,8,7}]

Da vidimo kako to radi korak po korak

Prva iteracija

10 #1+#2&[8,7]

Druga iteracija je

10 #1+#2&[10 #1+#2&[8,7],6]

Treća je

10 #1+#2&[10 #1+#2&[10 #1+#2&[8,7],6],1]

Definisati uopšteni faktorijel preko funkcije Fold

Videli smo kako možemo da rekurzivno sabiramo veličine u nekoj listi. Razmotrimo sada kako bi radilo nešto kao faktorijel. Naime, razmotrimo listu {a,b,c,d,e,f} i pokažimo kako bismo dobili proizvod njenih elemenata koristeći Fold. Prvo uradimo to isto sa FoldList. Dobijamo ono što se zove Running Product.

Clear[a]

FoldList[#1 #2&,{a,b,c,d,f}]

Počinjemo od prvog elementa liste, to jest a. Prva iteracija bi bila

#1 #2&[a,b]

druga bi bila

#1 #2&[#1 #2&[a,b],c]

i td

Faktorijel bi bio

Fold[#1 #2&,{a,b,c,d,f}]

Ovako možemo da izračunamo faktorijel od 30

Fold[#1 #2&,Range[30]]

Naći sadašnju vrednost anuiteta u uslovima promenljivih diskontnih stopa

Pretpostavimo da ćemo naredne 4 godine dobijati uvek istu količinu novca od rođaka u Nemačkoj, recimo c. Kolika je sadašnja vrednost tog novca? Moramo da diskontujemo odgovarajućim diskontnim stopama. Pretpostavljamo da diskontne stope mogu da se menjaju svake godine. Evo jednog načina da to uradimo:

Reverse[{r1,r2,r3,r4}]

FoldList[((#1)/(1+#2))+c&,c,Reverse[{r1,r2,r3,r4}]]//Expand

Primetimo da je

Reverse[{r1,r2,r3,r4}]

Stoga,

((#1)/(1+#2))+c&[c,r4]

((#1)/(1+#2))+c&[((#1)/(1+#2))+c&[c,r4],r3]

i td

Da sumiramo

FoldList[((#1)/(1+#2))+c&,c,Reverse[{r1,r2,r3,r4}]]//Expand

Tabela prikazuje rekurzivnu vrednost novčanih tokova, od kraja ka danas. Ako nas interesuje samo neto sadašnja vrednost (u trenutku 0 odnosno danas):

Fold[((#1)/(1+#2))+c&,c,Reverse[{r,r,r,r}]]//Expand

Fold[((#1)/(1+#2))+c&,c,Reverse[{r1,r2,r3,r4}]]//Expand

Ukoliko su sve diskontne stope identične, sadašnja vrednost anuiteta postaje

Fold[((#1)/(1+#2))+c&,c,Reverse[{r,r,r,r}]]//Expand

Numerički primer

Pretpostavimo da dobijamo 10000 euroa godišnje prihode na period od 5 godina i da su diskontne stope za prvu, drugu, ... petu godinu date vektorom:

{0.05,0.03,0.06,0.07,0.04}

Naći sadašnju vrednost anuiteta vaše plate

Fold[((#1)/(1+#2))+10000&,10000,Reverse[{0.05,0.03,0.06,0.07,0.04}]]

Znači, vaša plata je ekvivalentna tome kao da vam je neko danas dao nešto preko 53 hiljade eura

Sabiranje slika

Sada posmatramo sabiranje slika korišćenjem ImageAdd. Naime, koristimo čistu funkciju

Fold[ImageAdd[#1,#2]&,
 {, , , , }]

ImageAdd[#1,#2]&

FoldList[ImageAdd[#1,#2]&,
 {, , , , }]

Pogledajmo prva dva koraka u ovim iteracijama. U prvoj iteraciji

ImageAdd[#1,#2]&[, ]

ImageAdd[#1,#2]&[ImageAdd[#1,#2]&[, ],  ]

itd