This document discusses various programming concepts in Mathematica including expressions, patterns, lists, symbolic computation, and different programming paradigms like procedural, functional, list-oriented, and object-oriented programming. It provides examples of using blanks, patterns, rules, and other core Mathematica functions and constructs.

1. Principles of
Mathematica
Programming
kobayashikorio@gmail.com
Oct.31, 2016

2. Blank is the alpha
_
_

3. Expression
_[]
_[]

4. Expression with Blank between the brackets
_[_]
_[_]

5. Expression with Sequence
_[_,_]
_[_,_]

6. Blank can be replaced by the Expression
introduces Expression Nested
_[_[_]]
_[_[_]]

7. Blank can be replaced by the Expression
introduces Expression Serialized
_[_][_]
_[_][_]

8. Blank can be replaced by the Expression
introduces Sequenced Expression
_[_[_],_[_]]
_[_[_],_[_]]

9. So, Blank, Expression, Sequence,
and Symbol is the Atom of
Mathematica

10. Blank of Blank
__
__

11. Blank of Blank produce Named Type and Named
Pattern Replacing the Blank with Symbol
_h
_h
a_
a_

12. Blank of Blank of Blank produce Named
Pattern having Type
___
___
a_h
a_h

13. Replacing Blank with Symbol makes Named
Expression and Expression to the Function
x[_]
x[_]
x[a_h]
x[a_h]

14. Expression Compound
x[_];x[_,_]
x[_,_]

15. So, Named-Expression,
Pure-Function, Pattern, Boolean,
Type, and Number is the static
Primitive of Mathematica

16. Running
Evaluator

17. Predefined Expression “Set” lets run the
evaluator
Set[x,1]
1

18. Evaluation of Symbol “x”
x
1

19. Predefined Expression “Plus”
Plus[x,a]
1+a

20. Set Something
to
Expression

21. Expression Definition with Pattern
Set[f[a_],Plus[1,a]]
1+a

22. Evaluation of Definition
f[b]
1+b

23. Syntax Sugar for Expression Definition with
Pattern
f[a_]=1+a
1+a

24. Expression Predefined, “List”
List[1,2,a]
{1,2,a}

25. Syntax Sugar for “List”
{1,☺,a,f[2],a=2,{a,0}}
{1,☺,a,3,a=2,{2,0}}

26. Set
and
SetDelayed

27. Set and SetDelayed - Set
a=2;f[a_]=1+a
3
f[y]
3

28. Set and SetDelayed - SetDelayed
a=2;f[a_]:=1+a
3
f[y]
1+y

29. Listable

30. Plus is Listable
Plus[{1,2,3,b},c]
{1+c,2+c,3+c,a+c}
{1,2,3,b}+c
{1+c,2+c,3+c,b+c}

31. Apply Expression to List
Map[g,{2,3,4,b}]
{g[2],g[3],g[4],g[b]}

32. Apply User Defined Expression to List
f[a_]:=1+a;
Map[f,{1,2,3,b}]
{2,3,4,1+b}

33. Making List
Table[i,{i,5}]
{1,2,3,4,5}

34. Direct Replacement of List Components
n={1,2,3,4,5,6,7};
n[[{3,5}]]=☺;n
{1,2,☺,4,☺,6,7}
n={1,2,3,4,5,6,7};
n[[3;;5]]=☺;n
{1,2,☺,☺,☺,6,7}

35. Symbolic
Computation

36. Each of Blank and Expression is Member of the
Ring
{_+_,_*1,_*0,_^-1*_}
{2_,_,0,1}
{_[_]*1,_[_]*0,_[_]^-1*_[_]}
{_[_],0,1}

37. Any Symbol can name the Expression
{0[],☺[],{1}[],Sin[_]}
{0[],☺[],{1}[],Sin[_]}

38. Pure Function

39. Function and Pure Function
f[a_]:=a^2; Map[f,{1,2,3,b}]
{1,4,9,b^2}
Map[#^2&,{1,2,3,b}]
{1,4,9,b^2}

40. List Element Selection with Pure Function
Select[{1,2,3,4,5},#>3&]
{4,5}

41. Pure Function returned from Evaluation
h[x_]:=x^3+x^2;h'
2#1+3#1^2&
h'[2]
16

42. Replacing with
Rules

43. Replacement with Rules
Unset[x];
ReplaceAll[{x,y,z},x->5]
{5,y,z}
{x,y,z}/.x->5
{5,y,z}

44. Expression Replacement Applying
Rules
g=p*z+q/.z->y
q+py
g/.{q->2,p->3}
2+3y

45. Replacement of List components
{1,2,3,4,5,6,7}/.(2|4|7)->w
{1,w,3,w,5,6,w}
{i,j,k,l}/.{j->k,k->j}
{i,k,j,l}

46. Applying Answer Set of Solve to the Original
Equation
x=.;
solution=Solve[y^2==x,y]
{{y->-Sqrt[x]},{y->Sqrt[x]}}
y^2==x/.solution
{True,True}

47. Pattern and
Replacement

48. Pattern Priority
q[_]= -1;
q[1]= 0;
q[x_Integer]:= 1;
q[x_List]:=Total[x];
{q[2],q[1],q[{1,2}],q[a],q[a=1]}
{1,0,3,-1,0}

49. Replacement of List Components with
Conditioned Rule
x=9;{2,3,4,5}/.x_/;x>3->0
{2,3,0,0}
x=9;{1.,2,3}/.x_Integer->0
{1.,0,0}

50. Replacement of List Components by Pattern Test
x=1;
{1,2,3,4}/.x_?(#>2&):>x+1
{1,2,4,5}
{{1,2},{2,4}}/.
{x_/;EvenQ[x],y_}:>{y,x}
{{1,2},{4,2}}

51. Programming
Paradigms

52. Procedural Programming
sum=0;
Do[sum=sum+i,{i,10}];
sum
55

53. Functional Programming
sum[0]=0;
sum[n_/;n>0]:=n+sum[n-1];
sum[10]
55

54. Mathematica List Oriented Programming
Apply[Plus,Range[10]]
55

55. Object Oriented Programming
class[nam_] := Module[{a},
put[nam[x_]] ^:= a = x;
get[nam] ^:= a; ];
class[alpha]; class[beta];
{put[alpha[2]], put[beta[1]]};
{get[alpha], get[beta]}
{2,1}

56. eof