Програмиране

Mathematica включва редица програмни парадигми, което позволява всяка програма да бъде написана по най-добрия начин.

Пример 1. Процедурно програмиране. Операторите са близки до C++, Pascal, ... Присвояване и оператор за разклоняване If:

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

-3

Операторите за цикъл са: For, Do, While, Throw, NestWhile. Изчисляване на сумата от първите четири естествени числа с междинни печати:

For[suma = 0 ; i = 1,   i<5,   i ++,   suma += i ; Print[&quo ...  sumа до момента = ", suma]]

i= 1      sumа до момента = 1

i= 2      sumа до момента = 3

i= 3      sumа до момента = 6

i= 4      sumа до момента = 10

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

2

6

48

2448

Пример 2. Програмиране на базата на списъци. Много операции се третират лесно като списъци. Те могат да се създават по различни начини, например с оператора Table, чрез добавяне към края, началото или на произволно място и пр. По-долу са дадени примери за манипулиране и действия със списъци.

Clear[d] d = {}        (*  пра& ... ;тка *) 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}

Цикъл за тримерна таблица 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

Следващата функция привежда горната таблица в едномерен списък.

Flatten[%]

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

А тази ги комбинира по двойки.

Partition[%, 2]

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

Пример 3. Функционално програмиране.

NestList[f, x, 4]

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

Нека  (1 + #)^2 & е "чиста функция", аргументът й е вмъква на мястото на  #.

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

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

Пример 4. Програмиране,  основаващо се на правила. Символът : = тук означава дефиниране на функцията  p[], а  x_ и  y_ са формалните параметри.

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

p[a + b + c]

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

Символът _  може да се замества с единичен израз, а символът  __  е за произволен брой изрази.

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]

Пример 5. Обектно-ориентирано програмиране. По-долу се дават три дефиниции на функции, асоциирани с обекта  h.

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

Ето как могат да се използват трите дефиниции.

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

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

Clear[h]

Пример 6. Програмиране на базата на стрингове.

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

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

Пример 7. Смесени програмни парадигми.

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}}}

Пример 8.  Програмите могат да се пишат в различни стилове. Това е илюстрирано по-долу с малки програми (функции), всяка от които пресмята факториел от n, т.е.  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)