🍈 👼🏿 👩🏾‍🚒 Os pilares da destruição do código lento na Wolfram Language: acelerando o código dezenas, centenas e milhares de vezes 🧓🏼 💱 🎧

Você pode baixar o arquivo com o código e os dados na postagem original no meu blog

A imagem do webinar e do post foi tirada por uma razão: em certo sentido, o núcleo simbólico da Wolfram Language pode ser comparado com Thanos - se seu poder fosse direcionado na direção certa, ele poderia se tornar o "homem bom" mais poderoso e útil. O mesmo ocorre com o núcleo simbólico da Wolfram - seu poder monstruoso deve ser usado corretamente e, se isso não for feito, pode se tornar um verdadeiro "mal" que atrasa muito tudo. Desenvolvedores iniciantes não conhecem muitos dos paradigmas, idéias e princípios mais importantes da Wolfram Language, escrevem códigos realmente ineficientes e ficam decepcionados depois disso, embora a Wolfram Language não seja a culpada. Este artigo pretende corrigir este artigo.

Eu tive a chance de trabalhar com a Wolfram Language desde (já bastante distante) 2005 (então ainda havia a versão Mathematica 5.2, agora já é a 12ª). Nos últimos 15 anos, muita coisa aconteceu: foram adicionadas milhares de novas funções e áreas internas em que trabalham ( aprendizado de máquina , geometria precisa , trabalhando com áudio , trabalhando na web , recursos de nuvem , suporte profundo a unidades de medida , integração com os bancos de dados Wolfram | em Alpha , cálculo geográfica , suporte para trabalhar com o CUDA , o Python , paralelização de operações, e muito mais), novos serviços - nuvem por Wolfram nuvem , um sistema bem conhecido de computador de valor por Wolfram | sobre Alpha , funções do repositório , o repositório de redes neurais e etc. .

Ao longo dos anos, usei bastante a Wolfram Language (sim, anteriormente, na verdade, chamava-se Mathematica , antes de Stephen Wolfram decidir não destacar o idioma e torná-lo comum a toda uma galáxia de seus produtos) e em diferentes áreas: consegui criar um modelo de vendas para uma empresa farmacêutica; criar analisadores e geradores automáticos de álbuns de filmes para a indústria de aluguel de filmes (quando ainda estavam na infância); aplicar ativamente na ciência (trabalho em química e física de estado sólido e teoria da destruição); desenvolver protótipos de sistemas de ensino para as plataformas de ensino doméstico e universitário e as principais empresas e editoras desse mercado na Rússia.

Registros de alguns de meus discursos nas Conferências MBLT DEV e Wolfram

, , , Wolfram Language : JavaScript, Python, Java, PHP . — Wolfram , , , .

, , Wolfram Language — (., , "Performance tuning in Mathematica?" — ) — Wolfram Language — , , ( ) .

, , : , C - Wolfram Language, CUDA, Java C (, Wolfram-).

, Wolfram Language . , , , 15 ( , — , Factorial):

Module[{st, stInput, data, systemFunction}, 
st=Style[#, FontFamily->"Arial", Gray, FontSize->14]&;

SetAttributes[stInput, HoldAll];

stInput[code_]:=(Clear[f];

code;

{Style[HoldForm@code, "Input", FontSize->14, Background->None], code;

RepeatedTiming[f[9];

, 2][[1]]});

data=Flatten/@{
{st@" Wolfram", stInput[f=Factorial]}, 
{"", stInput[f[n_]:=n!]}, 
{st[" "], stInput[f[n_]:=n f[n-1];

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

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

t]]}, 
{st["  ()"], stInput[f[n_]:=Apply[Times, Range[n]]]}, 
{"", stInput[f[n_]:=Fold[Times, 1, Range[n]]]}, 
{st[""], stInput[f[n_]:=If[n==1, 1, n*f[n-1]]]}, 
{st[""], stInput[f=If[#1==1, 1, #1*#0[#1-1]]&]}, 
{"", stInput[f[n_]:=Fold[#2[#1]&, 1, Array[Function[t, #t]&, n]]]}, 
{st[""], stInput[f[n_]:=Length[Permutations[Range[n]]]]}, 
{st["  ()"], stInput[f[n_]:=First[{1, n}//.{a_, b_/;

b>0}:>{b*a, b-1}]]}, 
{st[" "], stInput[f[n_]:=StringLength[Fold[StringJoin[Table[#1, {#2}]]&, "A", Range[n]]]]}, 
{st[""], stInput[f[n_]:=Gamma[n+1]]}, 
{"", stInput[f[n_]:=Product[i, {i, n}]]}
};

systemFunction=data[[1, 3]];

Framed[#, Background->White, FrameMargins->5, FrameStyle->None]&@Grid[{Style[st[#], Bold]&/@{"", "", " \n,  "}}~Join~({#[[1]], #[[2]], st[Round[#[[3]]/systemFunction, 1/10]//N]}&/@data), 
Alignment->{{Center, Left, Left}, Center}, 
Dividers->{None, {None, {LightGray}, None}}, Background->{None, {LightOrange, None}}
]]

, , , , Python. Wolfram Language, C, .

Wolfram Language.

Wolfram Language (Mathematica , ) — , , , , , Matlab (Sympy, Maxima, Maple .), , . , , , , , , :

Wolfram Language, .

1.

1.1. , ,

Wolfram ( Java), ( !) , . , , .

ClearAll[data];

data=RandomReal[1, {10^6, 2, 2}];

compareTiming[{Map[Flatten, data], Flatten[data, {{1}, {2, 3}}]}]

1.2. (`Map` /@, `Apply` @@ )

(-) #-&, — , , , ( Function) , ( , , ).

ClearAll[data];

data=Range[1, 10^6];

compareTiming[{f[x_]:=x^2;

Table[f[i], {i, data}], Map[#^2&, data]}]

1.3.

Transpose, Flatten, Partition, Part . . — , .

ClearAll[data];

data=RandomReal[1, {10^5, 2}];

compareTiming[{{#[[1]], #[[2]]^2}&/@data, Transpose[{#1, #2^2}&@@Transpose[data]]}]

1.4.

. , ( . .). «» .

ClearAll[fibonacci, f];

compareTiming[{fibonacci={1, 1};

n=3;

While[n<=20000, AppendTo[fibonacci, fibonacci[[n-1]]+fibonacci[[n-2]]];

n++];

fibonacci, f[1]=1;

f[2]=1;

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

f/@Range[20000]}]

2. , ,

, , 6/47 . , , , .

2.1. ,

, , .

compareTiming[{data=Table[{x, Sin[x]/Gamma[x]}, {x, 0, 10, 1/100}];

ListPlot[data], data=Table[{x, Sin[x]/Gamma[x]}, {x, 0, 10, 1/100.}];

ListPlot[data]}]

— 100 100. — , — . 4 ! , , .

Table[{x, Sin[x]/Gamma[x]}, {x, 0, 10, 1/2}]
Table[{x, Sin[x]/Gamma[x]}, {x, 0, 10, 1/2.}]

, Wolfram Language : , ( ), , , , 100 ( Wolfram Language ), , . , .

2.2.

, . ,

a x^{3} + b x + c = 0

$ax^3+bx+c=0$ a, b, c. :

Solve[a x^3+b x+c==0, x]/.{a->1.23, b->3.45, c->2.6}

, 15 :

compareTiming[{Solve[a x^3+b x+c==0, x]/.{a->1.23, b->3.45, c->2.6}, Solve[a x^3+b x+c==0/.{a->1.23, b->3.45, c->2.6}, x]}]

, Wolfram Language :

Solve[a x^3+b x+c==0, x]

Solve[a x^3+b x+c==0, x]/.{a->1.23, b->3.45, c->2.6}

a x^3+b x+c==0/.{a->1.23, b->3.45, c->2.6}

Solve[a x^3+b x+c==0/.{a->1.23, b->3.45, c->2.6}, x]

2.3.

— (. ). N, Rationalize, Round, Floor, Ceiling, SetPrecision, SetAccuracy.

3. , , CUDA

3.1.

(Listability) — , . Wolfram Language List — . , .

, , Map .

ClearAll[data];

data=RandomReal[{-Pi, Pi}, 10^7];

compareTiming[{Sin/@data, Sin[data]}]

3.2. `Compile`

, . C- ( , Visual C++ Build Tools 2017 — , , . ). (RuntimeAttributes) (Parallelization).

ClearAll[data];

data=Range[-50, 50, 0.001];

fNotCompiled=Function[{x}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum]];

, - Wolfram Language (JIT-) ( JIT-)

fJITCompiled=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum]];

JIT- :

fJITCompiledParallelized=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], Parallelization->True];

JIT- :

fJITCompiledListable=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], RuntimeAttributes->{Listable}];

JIT- :

fJITCompiledListableParallelized=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], Parallelization->True, RuntimeAttributes->{Listable}];

, C ( ):

fCompiled=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], CompilationTarget->"C"];

fCompiledParallelized=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], CompilationTarget->"C", Parallelization->True];

fCompiledListable=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], CompilationTarget->"C", RuntimeAttributes->{Listable}];

fCompiledListableParallelized=Compile[{{x}}, Block[{sum=1.0, inc=1.0}, Do[inc=inc*x/i;

sum=sum+inc, {i, 100}];

sum], CompilationTarget->"C", Parallelization->True, RuntimeAttributes->{Listable}];

( !) . , C 50 !

compareTiming[
{fNotCompiled/@data, 
fJITCompiled/@data, 
fJITCompiledListable@data, 
fJITCompiledParallelized/@data, 
fJITCompiledListableParallelized@data, 
fCompiled/@data, 
fCompiledListable@data, 
fCompiledParallelized/@data, 
fCompiledListableParallelized@data}]

Compile , «», . MathGroup.

3.3. Compile

, (UnitStep, Clip, Sign, Abs . .) , Compile, « (-)», If, ( , ) Compile. - Wolfram Language, C .

f1Compiled=Compile[{{x, _Real}}, SeedRandom[1];

Block[{data}, data=RandomReal[{-x, x}, 10^5];

Table[If[data[[i]]>0, 1, 0], {i, 1, Length[data]}]], CompilationTarget->"C", Parallelization->True];

f2Compiled=Compile[{{x, _Real}}, SeedRandom[1];

Block[{data}, data=RandomReal[{-x, x}, 10^5];

UnitStep@data], CompilationTarget->"C", Parallelization->True];

compareTiming[{f1Compiled@10, f2Compiled@10}]

3.4.

— , . , : Parallelize, ParallelMap, ParallelTable.

compareTiming[{Table[Solve[Sin[n x+n^2]==0, x], {n, 1, 100}], ParallelTable[Solve[Sin[n x+n^2]==0, x], {n, 1, 100}]}]

3.5. CUDA, OpenCL — ()

, CUDA OpenCL. , , . .

4. , ({...} List) Wolfram Language,

4.1. , «», .

, . , 100-1000 , , XMLObject, -, , .

4.2. Append, Prepend, AppendTo PrependTo

Append, Prepend, AppendTo and PrependTo , . . — , , , .

compareTiming[{list={};

n=1;

While[n<=10000, list=Append[list, n++]];

list, Range[1, 10000]}]

4.3.

« » (, {1,{2,{3,{}}}}) «» ( {1,2,3,4}) .

: A = {new element, A}.

A — , .

compareTiming[{list1={};

Table[If[PrimeQ[i], list1=list1~Join~{i}], {i, 1, 100000}];

list1, list2={};

Table[If[PrimeQ[i], list2={list2, i}], {i, 1, 100000}];

Flatten@list2}]

4.4.

, (Pattern matching) , (__ BlankSequence ___ BlankNullSequence) , (Sequence) . , , {fst_,rest___}:>{f[fst],g[rest]} . , , . , (. ).

5. . .

, , (Patterns) Wolfram Language :

5.1.

, , , , .

, , , ( ).

:

list //. {left___, x_, middle__, y_, right__} /; x > y :> {left, y, middle, x, right};

SequenceCases, SequencePosition, SequenceCount, SequenceReplace, , 10.1 Wolfram.

5.2.

, .

ClearAll[data];

data=RandomInteger[{0, 100}, {10^6, 2}];

compareTiming[{data/.{p:({x_/;

x>90&&PrimeQ[x], y_/;

y>34})/;

x^2+y^2>1000:>p, t:{_, _}:>Nothing}, ((data/.{_, y_/;

y<=34}:>Nothing)/.{x_/;

(x<=90||Not[PrimeQ[x]]), _}:>Nothing)/.({x_, y_}/;

x^2+y^2<=1000)->Nothing, 
Cases[Cases[Cases[data, {x_/;

x>90&&PrimeQ[x], _}], {_, y_/;

y>34}], {x_, y_}/;

x^2+y^2>1000]}]

5.3.

. , ( , ..). , ( / ;) (?), , , .

ClearAll[data];

data=RandomSample[{##}]&@@@Transpose[{RandomInteger[{0, 100}, 10^5], RandomReal[{0, 100}, 10^5]}];

compareTiming[{Cases[data, {_Integer, x_/;

Sin[x]<FractionalPart[x]}], Module[{preData, seconds}, preData=Cases[data, {_Integer, _}];

seconds=Developer`ToPackedArray[preData[[;;, 2]]];

Pick[preData, UnitStep[FractionalPart[seconds]-Sin[seconds]], 1]]}]

6.

Wolfram Language, , . , , .

, ( ), — [[...]] (Part).

6.1. ,

, .

compareTiming[{NestWhile[Drop[#, 1]&, Range[1000], (Length[#]>10)&], Drop[Range[1000], 990]}]

6.2. Part

Part ( ). , (Part ).

:

list={1, 2, 3, 4, 5};

list[[{1, 3}]]=list[[{4, 1}]];

list

— :

ClearAll[list1, list2];

list1=Range[1000000];

list2=list1;

newArrangement=RandomSample[list1];

compareTiming[{list1=Table[list1[[i]], {i, newArrangement}];

list1, 
list2=list2[[newArrangement]];

list2}]

6.3. Extract

Extract , .

ClearAll[list1, list2];

list=Range[10000000];

elems=RandomInteger[{1, 10000000}, 10000];

compareTiming[{Table[list[[elems[[i]]]], {i, 1, Length@elems}], 
Extract[list, List/@elems]}]

7.

7.1.

, Developer`ToPackedArray. Developer`PackedArrayQ.

ClearAll[data];

data=RandomInteger[{0, 1}, 10^6];

dataUnPacked=data~Join~{1.};

dataPacked=Developer`ToPackedArray[N[data]~Join~{1.}];

compareTiming[{Total[dataUnPacked], Total[dataPacked]}]

7.2.

, , , , . SparseArray.

sparseArray=SparseArray[RandomInteger[{1, 100}, {100, 2}]->RandomReal[{0, 10}, 100], {100, 100}];

notSparseArray=Normal@sparseArray;

compareTiming[{Det@notSparseArray, Det@sparseArray}]

7.3. -

10 Wolfram Language , <|...|> (Association).

, , - (« », -). Wolfram Language .

assoc=<|a->1, b->2, c->3, d->4, e->5|>;

assoc[d]+assoc[a]

Dataset — , Wolfram Language.

Dispatch, - .

8. ,

8.1. ()

Wolfram Language .

: f[x_]:=functionBody f[x_]:=f[x]=functionBody — , . 1 , , , Save DumpSave.

ClearAll[f1, f2];

f1[x_]:=(Pause[0.1];

x^2);

f2[x_]:=f2[x]=(Pause[0.1];

x^2);

compareTiming[{f1/@{1, 1, 1, 1, 1}, f2/@{1, 1, 1, 1, 1}}]

8.2. (closures)

Wolfram Language , () , , , .

ClearAll[f1, f2]

f1[x_]:=(y/.Solve[y^2+x y+x==0, y]);

Module[{solution=FullSimplify@Solve[y^2+x y+x==0, y]}, 
f2[xValue_]:=(y/.solution)/.x->xValue];

compareTiming[{Table[f1[x], {x, 0, 100}], Table[f2[x], {x, 0, 100}]}]

8.3.

Wolfram Language := (SetDelayed), :> (RuleDelayed). «» , , = (Set) -> (Rule). , .

ClearAll[f1, f2]

f1[x_]:=(y/.FullSimplify[Solve[y^2+x y+x==0, y]]);

f2[x_]=(y/.FullSimplify[Solve[y^2+x y+x==0, y]]);

compareTiming[{Table[f1[x], {x, 0, 100}], Table[f2[x], {x, 0, 100}]}]

9.

9.1. Reap + Sow

Reap Sow , «» , . .

9.2.

Wolfram Language , , Mathematica. . . FullForm.

FullForm[{{1, 2}, {3, {4}}, {{5}}}]

FullForm[Hold[x5+y2+1/z+4/2]]

9.3.

, , ( ). .

9.4. $HistoryLength

Wolfram Language , . $HistoryLength.

Wolfram Language

— , . , Wolfram Language, : .

, , Wolfram Mathematica, Wolfram Cloud, Wolfram One . , , « ». Wolfram Language Wolfram Mathematica, , , . : , , .

: , — Wolfram Language . , , .

, , Wolfram Language :

, ( (, , ) ). , — 15, .

, Wolfram Language , . ( 12.0) 5436 188 . .

data=SortBy[#,-Length[#]&]&@GroupBy[Flatten[Thread/@EntityValue[WolframLanguageData[],{name,functionality areas}],1],Last,Sort[#[[;;,1]]]&];

Framed[Labeled[Style["  Wolfram Language   ,   \n",30,FontFamily->"Intro Regular"],#],Background->GrayLevel[0.95],FrameMargins->5,FrameStyle->None]&@WordCloud[KeyValueMap[{StringRiffle[StringCases[#1,RegularExpression["[A-Z][a-z]+"]]/."Symbols"->""," "]<>" ("<>ToString[Length@#2]<>")",N@Length@#2}&,data],ImageSize->{1200,800},Background->GrayLevel[0.95],WordOrientation->{{-Pi/4,0,Pi/4}},MaxItems->All,WordSpacings->3,FontFamily->"Intro Regular"]

Export[FileNameJoin[{NotebookDirectory[], "fileNames.nb"}], Notebook@Flatten@KeyValueMap[{Cell[#1<>" ("<>ToString[Length[#2]]<>")", "Title"], Cell[BoxData@ToBoxes@Row[Map[Hyperlink[#, "http://reference.wolfram.com/language/ref/"<>#<>".html"]&, #2], ",  "], "Text"]}&, data]];

Wolfram Language

: Entity ( : ), (Wolfram Data Repository), (Wolfram Neural Net Repository), (Wolfram Function Repository) .
. , . , .
- : () , — . :
Mathematica | | Wolfram 2014

| Wolfram Language

| Wolfram
— API, , , , . , Wolfram Language. , . :
Wolfram Programming Cloud
( , Wolfram Cloud , — ).
. Wolfram Language — . " : , ".
, . Wolfram Language — «Problem-oriented» — « », , . .
Wolfram | | Wolfram 2014
. , (Manipulate, Dynamic, DynamicModule, EventHandler) , ( , , Wolfram Language — Mathematica).
:
- — Fortran, C, Matlab;
- — Lisp, Haskell, Ocaml/F#, Scala, Clojure;
- — Prolog;
- — APL, Matlab;
- - — .

ClearAll[timing];

SetAttributes[timing, HoldAll];

timing[expr_]:=(ClearSystemCache[];

AbsoluteTiming[expr]);

ClearAll[compareTiming];

SetAttributes[compareTiming, HoldAll];

compareTiming[expr_List, OptionsPattern[{"OrderQ"->True}]]:=Module[{t, v, c1, c2, holdExpr, colorF, order, rescale}, 
colorF=Blend[{ColorSwatchGraphicsFontCapHeightRGBColor[19255, 167255, 107255]DeployedRGBColorValueSelectorClosingActionsSelectionDepartureParentChangedEvaluatorQuitPreemptive, ColorSwatchGraphicsFontCapHeightRGBColor[1, 101255, 47255]DeployedRGBColorValueSelectorClosingActionsSelectionDepartureParentChangedEvaluatorQuitPreemptive}, #]&;

holdExpr=ReleaseHold@Map[HoldForm, HoldForm@expr, {2}];

{t, v}=Transpose[timing[ReleaseHold[#]]&/@holdExpr];

order=If[OptionValue["OrderQ"], Reverse[Ordering[t]], Range[1, Length[expr]]];

t=t[[order]];

rescale=Evaluate[Rescale[#, MinMax[t], {0, 1}]]&;

v=v[[order]];

holdExpr=holdExpr[[order]];

If[Length[DeleteDuplicates[v]]>1, Echo["    "]];

Framed[Grid[{{Style[#, Bold]&@"      Wolfram Language"}, 
{Grid[{{"", ",  "}}~Join~Table[{Style[holdExpr[[ind]], "Input", Background->Transparent], t[[ind]]}, {ind, 1, Length[expr]}], Alignment->{{Left, Center}, {Center, Center}}, Dividers->White, Background->{None, {LightGray}~Join~(colorF@*rescale/@t)}, ItemSize->{{30, 8}, Automatic}]}, 
If[Length[expr]==2, {Row[{"   ", Style[Round[Max[t]/Min[t], 1/100]//N, Bold], " "}]}, {Row[{"   ", Style[Round[Max[t]/Min[t], 1/100]//N, Bold], " "}]}], 
{Graphics[
Table[{Opacity[0.6], colorF@*rescale@t[[ind]], Rectangle[{0, 1-ind-0.2(ind-1)}, {t[[ind]], 2-ind-0.2(ind-1)}]}, {ind, 1, Length[expr]}], 
ImageSize->{500, Automatic}, PlotRange->{{0, Max[t]}, {1.2(1-Length[expr]), 1}}, AspectRatio->1/(9-Length[expr]/2), 
Axes->False, Ticks->{Automatic, None}, FrameTicks->{All, None}, 
GridLines->{Automatic, None}, Background->White, PlotRangePadding->0, Frame->True, FrameLabel->{{None, None}, {",  ", None}}]}
}, 
ItemStyle->Directive[FontSize -> 14, FontFamily->"Open Sans Light"]], Background->White, FrameStyle->None]];

? )

, Wolfram Wolfram Language . :

Wolfram Cloud — ( , ).
Wolfram Programming Lab — Wolfram Wolfram Language. . .
Wolfram Engine — . . .
Raspberry Pi — Mathematica . ...

P.S.

YouTube : " — " ( ) (). , , Wolfram Language!

— .
. .

Os pilares da destruição do código lento na Wolfram Language: acelerando o código dezenas, centenas e milhares de vezes

1.

1.1. , ,

1.2. (Map /@, Apply @@ )

1.3.

1.4.

2. , ,

2.1. ,

2.2.

2.3.

3. , , CUDA

3.1.

3.2. Compile

3.3. Compile

3.4.

3.5. CUDA, OpenCL — ()

4. , ({...} List) Wolfram Language,

4.1. , «», .

4.2. Append, Prepend, AppendTo PrependTo

4.3.

4.4.

5. . .

5.1.

5.2.

5.3.

6.

6.1. ,

6.2. Part

6.3. Extract

7.

7.1.

7.2.

7.3. -

8. ,

8.1. ()

8.2. (closures)

8.3.

9.

9.1. Reap + Sow

9.2.

9.3.

9.4. $HistoryLength

Wolfram Language

Math Functions (279)

Basic (243)

Image (183)

Graph Theory (179)

Statistical Distribution (152)

Graphics (126)

Region (125)

String (115)

Plotting (110)

Statistics (110)

Paclet (103)

Cloud (97)

Net (90)

Control System (88)

Operator (86)

Front End (85)

Cell (78)

File System (78)

Comparison Operator (73)

Color (71)

Audio (69)

Linear Algebra (62)

Machine Learning (60)

Notebook (60)

Date (59)

Clustering (52)

Graphics Primitive (51)

Form (48)

Stream (44)

Statistical Test (42)

Statistical Process (41)

Chart (39)

Polynomial (39)

Arrow Operator (38)

Machine (38)

(36)

Image Filter (35)

1.2. (`Map` /@, `Apply` @@ )

3.2. `Compile`