Programovanie v systéme Mathematica

Systém Mathematica ponúka niekoľko schém programovania, ktoré umožňujú vytváranie vlastných programov čo najvhodnejším spôsobom.

Príklad 1. Procedurálne programovanie. Operátory sú podobné operátorom jazykov C++, Pascal, ... Ako príklad je uvedený podminovací operátor - kondicionál If:

z = 3 ; If[0≤z≤2 && z>5, z, -z ]

-3

Operátory pre definíciu cyklov sú: For, Do, While, Throw, NestWhile. Nasledujúci príklad je ukážkou, ako sa dá naprogramovať výpočet a priebežný zápis čiastočných súčtov prvých štyroch prvočísel:

For[sum1 = 0 ; i = 1,   i<5,   i ++,   sum1 += i ; Print[" i= ", i, "      sum1 to this moment is = ", sum1]]

 i= 1      sum1 to this moment is = 1

 i= 2      sum1 to this moment is = 3

 i= 3      sum1 to this moment is = 6

 i= 4      sum1 to this moment is = 10

z = 2 Do[Print[z *= z + i], {i, 3}]

2

6

48

2448

Príklad 2. Program na vytvorenia zoznamu prvkov. Výsledky mnohých výpočtov je často vhodné zobraziť prehľadne v zozname alebo tabuľke. Takéto výstupy sa dajú vytvoriť mnohými spôsobmi, napr. pomocou príkazového operátora Table, pridávaním prvkov na začiatok, na koniec, alebo na náhodnú pozíciu v zozname. Uvedených je niekoľko príkladov ilustrujúcich použitie jednoduchých operácií a manipulácií s výsledkami.

Clear[d] d = {}        (*  empty list, where this ... n the calculation cell *) For[i = 1, i<6, i ++, d = Append[d, i]] d Prepend[d, a] Append[%, b]

{}

{1, 2, 3, 4, 5}

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

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

Cyklus pre tvorbu dvojrozmernej tabuľky 'k':

k = Table[i^j, {i, 4}, {j, i}] TableForm[k]

{{1}, {2, 4}, {3, 9, 27}, {4, 16, 64, 256}}

1      
2 4    
3 9 27  
4 16 64 256

Nasledujúca funkcia zobrazí hornú tabuľku ako jednoduchý zoznam:

Flatten[%]

{1, 2, 4, 3, 9, 27, 4, 16, 64, 256}

Ďalšia funkcia kombinuje výstupy do dvojíc:

Partition[%, 2]

{{1, 2}, {4, 3}, {9, 27}, {4, 16}, {64, 256}}

Príklad 3. Programovanie funkcií.

NestList[f, x, 4]

{x, f[x], f[f[x]], f[f[f[x]]], f[f[f[f[x]]]]}

Ak je výraz (1 + #)^2 & "predpisom funkcie", nasledujúci príkaz umiestni tento výraz na pozíciu znaku   #.

NestList[(1 + #)^2 &, x, 3]

{x, (1 + x)^2, (1 + (1 + x)^2)^2, (1 + (1 + (1 + x)^2)^2)^2}

Príklad 4. Programovanie pomocou pravidiel. Symbol ':=' predstavuje definíciu funkcie 'p[ ]' , pričom   'x_'  a  'y_' sú formálne premenné.

p[x_ + y_] := p[x] + p[y]

p[a + b + c]

p[a] + p[b] + p[c]

Symbol _ možno zameniť iba jednoduchým výrazom, zatiaľ čo symbol __ reprezentuje ľubovoľný počet výrazov.

s[{x__, a_, y__}, a_] := {a, x, x, y, y}

s[{1, 2, 3, 4, 5, 6}, 4]

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

Clear[p, s]

Príklad 5. Objektovo-orientované programovanie. Definície troch funkcií asociovaných s objektom 'h' sú uvedené v nasledujúcom príklade.

h/:h[x_] + h[y_] := hplus[x, y] h/:p[h[x_], x_] := hp[x] h/:f_[h[x_]] := fh[f, x]

Uvedené tri definície sa dajú aj oddeliť.

h[a] + h[b] + f[h[r]] + h[h[x]]

fh[f, r] + fh[h, x] + hplus[a, b]

Clear[h]

Príklad 6. Programovanie preskupenia reťazca znakov.

StringReplace["aababbaabaabababa", {"aa"->"", "ba"->""}]

baa

Príklad 7. Kombinovaný spôsob programovania.

Position[{1, 2, 3, 4, 5}/2, _Integer]

{{2}, {4}}

MapIndexed[Power, {a, b, c, d}]

{{a}, {b^2}, {c^3}, {d^4}}

FixedPointList[If[EvenQ[#1], #1/2, #1] &, 10^5]

{100000, 50000, 25000, 12500, 6250, 3125, 3125}

ReplaceList[{a, b, c, d, e}, {x__, y__} -> {{x}, {y}}]

{{{a}, {b, c, d, e}}, {{a, b}, {c, d, e}}, {{a, b, c}, {d, e}}, {{a, b, c, d}, {e}}}

Príklad 8. Programy sa dajú napísať rôznymi štýlmi. Nasledujúcich 13 krátkych programov (definície funkcií), predstavuje rôzne spôsoby výpočtu hodoty n!

f[n_] := n !

f[n_] := Gamma[n - 1]

f[n_] := n  f[n - 1] ; f[1] = 1

f[n_] := Product[i, {i, n}]

f[n_] := Product[i, {i, n}]

f[n_] := Module[{t = 1}, Do[t = t * i, {i, n}] ; t]

f[n_] := Module[{t = 1, i}, For[i = 1, i <=n, i ++, t *= i] ; t]

f[n_] := Module[{t = 1, i}, For[i = 1, i <=n, i ++, t *= i] ; t]

f[n_] := Apply[Times, Range[n]]

f[n_] := Fold[Times, 1, Range[n]]

f[n_] := If[n == 1, 1, n f[n - 1]]

f = If[#1 == 1, 1, #1 #0[#1 - 1]] &

f[n_] := Fold[#2[#1] &, 1, Array[Function[t, #t] &, n]] Clear[f]


Created by Mathematica  (October 6, 2007)