🛀🏾 🏧 🙇🏻 वुल्फ्राम भाषा में धीमी कोड विनाश के कोनेस्टोन: कोड दसियों, सैकड़ों और हजारों बार तेजी 👩🏽‍🤝‍👩🏼 🔲 🏟️

आप मेरे ब्लॉग पर मूल पोस्ट में कोड और डेटा के साथ फाइल डाउनलोड कर सकते हैं

वेबिनार और पोस्ट के लिए तस्वीर एक कारण के लिए ली गई थी: एक निश्चित अर्थ में, वुल्फराम भाषा के प्रतीकात्मक कोर की तुलना थानोस के साथ की जा सकती है - अगर उसकी शक्ति को सही दिशा में निर्देशित किया गया था, तो वह सबसे शक्तिशाली और उपयोगी "अच्छा आदमी" बन सकता है। यह वुल्फ्राम प्रतीकात्मक कोर के साथ समान है - इसकी राक्षसी शक्ति का सही ढंग से उपयोग किया जाना चाहिए, और यदि ऐसा नहीं किया जाता है, तो यह एक वास्तविक "बुराई" बन सकता है जो सब कुछ बहुत धीमा कर देता है। नोविस डेवलपर्स वुल्फराम भाषा के कई सबसे महत्वपूर्ण प्रतिमानों, विचारों और सिद्धांतों को नहीं जानते हैं, ऐसे कोड लिखते हैं जो वास्तव में बेतहाशा अक्षम होते हैं और उसके बाद निराश होते हैं, हालांकि वोल्फग्राम भाषा को दोष नहीं देना है। यह लेख इस लेख को सही करने के लिए है।

मुझे 2005 के बाद से (पहले से काफी दूर) वुल्फराम भाषा के साथ काम करने का मौका मिला (तब मैथमेटिका 5.2 का संस्करण था, अब यह 12 वां है)। पिछले 15 वर्षों में, बहुत कुछ हुआ है: हजारों नए अंतर्निहित कार्य और क्षेत्र जिनमें वे काम करते हैं उन्हें जोड़ा गया है ( मशीन लर्निंग , सटीक ज्यामिति , ऑडियो के साथ काम करना, वेब पर काम करना , क्लाउड क्षमताएं , माप की इकाइयों के लिए गहरा समर्थन, वुल्फराम डेटाबेस के लिए एकीकरण | अल्फा पर , भौगोलिक गणना , के साथ काम करने के लिए समर्थन CUDA , अजगर , के साथ में चलाना बादल - संचालन, और भी बहुत कुछ), नई सेवाओं Wolfram बादल द्वारा , कंप्यूटर मूल्य का एक प्रसिद्ध प्रणाली अल्फा पर | Wolfram द्वारा , भंडार के कार्यों , तंत्रिका नेटवर्क के भंडार और आदि ।

इन वर्षों में, मैंने वुल्फराम भाषा का बहुत उपयोग किया (हाँ, पहले, वास्तव में, इसे मैथेमेटिका कहा जाता था, इससे पहले कि स्टीफन वोल्फ़्राम ने भाषा को एकल न करने और अपने उत्पादों की एक पूरी आकाशगंगा के लिए सामान्य बनाने का फैसला किया) और विभिन्न क्षेत्रों में मैं एक बिक्री मॉडल बनाने में कामयाब रहा। एक दवा कंपनी के लिए; मूवी रेंटल इंडस्ट्री के लिए पर्सर्स और ऑटोमैटिक मूवी एल्बम जनरेटर्स बनाएँ (जब वे सिर्फ अपनी शैशवावस्था में थे); विज्ञान में सक्रिय रूप से लागू (रसायन विज्ञान और ठोस राज्य भौतिकी और विनाश सिद्धांत में काम); रूस में इस बाजार में घरेलू स्कूल और विश्वविद्यालय शिक्षा और अग्रणी कंपनियों और प्रकाशकों के प्लेटफार्मों के लिए शिक्षण प्रणालियों के प्रोटोटाइप विकसित करना।

MBLT DEV और वोल्फ्राम सम्मेलनों में मेरे कुछ भाषणों का रिकॉर्ड

, , , 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!

— .
. .

वुल्फ्राम भाषा में धीमी कोड विनाश के कोनेस्टोन: कोड दसियों, सैकड़ों और हजारों बार तेजी

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`