Uwagi do programowania funkcyjnego

S=10;
razyS=Function[{n},
s n];

razyS[10]

Sin[z]+Cos[x]+2x;
Integrate[x,{x,0,1}];s=10;Tanh[s];
Solve[a x+b==10,x];

razyS[10]

Przykład

m=50;liczbakroków=20;

sumasąsiadów[i_,j_,plansza_]:=If[i≠1,If[j≠1,If[i≠ m,If[j≠m,plansza[[i-1,j-1]]+plansza[[i,j-1]]+plansza[[i+1,j-1]]+plansza[[i+1,j]]+plansza[[i+1,j+1]]+plansza[[i,j+1]]+plansza[[i-1,j+1]]+plansza[[i-1,j]],0],0],0],0];

wartośćwkom[i_,j_,plansza_]:=If[plansza [[i,j]]==1,Switch[MemberQ[{2,3},sumasąsiadów[i,j,plansza]],True,1,False,0],Switch[MemberQ[{3}, sumasąsiadów[i,j,plansza]],True,1,False,0]]

Zmienplanszę[plansza_]:=Table[wartośćwkom[i,j,plansza],{i,1,m},{j,1,m}]

Pocz=Table[RandomChoice[{0,1}],{i,m},{j,m}];

Wynik1=NestList[Zmienplanszę,Pocz,liczbakroków];//Timing

MatrixForm[Pocz=ArrayPad[{{1}},5]]

Wynik1=NestList[Zmienplanszę,Pocz,1];//Timing

Rozwiązania

Block, Module

lengths=Function[m,
Module[
{lx=Length[m],ly=Length[m[[1]]]},
{lx,ly}]
];

lx
ly

lengths[{{1,1},{2,3}}]

Function[x,Module[
{a,b,c},
a=f1[x];
b=f2[a];
c=f3[b];
c
]
][a]

Dlaczego nie Block?

Function[x,Block[{a},
a=f[x]
]
];
%[a]

Block[{a},Print[a]]
Module[{a},Print[a]]

Game of life via ListConvolve

l=ArrayPad[RandomInteger[{0,1},10],30];

rrand=(#->RandomInteger[{0,1}])&/@Range[0,7]

l={0,0,0,0,0,1,0,0,0,0,0};
r={0->0,1->1,2->0,3->1,4->1,5->0,6->1,7->0};

next=Function[{r,l},ListConvolve[{4,2,1},l,{2},0]/.r];

ArrayPlot[NestList[next[r,#]&,l,20]]

showrules=Function[r,TableForm[ArrayPlot[{IntegerDigits[#[[1]],2,3]},ImageSize->90]->ArrayPlot[{{#[[2]]}},ImageSize->30]&/@r]];
showrules[r]

l={a,b,c,d,e,f};

ListConvolve[{x,y},{a,b,c,d,e,f}]

ListConvolve[{x,y,z},{a,b,c,d,e,f}]

ListConvolve[{1,1},{a,b,c,d,e,f}]

ListConvolve[{A[1],A[2],A[3]},{a,b,c,d,e,f},{-1,1}]

ListConvolve[{A[1],A[2],A[3]},{a,b,c,d,e,f},{1,1}]

ListConvolve[{{1,1},{1,1}},{{a,b,c},{d,e,f},{g,h,i}}]

ListConvolve[{{1,1,1},{1,0,1},{1,1,1}},{{a,b,c},{d,e,f},{g,h,i}}]

ListConvolve[{{1,1,1},{1,0,1},{1,1,1}},{{a,b,c},{d,e,f},{g,h,i}},{2,2}]

ListConvolve[{{1,1,1},{1,0,1},{1,1,1}},{{0,0,0},{0,1,0},{0,0,0}},{2,2},0]

ListConvolve[{{1,1,1},{1,0,1},{1,1,1}},{{0,0,0},{0,1,0},{0,0,0}},{2,2},1]

next2D = Function[{r,m},
ListConvolve[
{{2,2,2},{2,1,2},{2,2,2}},
m,{2,2},0]/.r
];

numtorules=Function[{nums},Thread[Range[0,17]->Normal[SparseArray[Thread[nums+1->1],{18}]]]];

r2D=numtorules[{5,6,7}]

m2D=ArrayPad[RandomInteger[{0,1},{5,5}],10];

ListAnimate[ArrayPlot/@NestList[next2D[r2D,#]&,m2D,100]]