Mathematica II.

Függvények

Emlékezettő

Sima függvény hívás:

f[x]

Elől-hattatás

f@x

Hátul-hattatás

x//f

A @ és a // precedenciája különböző az algebrai műveletekhez képest (a @ erősebb, a // gyengébb):

2Pi+1//f

f@2Pi+1

A sima függvényhívások sorrendjét a zárójelezés határozza meg.

f[x,g[y,z]]

Az elől-hattatás hátulról asszociatív

f@g@x

de ellenkező is kikényszeríthető

(f@g)@x

A hátul-hattatás elölről asszociatív

x//f//g

de ellenkező is kikényszeríthető

x//(f//g)

Map

Egy függvény alkalmazása egy lista minden elemére a /@ művelettel érhető el:

Sin/@{Pi/2,Pi/3,Pi/5}

Cos/@{.25,.75}

Figyeljük meg a különbséget @ és /@ között.

Length/@{{1},{a,b},{b,c,d,e},{22,23}}

Length@{{1},{a,b},{b,c,d,e},{22,23}}

Reverse@{{1},{a,b},{b,c,d,e},{22,23}}

Reverse/@{{1},{a,b},{b,c,d,e},{22,23}}

A /@ kiváltható a sok más programnyelvben is map-nek nevezett Map függvénnyel:

Map[Cos,{Pi,2Pi}]

Néhány függvény listán is elemenként ható (listable), ezeknél nincs különbség a @ és a /@ között. Ilyen például az N, a Range és a Prime függvény:

Sqrt@{2,3}

N[Sqrt[{2,3}]]

Prime@{10,1000,100000}
Prime/@{10,1000,100000}

Összeadás olyan, mintha az összeadandók listája lenne.

f/@(a+b c+d)

A szorzás olyan, mintha a tényezők listája lenne.

f/@(a (b+c)d)

A Map-nél a legkülső művelet számít.

Függvény alkalmazásának szintjei

Az, hogy egy lista elemeit tekintsük egy függvény argumentumainak a @@ és @@@ műveletekkel érhető el:

f@{a,b,c}

f@@{a,b,c}

f@@{{a,b},{c,d}}

f@@@{{a,b},{c,d}}

Más néven ez az Apply, nem egyezik meg a @-al.

Apply[f,{a,b,c}]

Apply[f,{{a,b},{c,d}},{1}]

Apply[f,{{{a,b},{c,d}}},{2}]

Tiszta függvény (pure, anonymous, lambda function)

A tiszta függvény a matematikában szokásos ,,x -> kifejezés’’ alakú név nélküli függvénydefiníció megvalósítása a Mathematicában. Két alakja van:
1a. Function[x,kifejezés]		(x helyett bármilyen argumentum állhat)
1b. Function[{x1,x2,…},kifejezés]	többváltozós eset
2.   kifejezés&				a kifejezésben a # (vagy #1, #2,...) az argumentum szerepét játssza, 
					## az összeset, ##n az n-ediktől mind
Lássunk egy példát, amelyben először egy névvel definiált függvényt használunk, majd a tiszta függvényes változatait:

g[x_]:=f[x]-x^2
g/@{a,b,c}

g/@(a+b+c)

Map[g,{a,b,c}]

Map[f[#]-#^2&,{a,b,c}]

((#)^2)&@x

Map[Function[x,f[x]-x^2],{a,b,c}]

Apply[Function[{x,y},x+y],{{1,2},{3,4}}]

Az elől/hátul hattatás mindig egy változós, de lehet tiszta függvény.

Range[10]//((#)/(Total[#]))&

Mod[#,3]&/@Range[10]

Függvényobjektumot is eltárolhatok változóba

f=((#)^2)&;
f=Function[x,(x^2)];
f[3]

Map[f, Range[10]]

Operátor

Függvényhez függvényt rendelő függvény.

Derivative[1][f]

A Derivative egy operátor értékű függvény.

∂:ℕ↦(∂_n)
(∂_n):(ℝ↦ℝ)↦(ℝ↦ℝ)

Derivative[n][F][x]

A sima D függvény egyszerűen lederivál egy képletet

D[f,x](*nem jó*)
D[f[x],x](*jó*)
D[f[x],{x,2}](*második derivált*)

f//Derivative[1]
x//(f//Derivative[1])

Függvények ismételt alkalmazása

A Nest és a NestList függvényekkel egy függvény többször alkalmazható argumentumán:

Nest[f,x,3]

Nest[#^2&,3,5]

NestList[#^2&,3,5]

Nest[1+1/#&,x,4]

NestList[1+1/#&,1,6]

A FixedPoint addig alkalmaz egy függvény ismételve, míg az eredmény már nem változik, azaz a függvény fixpontja:

NestList[Cos[#]&,1.0,8]

FixedPoint[Cos[#]&,1.0]

A Nest többargumentumos változata a Fold és a FoldList

FoldList[f,x,{a,b,c}]

FoldList[Times,1,Range[2,10]]

FoldList[Plus,0,{a,b,c}]

FoldList[Times,1,{a,b,c}]

Times[a,b,c]

Times[]

Listák szűrése

Tesztfüggvények

Általában Q betűre végződő függvénynevek, igaz-hamis (bool) értékű függvények.

EvenQ[11]
OddQ[11]

IntegerQ[12.2]
NumberQ[x]

Select

“Tiszta függvény, rendes ház”

Select[{1,2,3,4,5},EvenQ]
Select[{1,2,3,4,5},OddQ]
Select[Range[100], PrimeQ]

Írhatunk bármilyen tesztet a kritérium helyére, hasznos a tiszta függvény.

Select[Range[10], Mod[10,#]==0&]