({{AASTriangle[α,β,a]}})

({{AbelianGroup[{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{Abort[]}})

({{AbortKernels[]}})

({{AbortProtect[expr]}})

({{AbortScheduledTask[task]}})

({{Abs[z]}})

({{AbsArg[z]}})

({{AbsoluteCorrelation[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{AbsoluteCorrelation[m]}})

({{AbsoluteCorrelation[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{AbsoluteCorrelation[dist]}})

({{AbsoluteCorrelation[dist,i,j]}})

({{AbsoluteCorrelationFunction[data,hspec]}})

({{AbsoluteCorrelationFunction[proc,hspec]}})

({{AbsoluteCorrelationFunction[proc,s,t]}})

({{AbsoluteCurrentValue[item]}})

({{AbsoluteCurrentValue[{item,spec}]}})

({{AbsoluteCurrentValue[obj,item]}})

({{AbsoluteDashing[{(Subscript[d, 1]),(Subscript[d, 2]),…}]}})

({{AbsoluteDashing[d]}})

({{AbsoluteDashing[{d,d}]}})

({{AbsoluteFileName["name"]}})

({{AbsoluteOptions[expr]}})

({{AbsoluteOptions[expr,name]}})

({{AbsoluteOptions[expr,{(Subscript[name, 1]),(Subscript[name, 2]),…}]}})

({{AbsoluteOptions[object]}})

({{AbsolutePointSize[d]}})

({{AbsoluteThickness[d]}})

({{AbsoluteTiming[expr]}})

({{Accuracy[x]}})

({{AcyclicGraphQ[g]}})

({{AddSides[rel,x]}})

({{AddSides[(Subscript[rel, 1]),(Subscript[rel, 2])]}})

({{AddUsers[group,{(Subscript[user, 1]),…}]}})

({{AdjacencyList[g,v]}})

({{AdjacencyList[g,patt]}})

({{AdjacencyList[g,patt,d]}})

({{AdjacencyList[{v->w,…},…]}})

({{AdjacencyMatrix[g]}})

({{AdjacencyMatrix[{v->w,…}]}})

({{AdjustTimeSeriesForecast[tproc,forecast,newdata]}})

({{AdministrativeDivisionData[entity,property]}})

({{AdministrativeDivisionData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{AdministrativeDivisionData[entity,property,annotation]}})

({{AffineHalfSpace[{(Subscript[p, 1]),…,(Subscript[p, k+1])},w]}})

({{AffineHalfSpace[p,{(Subscript[v, 1]),…,(Subscript[v, k])},w]}})

({{AffineSpace[{(Subscript[p, 1]),…,(Subscript[p, k+1])}]}})

({{AffineSpace[p,{(Subscript[v, 1]),…,(Subscript[v, k])}]}})

({{AffineTransform[m]}})

({{AffineTransform[{m,v}]}})

({{AircraftData[entity,property]}})

({{AircraftData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{AircraftData[entity,property,annotation]}})

({{AirportData[entity,property]}})

({{AirportData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{AirportData[entity,property,annotation]}})

({{AiryAi[z]}})

({{AiryAiPrime[z]}})

({{AiryAiZero[k]}})

({{AiryAiZero[k,(Subscript[x, 0])]}})

({{AiryBi[z]}})

({{AiryBiPrime[z]}})

({{AiryBiZero[k]}})

({{AiryBiZero[k,(Subscript[x, 0])]}})

({{AlgebraicIntegerQ[a]}})

({{AlgebraicNumber[θ,{(Subscript[c, 0]),(Subscript[c, 1]),…,(Subscript[c, n])}]}})

({{AlgebraicNumberDenominator[a]}})

({{AlgebraicNumberPolynomial[a,x]}})

({{AlgebraicUnitQ[a]}})

({{AllTrue[{(Subscript[e, 1]),(Subscript[e, 2]),…},test]}})

({{AllTrue[expr,test,level]}})

({{AllTrue[test]}})

({{AlphaChannel[image]}})

({{AlternatingFactorial[n]}})

({{AlternatingGroup[n]}})

({{AmbiguityList[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{AmbiguityList[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},"string"]}})

({{AmbiguityList[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},"string",{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{AnatomyData[entity,property]}})

({{AnatomyData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{AnatomyData[entity,property,annotation]}})

({{AnatomyForm[g]}})

({{AngerJ[ν,z]}})

({{AngerJ[ν,μ,z]}})

({{AngleBracket[x,y,…]}})

({{AnglePath[{(Subscript[θ, 1]),(Subscript[θ, 2]),(Subscript[θ, 3]),…}]}})

({{AnglePath[{{(Subscript[r, 1]),(Subscript[θ, 1])},{(Subscript[r, 2]),(Subscript[θ, 2])},{(Subscript[r, 3]),(Subscript[θ, 3])},…}]}})

({{AnglePath[(Subscript[θ, 0]),{(Subscript[step, 1]),(Subscript[step, 2]),…}]}})

({{AnglePath[{x,y},{(Subscript[step, 1]),(Subscript[step, 2]),…}]}})

({{AnglePath[{{x,y},(Subscript[θ, 0])},{(Subscript[step, 1]),(Subscript[step, 2]),…}]}})

({{AnglePath[{{x,y},{dx,dy}},{(Subscript[step, 1]),(Subscript[step, 2]),…}]}})

({{AnglePath[init,steps,form]}})

({{AnglePath3D[{{(Subscript[α, 1]),(Subscript[β, 1]),(Subscript[γ, 1])},{(Subscript[α, 2]),(Subscript[β, 2]),(Subscript[γ, 2])},…}]}})

({{AnglePath3D[{{(Subscript[α, 1]),(Subscript[β, 1])},{(Subscript[α, 2]),(Subscript[β, 2])},…}]}})

({{AnglePath3D[{(Subscript[mat, 1]),(Subscript[mat, 2]),…}]}})

({{AnglePath3D[{{(Subscript[r, 1]),(Subscript[rot, 1])},{(Subscript[r, 2]),(Subscript[rot, 2])},…}]}})

({{AnglePath3D[{(Subscript[x, 0]),(Subscript[y, 0]),(Subscript[z, 0])},steps]}})

({{AnglePath3D[{(Subscript[rot, 0])},steps]}})

({{AnglePath3D[{{(Subscript[x, 0]),(Subscript[y, 0]),(Subscript[z, 0])},(Subscript[rot, 0])},steps]}})

({{AnglePath3D[init,steps,form]}})

({{AngleVector[θ]}})

({{AngleVector[{r,θ}]}})

({{AngleVector[{x,y},θ]}})

({{AngleVector[{x,y},{r,θ}]}})

({{Annotation[expr,data]}})

({{Annotation[expr,data,"type"]}})

({{AnnuityDue[p,t]}})

({{AnnuityDue[p,t,q]}})

({{AnnuityDue[{p,{(Subscript[p, initial]),(Subscript[p, final])}},t,q]}})

({{Annulus[{x,y},{(Subscript[r, inner]),(Subscript[r, outer])}]}})

({{Annulus[{x,y},{(Subscript[r, inner]),(Subscript[r, outer])},{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{Antisymmetric[{(Subscript[s, 1]),…,(Subscript[s, n])}]}})

({{AnyOrder[(Subscript[p, 1]),(Subscript[p, 2]),…]}})

({{AnySubset[{(Subscript[c, 1]),(Subscript[c, 2]),…}]}})

({{AnySubset[{(Subscript[lab, 1])->(Subscript[c, 1]),(Subscript[lab, 2])->(Subscript[c, 2]),…}]}})

({{AnySubset[EntityClass["type","class"]]}})

({{AnySubset[choices,max]}})

({{AnySubset[choices,{min,max}]}})

({{AnyTrue[{(Subscript[e, 1]),(Subscript[e, 2]),…},test]}})

({{AnyTrue[expr,test,level]}})

({{AnyTrue[test]}})

({{AppellF1[a,(Subscript[b, 1]),(Subscript[b, 2]),c,x,y]}})

({{Append[expr,elem]}})

({{Append[elem]}})

({{AppendTo[s,elem]}})

({{ApplySides[f,rel]}})

({{ArcCos[z]}})

({{ArcCosh[z]}})

({{ArcCot[z]}})

({{ArcCoth[z]}})

({{ArcCsc[z]}})

({{ArcCsch[z]}})

({{ARCHProcess[κ,{(Subscript[α, 1]),…,(Subscript[α, q])}]}})

({{ARCHProcess[κ,{(Subscript[α, 1]),…,(Subscript[α, q])},init]}})

({{ArcSec[z]}})

({{ArcSech[z]}})

({{ArcSin[z]}})

({{ArcSinDistribution[{(Subscript[x, min]),(Subscript[x, max])}]}})

({{ArcSinDistribution[]}})

({{ArcSinh[z]}})

({{ArcTan[z]}})

({{ArcTan[x,y]}})

({{ArcTanh[z]}})

({{Arg[z]}})

({{ArgumentCountQ[head, len, min, max]}})

({{ArgumentCountQ[head,len,{(Subscript[m, 1]),(Subscript[m, 2]),…,(Subscript[m, i])}]}})

({{ARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},v]}})

({{ARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{ARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[d, 1]),…,(Subscript[d, n])},{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{ARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},v,init]}})

({{ARIMAProcess[c,…]}})

({{ArithmeticGeometricMean[a,b]}})

({{ARMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},v]}})

({{ARMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{ARMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},v,init]}})

({{ARMAProcess[c,…]}})

({{ARProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},v]}})

({{ARProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},Σ]}})

({{ARProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},v,init]}})

({{ARProcess[c,…]}})

({{Array[f,n]}})

({{Array[f,n,r]}})

({{Array[f,n,{a,b}]}})

({{Array[f,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{Array[f,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{Array[f,{(Subscript[n, 1]),(Subscript[n, 2]),…},{{(Subscript[a, 1]),(Subscript[b, 1])},{(Subscript[a, 2]),(Subscript[b, 2])},…}]}})

({{Array[f,dims,origin,h]}})

({{ArrayComponents[array]}})

({{ArrayComponents[array,level]}})

({{ArrayComponents[array,level,rules]}})

({{ArrayFlatten[{{(Subscript[m, 11]),(Subscript[m, 12]),…},{(Subscript[m, 21]),(Subscript[m, 22]),…},…}]}})

({{ArrayFlatten[a,r]}})

({{ArrayQ[expr]}})

({{ArrayQ[expr,patt]}})

({{ArrayQ[expr,patt,test]}})

({{ArrayReshape[list,dims]}})

({{ArrayReshape[list,dims,padding]}})

({{ArrayRules[SparseArray[…]]}})

({{ArrayRules[list]}})

({{Arrays[{(Subscript[d, 1]),…,(Subscript[d, r])}]}})

({{Arrays[{(Subscript[d, 1]),…,(Subscript[d, r])},dom]}})

({{Arrays[{(Subscript[d, 1]),…,(Subscript[d, r])},dom,sym]}})

({{Arrow[{(Subscript[pt, 1]),(Subscript[pt, 2])}]}})

({{Arrow[{(Subscript[pt, 1]),(Subscript[pt, 2])},s]}})

({{Arrow[{(Subscript[pt, 1]),(Subscript[pt, 2])},{(Subscript[s, 1]),(Subscript[s, 2])}]}})

({{Arrow[curve,…]}})

({{ASATriangle[α,c,β]}})

({{Ask["key"]}})

({{Ask["key"->formspec]}})

({{Ask[{"(Subscript[key, 1])","(Subscript[key, 2])",…}]}})

({{Ask[{"(Subscript[key, 1])"->(Subscript[formspec, 1]),"(Subscript[key, 2])"->(Subscript[formspec, 2]),…}]}})

({{AskAppend["key"]}})

({{AskAppend["key"->formspec]}})

({{AskConfirm["key"]}})

({{AskConfirm["key",fun]}})

({{AskConfirm["key","str"]}})

({{AskDisplay[expr]}})

({{AskedQ["key"]}})

({{AskedValue["key"]}})

({{AskState[]}})

({{AskTemplateDisplay[fun]}})

({{AskTemplateDisplay["str\!\(\*StyleBox["\"", "TI"]\)]}})

({{Assert[test]}})

({{Assert[test,tag]}})

({{AssociateTo[a,key->val]}})

({{AssociateTo[a,{(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…}]}})

({{Association[(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…]}})

({{AssociationMap[f,{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{AssociationMap[f,\[LeftAssociation](Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…\[RightAssociation]]}})

({{AssociationMap[f]}})

({{AssociationQ[expr]}})

({{AssociationThread[{(Subscript[key, 1]),(Subscript[key, 2]),…}->{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{AssociationThread[{(Subscript[key, 1]),(Subscript[key, 2]),…},{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{Assuming[assum,expr]}})

({{AstronomicalData["name","property"]}})

({{AstronomicalData["name",{"property",date}]}})

({{AsynchronousTaskObject["name",id,sessionid]}})

({{AsynchronousTasks[]}})

({{AtomQ[expr]}})

({{Attributes[symbol]}})

({{AudioAmplify[audio,s]}})

({{AudioChannelMix[audio]}})

({{AudioChannelMix[audio,desttype]}})

({{AudioChannels[audio]}})

({{AudioChannelSeparate[audio]}})

({{AudioChannelSeparate[audio,channel]}})

({{AudioDelete[audio,t]}})

({{AudioDelete[audio,-t]}})

({{AudioDelete[audio,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{AudioDelete[audio,{{(Subscript[t, 11]),(Subscript[t, 12])},…}]}})

({{AudioInsert[audio,t->new]}})

({{AudioInsert[audio,{(Subscript[t, 1]),(Subscript[t, 2]),…}->new]}})

({{AudioInsert[audio,{(Subscript[t, 1])->(Subscript[new, 1]),…}]}})

({{AudioLength[audio]}})

({{AudioNormalize[audio]}})

({{AudioNormalize[audio,model]}})

({{AudioPad[audio,t]}})

({{AudioPad[audio,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{AudioPad[audio,tspec,padding]}})

({{AudioPan[audio]}})

({{AudioPan[audio,pan]}})

({{AudioPause[]}})

({{AudioPause[astream]}})

({{AudioPause[audio]}})

({{AudioQ[audio]}})

({{AudioReplace[audio,{(Subscript[t, 1]),(Subscript[t, 2])}->new]}})

({{AudioReplace[audio,{{(Subscript[t, 11]),(Subscript[t, 12])},…}->new]}})

({{AudioReplace[audio,{{(Subscript[t, 11]),(Subscript[t, 12])}->(Subscript[new, 1]),…}]}})

({{AudioReplace[audio,{(Subscript[t, 1]),(Subscript[t, 2])}->new,fitting]}})

({{AudioSampleRate[audio]}})

({{AudioSplit[audio,t]}})

({{AudioSplit[audio,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{AudioStop[]}})

({{AudioStop[astream]}})

({{AudioStop[audio]}})

({{AudioStreams[]}})

({{AudioStreams[audio]}})

({{AudioStreams[audio,"prop"]}})

({{AudioType[audio]}})

({{AugmentedSymmetricPolynomial[{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{AugmentedSymmetricPolynomial[{{(Subscript[r, 11]),…,(Subscript[r, 1n])},{(Subscript[r, 21]),…,(Subscript[r, 2n])},…}]}})

({{AugmentedSymmetricPolynomial[rspec,data]}})

({{Autocomplete[{"(Subscript[string, 1])","(Subscript[string, 2])",…},"string"]}})

({{Autocomplete[\[LeftAssociation]"(Subscript[s, 1])"->(Subscript[w, 1]),"(Subscript[s, 2])"->(Subscript[w, 2]),…\[RightAssociation],"string"]}})

({{Autocomplete[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},"string"]}})

({{Autocomplete[comps,"string",n]}})

({{Autocomplete[comps]}})

({{AutoRefreshed[expr]}})

({{AutoRefreshed[expr,dt]}})

({{AutoRefreshed[expr,timespec]}})

({{AutoRefreshed[expr,timespec,fmt]}})

({{AutoRefreshed[expr,timespec,{fmt,rform}]}})

({{AutoSubmitting[spec]}})

({{BabyMonsterGroupB[]}})

({{Backslash[x,y,…]}})

({{Ball[p]}})

({{Ball[p,r]}})

({{Ball[{(Subscript[p, 1]),(Subscript[p, 2]),…},r]}})

({{Band[{i,j}]}})

({{Band[{(Subscript[i, min]),(Subscript[j, min]),…},{(Subscript[i, max]),(Subscript[j, max]),…}]}})

({{Band[{(Subscript[i, min]),(Subscript[j, min]),…},{(Subscript[i, max]),(Subscript[j, max]),…},{di,dj,…}]}})

({{BarabasiAlbertGraphDistribution[n,k]}})

({{BarcodeImage["string",format]}})

({{BarcodeImage["string",format,size]}})

({{BarcodeRecognize[image]}})

({{BarcodeRecognize[image,"prop"]}})

({{BarcodeRecognize[image,"prop",format]}})

({{BarlowProschanImportance[rdist]}})

({{BarlowProschanImportance[fdist]}})

({{BarnesG[z]}})

({{BartlettHannWindow[x]}})

({{BartlettWindow[x]}})

({{BaseDecode["string"]}})

({{BaseEncode[ba]}})

({{BaseForm[expr,n]}})

({{BatesDistribution[n]}})

({{BatesDistribution[n,{min,max}]}})

({{BattleLemarieWavelet[]}})

({{BattleLemarieWavelet[n]}})

({{BattleLemarieWavelet[n,lim]}})

({{Because[x,y]}})

({{BeckmannDistribution[(Subscript[μ, 1]),(Subscript[μ, 2]),(Subscript[σ, 1]),(Subscript[σ, 2])]}})

({{BeckmannDistribution[(Subscript[μ, 1]),(Subscript[μ, 2]),(Subscript[σ, 1]),(Subscript[σ, 2]),ρ]}})

({{Beep[]}})

({{Begin["context`"]}})

({{BeginDialogPacket[integer]}})

({{BeginPackage["context`"]}})

({{BeginPackage["context`",{"(Subscript[need, 1])`","(Subscript[need, 2])`",…}]}})

({{BellB[n]}})

({{BellB[n,x]}})

({{BellY[n,k,{(Subscript[x, 1]),…,(Subscript[x, n-k+1])}]}})

({{BellY[n,k,m]}})

({{BellY[m]}})

({{BenfordDistribution[b]}})

({{BeniniDistribution[α,β,σ]}})

({{BenktanderGibratDistribution[a,b]}})

({{BenktanderWeibullDistribution[a,b]}})

({{BernoulliB[n]}})

({{BernoulliB[n,x]}})

({{BernoulliDistribution[p]}})

({{BernoulliProcess[p]}})

({{BernsteinBasis[d,n,x]}})

({{BesselFilterModel[n]}})

({{BesselFilterModel[{n,(Subscript[ω, c])}]}})

({{BesselFilterModel[{n,(Subscript[ω, c])},var]}})

({{BesselI[n,z]}})

({{BesselJ[n,z]}})

({{BesselJZero[n,k]}})

({{BesselJZero[n,k,(Subscript[x, 0])]}})

({{BesselK[n,z]}})

({{BesselY[n,z]}})

({{BesselYZero[n,k]}})

({{BesselYZero[n,k,(Subscript[x, 0])]}})

({{Beta[a,b]}})

({{Beta[z,a,b]}})

({{BetaBinomialDistribution[α,β,n]}})

({{BetaDistribution[α,β]}})

({{BetaNegativeBinomialDistribution[α,β,n]}})

({{BetaPrimeDistribution[p,q]}})

({{BetaPrimeDistribution[p,q,β]}})

({{BetaPrimeDistribution[p,q,α,β]}})

({{BetaRegularized[z,a,b]}})

({{Between[x,{min,max}]}})

({{Between[x,{{(min_1),(max_1)},{(min_2),(max_2)},…}]}})

({{Between[range]}})

({{Between[x,range]}})

({{BetweennessCentrality[g]}})

({{BetweennessCentrality[{v->w,…}]}})

({{BinaryDeserialize[ByteArray[…]]}})

({{BinaryDeserialize[ByteArray[…],h]}})

({{BinaryDistance[u,v]}})

({{BinaryImageQ[image]}})

({{BinCounts[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{BinCounts[{(Subscript[x, 1]),(Subscript[x, 2]),…},dx]}})

({{BinCounts[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[x, min]),(Subscript[x, max]),dx}]}})

({{BinCounts[{(Subscript[x, 1]),(Subscript[x, 2]),…},{{(Subscript[b, 1]),(Subscript[b, 2]),…}}]}})

({{BinCounts[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…},xbins,ybins,…]}})

({{BinLists[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{BinLists[{(Subscript[x, 1]),(Subscript[x, 2]),…},dx]}})

({{BinLists[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[x, min]),(Subscript[x, max]),dx}]}})

({{BinLists[{(Subscript[x, 1]),(Subscript[x, 2]),…},{{(Subscript[b, 1]),(Subscript[b, 2]),…}}]}})

({{BinLists[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…},xbins,ybins,…]}})

({{Binomial[n,m]}})

({{BinomialDistribution[n,p]}})

({{BinomialProcess[p]}})

({{BinormalDistribution[{(Subscript[μ, 1]),(Subscript[μ, 2])},{(Subscript[σ, 1]),(Subscript[σ, 2])},ρ]}})

({{BinormalDistribution[{(Subscript[σ, 1]),(Subscript[σ, 2])},ρ]}})

({{BinormalDistribution[ρ]}})

({{BiorthogonalSplineWavelet[]}})

({{BiorthogonalSplineWavelet[n,m]}})

({{BipartiteGraphQ[g]}})

({{BiquadraticFilterModel[{ω,q}]}})

({{BiquadraticFilterModel[{"type",spec}]}})

({{BiquadraticFilterModel[{"type",spec},var]}})

({{BirnbaumImportance[rdist,t]}})

({{BirnbaumImportance[fdist,t]}})

({{BirnbaumSaundersDistribution[α,λ]}})

({{BitAnd[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{BitClear[n,k]}})

({{BitGet[n,k]}})

({{BitLength[n]}})

({{BitNot[n]}})

({{BitOr[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{BitSet[n,k]}})

({{BitShiftLeft[n,k]}})

({{BitShiftLeft[n]}})

({{BitShiftRight[n,k]}})

({{BitShiftRight[n]}})

({{BitXor[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{BiweightMidvariance[list]}})

({{BiweightMidvariance[list,c]}})

({{BlackmanHarrisWindow[x]}})

({{BlackmanNuttallWindow[x]}})

({{BlackmanWindow[x]}})

({{Blank[]}})

({{Blank[h]}})

({{BlankNullSequence[]}})

({{BlankNullSequence[h]}})

({{BlankSequence[]}})

({{BlankSequence[h]}})

({{Blend[{(Subscript[col, 1]),(Subscript[col, 2])},x]}})

({{Blend[{(Subscript[col, 1]),(Subscript[col, 2]),(Subscript[col, 3]),…},x]}})

({{Blend[{{(Subscript[x, 1]),(Subscript[col, 1])},{(Subscript[x, 2]),(Subscript[col, 2])},…},x]}})

({{Blend[{(Subscript[col, 1]),(Subscript[col, 2]),…},{(Subscript[u, 1]),(Subscript[u, 2]),…}]}})

({{Blend[{(Subscript[image, 1]),(Subscript[image, 2]),…},…]}})

({{Block[{x,y,…},expr]}})

({{Block[{x=(Subscript[x, 0]),…},expr]}})

({{BlockchainGet[id]}})

({{BlockchainPut[expr]}})

({{BlockMap[f,list,n]}})

({{BlockMap[f,list,n,d]}})

({{BlockMap[f,list,{(Subscript[n, 1]),(Subscript[n, 2]),…},…]}})

({{BlomqvistBeta[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{BlomqvistBeta[m]}})

({{BlomqvistBeta[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{BlomqvistBeta[dist]}})

({{BlomqvistBeta[dist,i,j]}})

({{Blur[image]}})

({{Blur[image,r]}})

({{BohmanWindow[x]}})

({{Boole[expr]}})

({{BooleanConsecutiveFunction[k,n]}})

({{BooleanConsecutiveFunction[{k,True},n]}})

({{BooleanConsecutiveFunction[{(Subscript[k, 1]),(Subscript[k, 2]),…,(Subscript[k, d])},{(Subscript[n, 1]),(Subscript[n, 2]),…,(Subscript[n, d])}]}})

({{BooleanConsecutiveFunction[{{(Subscript[k, 1]),(Subscript[k, 2]),…,(Subscript[k, d])},{(Subscript[c, 1]),(Subscript[c, 2]),…,(Subscript[c, d])}},{(Subscript[n, 1]),(Subscript[n, 2]),…,(Subscript[n, d])}]}})

({{BooleanConsecutiveFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanConsecutiveFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…},form]}})

({{BooleanCountingFunction[(Subscript[k, max]),n]}})

({{BooleanCountingFunction[{k},n]}})

({{BooleanCountingFunction[{(Subscript[k, min]),(Subscript[k, max])},n]}})

({{BooleanCountingFunction[{{(Subscript[k, 1]),(Subscript[k, 2]),…}},n]}})

({{BooleanCountingFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanCountingFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…},form]}})

({{BooleanFunction[k,n]}})

({{BooleanFunction[values]}})

({{BooleanFunction[{{(Subscript[i, 11]),(Subscript[i, 12]),…}->(Subscript[o, 1]),…}]}})

({{BooleanFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanFunction[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…},form]}})

({{BooleanMaxterms[k,n]}})

({{BooleanMaxterms[{(Subscript[k, 1]),(Subscript[k, 2]),…},n]}})

({{BooleanMaxterms[{{(Subscript[u, 1]),…,(Subscript[u, n])},{(Subscript[v, 1]),…},…}]}})

({{BooleanMaxterms[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanMaxterms[spec,{a,(Subscript[a, 2]),…},form]}})

({{BooleanMinterms[k,n]}})

({{BooleanMinterms[{(Subscript[k, 1]),(Subscript[k, 2]),…},n]}})

({{BooleanMinterms[{{(Subscript[u, 1]),…,(Subscript[u, n])},{(Subscript[v, 1]),…},…}]}})

({{BooleanMinterms[spec,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanMinterms[spec,{a,(Subscript[a, 2]),…},form]}})

({{BooleanQ[expr]}})

({{BooleanTable[bf]}})

({{BooleanTable[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{BooleanTable[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),…},…]}})

({{BooleanVariables[expr]}})

({{BooleanVariables[bf]}})

({{BorelTannerDistribution[α,n]}})

({{BottomHatTransform[image,ker]}})

({{BottomHatTransform[image,r]}})

({{BottomHatTransform[data,…]}})

({{BoundaryMeshRegionQ[reg]}})

({{BoundedRegionQ[reg]}})

({{BoxData[boxes]}})

({{BoxMatrix[r]}})

({{BoxMatrix[r,w]}})

({{BoxMatrix[{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{BoxObject[id]}})

({{BracketingBar[x, y, …]}})

({{BrayCurtisDistance[u,v]}})

({{BreadthFirstScan[g,s,{"(Subscript[event, 1])"->(Subscript[f, 1]),"(Subscript[event, 2])"->(Subscript[f, 2]),…}]}})

({{BreadthFirstScan[g,{"(Subscript[event, 1])"->(Subscript[f, 1]),"(Subscript[event, 2])"->(Subscript[f, 2]),…}]}})

({{BreadthFirstScan[{v->w,…},…]}})

({{Break[]}})

({{BridgeData[entity,property]}})

({{BridgeData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{BridgeData[entity,property,annotation]}})

({{BroadcastStationData[entity,property]}})

({{BroadcastStationData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{BroadcastStationData[entity,property,annotation]}})

({{BrownianBridgeProcess[σ,{(Subscript[t, 1]),a},{(Subscript[t, 2]),b}]}})

({{BrownianBridgeProcess[{(Subscript[t, 1]),a},{(Subscript[t, 2]),b}]}})

({{BrownianBridgeProcess[(Subscript[t, 1]),(Subscript[t, 2])]}})

({{BrownianBridgeProcess[]}})

({{BSplineBasis[d,x]}})

({{BSplineBasis[d,n,x]}})

({{BuildingData[entity,property]}})

({{BuildingData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{BuildingData[entity,property,annotation]}})

({{ButterworthFilterModel[n]}})

({{ButterworthFilterModel[{n,(Subscript[ω, c])}]}})

({{ButterworthFilterModel[{"type",spec}]}})

({{ButterworthFilterModel[{"type",spec},var]}})

({{ButtonNotebook[]}})

({{ByteArray[{(Subscript[b, 1]),(Subscript[b, 2]),…}]}})

({{ByteArray["string"]}})

({{ByteArrayQ[expr]}})

({{ByteArrayToString[ba]}})

({{ByteArrayToString[ba,"encoding"]}})

({{ByteCount[expr]}})

({{C[i]}})

({{CalendarConvert[date,calendar]}})

({{CalendarConvert[date]}})

({{CalendarConvert[{(Subscript[date, 1]),…,(Subscript[date, n])},calendar]}})

({{CalendarData[]}})

({{CalendarData[country]}})

({{CallPacket[integer,list]}})

({{CanberraDistance[u,v]}})

({{CanonicalGraph[g]}})

({{CanonicalGraph[{v->w,…}]}})

({{CanonicalName[entity]}})

({{CanonicalName[{(Subscript[entity, 1]),…,(Subscript[entity, n])}]}})

({{CantorStaircase[x]}})

({{Cap[x,y,…]}})

({{CapForm[type]}})

({{CapitalDifferentialD[x]}})

({{Capitalize[string]}})

({{Capitalize[string,scheme]}})

({{CapsuleShape[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])}},r]}})

({{CarlemanLinearize[sys,spec]}})

({{CarmichaelLambda[n]}})

({{CaseSensitive[patt]}})

({{Cashflow[{(Subscript[c, 0]),(Subscript[c, 1]),…,(Subscript[c, n])}]}})

({{Cashflow[{(Subscript[c, 0]),(Subscript[c, 1]),…,(Subscript[c, n])},q]}})

({{Cashflow[{{(Subscript[time, 1]),(Subscript[c, 1])},{(Subscript[time, 2]),(Subscript[c, 2])},…}]}})

({{Casoratian[{(Subscript[y, 1]),(Subscript[y, 2]),…},n]}})

({{Casoratian[eqn,y,n]}})

({{Casoratian[eqns,{(Subscript[y, 1]),(Subscript[y, 2]),…},n]}})

({{CatalanNumber[n]}})

({{Catch[expr]}})

({{Catch[expr,form]}})

({{Catch[expr,form,f]}})

({{Catenate[{(Subscript[list, 1]),(Subscript[list, 2]),…}]}})

({{Catenate[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{CauchyDistribution[a,b]}})

({{CauchyDistribution[]}})

({{CauchyWindow[x]}})

({{CauchyWindow[x,α]}})

({{CDF[dist,x]}})

({{CDF[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{CDF[dist]}})

({{CDFWavelet[]}})

({{CDFWavelet["type"]}})

({{Ceiling[x]}})

({{Ceiling[x,a]}})

({{CellGroup[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{CellGroup[{(Subscript[cell, 1]),(Subscript[cell, 2]),…},1]}})

({{CellGroup[{(Subscript[cell, 1]),(Subscript[cell, 2]),…},-1]}})

({{CellGroup[{(Subscript[cell, 1]),(Subscript[cell, 2]),…},{(Subscript[i, 1]),(Subscript[i, 2]),…}]}})

({{CellGroupData[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{CellGroupData[{(Subscript[cell, 1]),(Subscript[cell, 2]),…},status]}})

({{CellGroupData[{(Subscript[cell, 1]),(Subscript[cell, 2]),…},{(Subscript[i, 1]),(Subscript[i, 2]),…}]}})

({{CellObject[id]}})

({{CellPrint[expr]}})

({{CellPrint[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{CellularAutomaton[rule,init,t]}})

({{CellularAutomaton[rule,init]}})

({{CellularAutomaton[rule,init,{tspec,xspec,…}]}})

({{CellularAutomaton[rule,init,{t,All,…}]}})

({{CellularAutomaton[rule]}})

({{CensoredDistribution[{(Subscript[x, min]),(Subscript[x, max])},dist]}})

({{CensoredDistribution[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…},dist]}})

({{Censoring[t,c]}})

({{Censoring[{(Subscript[t, 1]),(Subscript[t, 2]),…},c]}})

({{Censoring[{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[c, 1]),(Subscript[c, 2]),…}]}})

({{CenterArray[a,n]}})

({{CenterArray[a,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{CenterArray[a,nspec,pad]}})

({{CenterArray[nspec]}})

({{CenterDot[x,y,…]}})

({{CentralMoment[list,r]}})

({{CentralMoment[dist,r]}})

({{CentralMoment[r]}})

({{CentralMomentGeneratingFunction[dist,t]}})

({{CentralMomentGeneratingFunction[dist,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{CForm[expr]}})

({{ChampernowneNumber[b]}})

({{ChampernowneNumber[]}})

({{ChannelListener[…]}})

({{ChannelListeners[]}})

({{CharacteristicFunction[dist,t]}})

({{CharacteristicFunction[dist,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{CharacteristicPolynomial[m,x]}})

({{CharacteristicPolynomial[{m,a},x]}})

({{CharacterName["c"]}})

({{CharacterName[n]}})

({{CharacterName[c,"type"]}})

({{CharacterRange["(Subscript[c, 1])","(Subscript[c, 2])"]}})

({{CharacterRange[(Subscript[n, 1]),(Subscript[n, 2])]}})

({{Characters["string"]}})

({{Chebyshev1FilterModel[n]}})

({{Chebyshev1FilterModel[{n,(Subscript[ω, c])}]}})

({{Chebyshev1FilterModel[{"type",spec}]}})

({{Chebyshev1FilterModel[{"type",spec},var]}})

({{Chebyshev2FilterModel[n]}})

({{Chebyshev2FilterModel[{n,(Subscript[ω, c])}]}})

({{Chebyshev2FilterModel[{"type",spec}]}})

({{Chebyshev2FilterModel[{"type",spec},var]}})

({{ChebyshevDistance[u,v]}})

({{ChebyshevT[n,x]}})

({{ChebyshevU[n,x]}})

({{Check[expr,failexpr]}})

({{Check[expr,failexpr,{(Subscript[s, 1])::(Subscript[t, 1]),(Subscript[s, 2])::(Subscript[t, 2]),…}]}})

({{Check[expr,failexpr,"name"]}})

({{CheckAbort[expr,failexpr]}})

({{CheckAll[expr,f]}})

({{ChemicalData["name","property"]}})

({{ChemicalData["name"]}})

({{ChemicalData["class"]}})

({{ChessboardDistance[u,v]}})

({{ChiDistribution[ν]}})

({{ChineseRemainder[{(Subscript[r, 1]),(Subscript[r, 2]),…},{(Subscript[m, 1]),(Subscript[m, 2]),…}]}})

({{ChineseRemainder[{(Subscript[r, 1]),(Subscript[r, 2]),…},{(Subscript[m, 1]),(Subscript[m, 2]),…},d]}})

({{ChiSquareDistribution[ν]}})

({{ChoiceButtons[]}})

({{ChoiceButtons[{(Subscript[act, ok]),(Subscript[act, cancel])}]}})

({{ChoiceButtons[{(Subscript[lbl, ok]),(Subscript[lbl, cancel])},{(Subscript[act, ok]),(Subscript[act, cancel])}]}})

({{CholeskyDecomposition[m]}})

({{Chop[expr]}})

({{ChromaticPolynomial[g,k]}})

({{ChromaticPolynomial[{v->w,…},…]}})

({{Circle[{x,y},r]}})

({{Circle[{x,y}]}})

({{Circle[{x,y},{(Subscript[r, x]),(Subscript[r, y])}]}})

({{Circle[{x,y},…,{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{CircleDot[x,y,…]}})

({{CircleMinus[x,y]}})

({{CirclePlus[x,y,…]}})

({{CirclePoints[n]}})

({{CirclePoints[r,n]}})

({{CirclePoints[{r,(Subscript[θ, 1])},n]}})

({{CirclePoints[{x,y},rspec,n]}})

({{CircleTimes[x]}})

({{CircleTimes[x,y,…]}})

({{CircularOrthogonalMatrixDistribution[n]}})

({{CircularQuaternionMatrixDistribution[n]}})

({{CircularRealMatrixDistribution[n]}})

({{CircularSymplecticMatrixDistribution[n]}})

({{CircularUnitaryMatrixDistribution[n]}})

({{Circumsphere[{(Subscript[p, 1]),…,(Subscript[p, n+1])}]}})

({{CityData["name","property"]}})

({{CityData["name"]}})

({{ClassifierInformation[classifier]}})

({{ClassifierInformation[classifier,prop]}})

({{Clear[(Subscript[symbol, 1]),(Subscript[symbol, 2]),…]}})

({{Clear["(Subscript[form, 1])","(Subscript[form, 2])",…]}})

({{ClearAll[(Subscript[symb, 1]),(Subscript[symb, 2]),…]}})

({{ClearAll["(Subscript[form, 1])","(Subscript[form, 2])",…]}})

({{ClearAttributes[s,attr]}})

({{ClearCookies[domain]}})

({{ClearCookies[assoc]}})

({{ClearCookies[All]}})

({{ClearPermissions[obj,class]}})

({{ClearPermissions[class]}})

({{ClearSystemCache[]}})

({{ClebschGordan[{(Subscript[j, 1]),(Subscript[m, 1])},{(Subscript[j, 2]),(Subscript[m, 2])},{j,m}]}})

({{Clip[x]}})

({{Clip[x,{min,max}]}})

({{Clip[x,{min,max},{(Subscript[v, min]),(Subscript[v, max])}]}})

({{Clock[]}})

({{Clock[t]}})

({{Clock[(Subscript[v, max]),t]}})

({{Clock[{(Subscript[v, min]),(Subscript[v, max])},t]}})

({{Clock[{(Subscript[v, min]),(Subscript[v, max])}]}})

({{Clock[{(Subscript[v, min]),(Subscript[v, max]),dv}]}})

({{Clock[{(Subscript[v, min]),(Subscript[v, max]),dv},t]}})

({{Clock[vals,t,n]}})

({{Close[obj]}})

({{CloseKernels[]}})

({{CloseKernels[k]}})

({{CloseKernels[{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{Closing[image,ker]}})

({{Closing[image,r]}})

({{Closing[data,…]}})

({{CloudDirectory[]}})

({{CloudExpression["name"]}})

({{CloudExpression["http://…"]}})

({{CloudExpression["https://…"]}})

({{CloudExpression[base,(Subscript[part, 1]),(Subscript[part, 2]),…]}})

({{CloudExpressions[]}})

({{CloudExpressions[None]}})

({{CloudExpressions[All]}})

({{CloudFunction[fun]}})

({{CloudFunction[CloudObject[…]]}})

({{CloudFunction[f,h]}})

({{CloudShare[user]}})

({{CloudShare[{(Subscript[user, 1]),(Subscript[user, 2]),…}]}})

({{CloudShare[obj,users]}})

({{CloudSymbol["name"]}})

({{CloudSymbol[obj]}})

({{CloudSymbol["uri"]}})

({{CMYKColor[cyan,magenta,yellow,black]}})

({{CMYKColor[c,m,y,k,a]}})

({{CoifletWavelet[]}})

({{CoifletWavelet[n]}})

({{Colon[x,y,…]}})

({{ColonForm[a,b]}})

({{ColorCombine[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ColorCombine[{(Subscript[image, 1]),(Subscript[image, 2]),…},colorspace]}})

({{ColorConvert[expr,colspace]}})

({{ColorData["scheme"]}})

({{ColorData["scheme","property"]}})

({{ColorData["collection"]}})

({{ColorData[]}})

({{ColorDataFunction[range,…]}})

({{ColorNegate[image]}})

({{ColorNegate[color]}})

({{ColorProfileData[<>,"Description"->"desc","DeviceColorSpace"->"device","IndependentColorSpace"->"ics"]}})

({{ColorQ[color]}})

({{ColorReplace[image,color]}})

({{ColorReplace[image,color->replacement]}})

({{ColorReplace[image,color->replacement,d]}})

({{ColorReplace[image,{(Subscript[color, 1])->(Subscript[replacement, 1]),…},{(Subscript[d, 1]),…}]}})

({{ColorSeparate[image]}})

({{ColorSeparate[image,colorspace]}})

({{ColorSeparate[image,channel]}})

({{ColumnForm[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{ColumnForm[list,horiz]}})

({{ColumnForm[list,horiz,vert]}})

({{CometData[entity,property]}})

({{CometData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{CometData[entity,property,annotation]}})

({{Commonest[list]}})

({{Commonest[list,n]}})

({{CommonestFilter[data,r]}})

({{CommonestFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{CommonName[entity]}})

({{CommonName[{(Subscript[entity, 1]),…,(Subscript[entity, n])}]}})

({{CommonUnits[{(Subscript[quantity, 1]),(Subscript[quantity, 2]),…,(Subscript[quantity, n])}]}})

({{CompanyData[entity,property]}})

({{CompanyData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{CompanyData[entity,property,annotation]}})

({{CompatibleUnitQ[(Subscript[quantity, 1]),(Subscript[quantity, 2])]}})

({{CompiledFunction[args…]}})

({{CompleteGraphQ[g]}})

({{CompleteGraphQ[g,vlist]}})

({{ComposeList[{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{ComposeSeries[(Subscript[series, 1]),(Subscript[series, 2]),…]}})

({{Composition[(Subscript[f, 1]),(Subscript[f, 2]),(Subscript[f, 3]),…]}})

({{CompoundElement[{(Subscript[spec, 1]),(Subscript[spec, 2]),…}]}})

({{CompoundElement[\[LeftAssociation](Subscript[key, 1])->(Subscript[spec, 1]),(Subscript[key, 2])->(Subscript[spec, 2]),…\[RightAssociation]]}})

({{CompoundPoissonDistribution[λ,dist]}})

({{CompoundPoissonProcess[λ,jdist]}})

({{CompoundRenewalProcess[rdist,jdist]}})

({{ConditionalExpression[expr,cond]}})

({{Conditioned[expr,cond]}})

({{Cone[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])}},r]}})

({{Cone[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])}}]}})

({{Congruent[x,y,…]}})

({{ConicHullRegion[{(Subscript[p, 1]),…,(Subscript[p, m+1])}]}})

({{ConicHullRegion[p,{(Subscript[v, 1]),…,(Subscript[v, m])}]}})

({{ConicHullRegion[{(Subscript[p, 1]),…,(Subscript[p, m+1])},{(Subscript[w, 1]),…,(Subscript[w, n])}]}})

({{ConicHullRegion[p,{(Subscript[v, 1]),…,(Subscript[v, m])},{(Subscript[w, 1]),…,(Subscript[w, n])}]}})

({{Conjugate[z]}})

({{Conjunction[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{ConnectedComponents[g]}})

({{ConnectedComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{ConnectedComponents[g,patt]}})

({{ConnectedComponents[{v->w,…},…]}})

({{ConnectedGraphQ[g]}})

({{ConnectLibraryCallbackFunction[mname,cf]}})

({{ConnesWindow[x]}})

({{ConnesWindow[x,α]}})

({{ConstantArray[c,n]}})

({{ConstantArray[c,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{ConstantRegionQ[reg]}})

({{ConstellationData[entity,property]}})

({{ConstellationData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{ConstellationData[entity,property,annotation]}})

({{Construct[f,x]}})

({{Construct[f,(Subscript[x, 1]),…,(Subscript[x, n])]}})

({{Containing["outer","inner"]}})

({{ContentObject["string"]}})

({{ContentObject[File[…]]}})

({{ContentObject[\[LeftAssociation]"(Subscript[name, 1])"->(Subscript[val, 1]),"(Subscript[name, 2])"->(Subscript[val, 2]),…\[RightAssociation]]}})

({{Context[]}})

({{Context[symbol]}})

({{Contexts[]}})

({{Contexts["string"]}})

({{ContextToFileName["context"]}})

({{Continue[]}})

({{ContinuedFraction[x,n]}})

({{ContinuedFraction[x]}})

({{ContinuousMarkovProcess[(Subscript[i, 0]),q]}})

({{ContinuousMarkovProcess[(Subscript[p, 0]),q]}})

({{ContinuousMarkovProcess[…,m,μ]}})

({{ContinuousMarkovProcess[…,g]}})

({{ContinuousTimeModelQ[lsys]}})

({{ContraharmonicMean[list]}})

({{ContraharmonicMean[list,p]}})

({{Control[{u,dom}]}})

({{Control[{{u,(Subscript[u, init])},dom}]}})

({{ControlActive[act,norm]}})

({{ControllabilityMatrix[ssm]}})

({{ControllerInformation[]}})

({{Convergents[list]}})

({{Convergents[x,n]}})

({{Convergents[x]}})

({{ConwayGroupCo1[]}})

({{ConwayGroupCo2[]}})

({{ConwayGroupCo3[]}})

({{CoordinateBoundingBox[coords]}})

({{CoordinateBoundingBox[coords,δ]}})

({{CoordinateBoundingBox[coords,Scaled[s]]}})

({{CoordinateBoundingBox[coords,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{CoordinateBoundingBox[coords,{{(Subscript[p, 1min]),(Subscript[p, 1max])},{(Subscript[p, 2min]),(Subscript[p, 2max])},…}]}})

({{CoordinateBoundingBoxArray[{{(Subscript[x, min]),(Subscript[y, min]),…},{(Subscript[x, max]),(Subscript[y, max]),…}}]}})

({{CoordinateBoundingBoxArray[{min,max},d]}})

({{CoordinateBoundingBoxArray[{min,max},{dx,dy,…}]}})

({{CoordinateBoundingBoxArray[{min,max},Into[n]]}})

({{CoordinateBoundingBoxArray[{min,max},steps,offsets]}})

({{CoordinateBoundingBoxArray[{min,max},steps,offsets,k]}})

({{CoordinateBounds[coords]}})

({{CoordinateBounds[coords,δ]}})

({{CoordinateBounds[coords,Scaled[s]]}})

({{CoordinateBounds[coords,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{CoordinateBoundsArray[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…}]}})

({{CoordinateBoundsArray[{xrange,yrange,…},d]}})

({{CoordinateBoundsArray[{xrange,yrange,…},{dx,dy,…}]}})

({{CoordinateBoundsArray[{xrange,yrange,…},Into[n]]}})

({{CoordinateBoundsArray[{xrange,yrange,…},steps,offsets]}})

({{CoordinateBoundsArray[{xrange,yrange,…},steps,offsets,k]}})

({{CoordinateChartData[chart,property]}})

({{CoordinateChartData[chart,property,{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])}]}})

({{CoordinateTransform[t,pt]}})

({{CoordinateTransform[t,{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{CoordinateTransformData[t,property]}})

({{CoordinateTransformData[t,property,{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])}]}})

({{CoprimeQ[(Subscript[n, 1]),(Subscript[n, 2])]}})

({{CoprimeQ[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{Coproduct[x,y,…]}})

({{CopulaDistribution[ker,{(Subscript[dist, 1]),(Subscript[dist, 2]),…}]}})

({{CopyDatabin[bin]}})

({{CopyDatabin[bin,options]}})

({{CopyDirectory["(Subscript[dir, 1])","(Subscript[dir, 2])"]}})

({{CopyToClipboard[expr]}})

({{Correlation[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{Correlation[m]}})

({{Correlation[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{Correlation[dist]}})

({{Correlation[dist,i,j]}})

({{CorrelationDistance[u,v]}})

({{CorrelationFunction[data,hspec]}})

({{CorrelationFunction[proc,hspec]}})

({{CorrelationFunction[proc,s,t]}})

({{Cos[z]}})

({{Cosh[z]}})

({{CoshIntegral[z]}})

({{CosineDistance[u,v]}})

({{CosineWindow[x]}})

({{CosineWindow[x,α]}})

({{CosIntegral[z]}})

({{Cot[z]}})

({{Coth[z]}})

({{CountDistinct[list]}})

({{CountDistinctBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{CountDistinctBy[f]}})

({{CountRoots[f,x]}})

({{CountRoots[f,{x,a,b}]}})

({{CountryData["tag",property]}})

({{CountryData["tag",{property,…,dates}]}})

({{Counts[list]}})

({{CountsBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{CountsBy[f]}})

({{Covariance[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{Covariance[m]}})

({{Covariance[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{Covariance[dist]}})

({{Covariance[dist,i,j]}})

({{CovarianceFunction[data,hspec]}})

({{CovarianceFunction[proc,hspec]}})

({{CovarianceFunction[proc,s,t]}})

({{CoxianDistribution[{(Subscript[α, 1]),…,(Subscript[α, m-1])},{(Subscript[λ, 1]),…,(Subscript[λ, m])}]}})

({{CoxIngersollRossProcess[μ,σ,θ,(Subscript[x, 0])]}})

({{CreateDatabin[]}})

({{CreateDatabin[options]}})

({{CreateManagedLibraryExpression[mname,f]}})

({{CreatePermissionsGroup["name"]}})

({{CreatePermissionsGroup["name",{(Subscript[user, 1]),(Subscript[user, 2]),…}]}})

({{CreateTemporary[]}})

({{CreateUUID[]}})

({{CreateUUID["base"]}})

({{CriticalityFailureImportance[rdist,t]}})

({{CriticalityFailureImportance[fdist,t]}})

({{CriticalitySuccessImportance[rdist,t]}})

({{CriticalitySuccessImportance[fdist,t]}})

({{CriticalSection[{(Subscript[var, 1]),(Subscript[var, 2]),…},expr]}})

({{Cross[a,b]}})

({{CrossMatrix[r]}})

({{CrossMatrix[r,w]}})

({{CrossMatrix[{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{Csc[z]}})

({{Csch[z]}})

({{CubeRoot[x]}})

({{Cuboid[(Subscript[p, min])]}})

({{Cuboid[(Subscript[p, min]),(Subscript[p, max])]}})

({{Cumulant[dist,r]}})

({{Cumulant[list,r]}})

({{Cumulant[r]}})

({{CumulantGeneratingFunction[dist,t]}})

({{CumulantGeneratingFunction[dist,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{Cup[x,y,…]}})

({{CupCap[x,y,…]}})

({{CurrencyConvert[quantity,target]}})

({{CurrentValue[item]}})

({{CurrentValue[{item,spec}]}})

({{CurrentValue[obj,item]}})

({{Curry[f,n]}})

({{Curry[f]}})

({{Curry[f,{(Subscript[i, 1]),…,(Subscript[i, n])}]}})

({{Curry[f,k->{(Subscript[i, 1]),…,(Subscript[i, n])}]}})

({{CurvatureFlowFilter[image]}})

({{CurvatureFlowFilter[image,t]}})

({{CurvatureFlowFilter[image,t,k]}})

({{CycleIndexPolynomial[perm,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{CycleIndexPolynomial[group,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{Cycles[{(Subscript[cyc, 1]),(Subscript[cyc, 2]),…}]}})

({{CyclicGroup[n]}})

({{Cyclotomic[n,x]}})

({{Cylinder[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])}},r]}})

({{Cylinder[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])}}]}})

({{DagumDistribution[p,a,b]}})

({{DamData[entity,property]}})

({{DamData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{DamData[entity,property,annotation]}})

({{Darker[color]}})

({{Darker[color,f]}})

({{Darker[image,…]}})

({{Dashing[{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{Dashing[r]}})

({{Dashing[{r,r}]}})

({{Databin["id"]}})

({{Databin["id",n]}})

({{Databin["id",-n]}})

({{Databin["id",{m,n}]}})

({{Databin["id",{m,n,s}]}})

({{Databin["id",time]}})

({{Databin["id",date]}})

({{Databin["id",{(Subscript[date, 1]),(Subscript[date, 2])}]}})

({{Databin["id",range,{"(Subscript[key, 1])","(Subscript[key, 2])",…}]}})

({{DatabinAdd[bin,data]}})

({{DatabinRemove[bin,i]}})

({{DatabinRemove[bin,uuid]}})

({{DatabinRemove[bin,{i,j}]}})

({{Databins[]}})

({{DatabinUpload[bin,{(Subscript[entry, 1]),(Subscript[entry, 2]),…}]}})

({{DatabinUpload[bin,EventSeries[…]]}})

({{DataDistribution[ddist,…]}})

({{Dataset[data]}})

({{Date[]}})

({{DateBounds[{(Subscript[date, 1]),(Subscript[date, 2]),…}]}})

({{DateBounds[tseries]}})

({{DateBounds[bin]}})

({{Dated[obj,year]}})

({{Dated[obj,date]}})

({{Dated[obj,All]}})

({{DatedUnit[unit,date]}})

({{DateObjectQ[expr]}})

({{DateOverlapsQ[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DatePattern[{"(Subscript[e, 1])","(Subscript[e, 2])",…}]}})

({{DatePattern[{"(Subscript[e, 1])","(Subscript[e, 2])",…},sep]}})

({{DateValue["elem"]}})

({{DateValue[{"(Subscript[elem, 1])","(Subscript[elem, 2])",…}]}})

({{DateValue[date,elem]}})

({{DateValue[date,elem,form]}})

({{DateWithinQ[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DaubechiesWavelet[]}})

({{DaubechiesWavelet[n]}})

({{DawsonF[z]}})

({{DayHemisphere[]}})

({{DayHemisphere[datespec]}})

({{DayNightTerminator[]}})

({{DayNightTerminator[datespec]}})

({{DeBruijnSequence[list,n]}})

({{DeBruijnSequence[k,n]}})

({{DeBruijnSequence["string",n]}})

({{Decapitalize[string]}})

({{DeclarePackage["context`",{"(Subscript[name, 1])","(Subscript[name, 2])",…}]}})

({{Decrypt["password",enc]}})

({{Decrypt[keyspec,enc]}})

({{Decrypt[key,bytes]}})

({{DedekindEta[τ]}})

({{DeepSpaceProbeData[entity,property]}})

({{DeepSpaceProbeData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{DeepSpaceProbeData[entity,property,annotation]}})

({{Default[f]}})

({{Default[f,i]}})

({{Default[f,i,n]}})

({{Defer[expr]}})

({{DefineOutputStreamMethod["name",{"(Subscript[fname, 1])"->(Subscript[function, 1]),"(Subscript[fname, 2])"->(Subscript[function, 2]),… }]}})

({{Definition[symbol]}})

({{DegreeCentrality[g]}})

({{DegreeCentrality[g,"In"]}})

({{DegreeCentrality[g,"Out"]}})

({{DegreeCentrality[{v->w,…},…]}})

({{Del[x]}})

({{Delete[expr,n]}})

({{Delete[expr,{i,j,…}]}})

({{Delete[expr,{{(Subscript[i, 1]),(Subscript[j, 1]),…},{(Subscript[i, 2]),(Subscript[j, 2]),…},…}]}})

({{Delete[pos]}})

({{DeleteCloudExpression["name\!\(\*StyleBox["\"", "TI"]\)]}})

({{DeleteCloudExpression[obj]}})

({{DeleteDuplicates[list]}})

({{DeleteDuplicates[list,test]}})

({{DeleteDuplicatesBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{DeleteDuplicatesBy[f]}})

({{DeleteFile["file"]}})

({{DeleteFile[{"(Subscript[file, 1])","(Subscript[file, 2])",…}]}})

({{DeleteMissing[list]}})

({{DeleteMissing[assoc]}})

({{DeleteMissing[expr,n]}})

({{DeleteMissing[expr,n,d]}})

({{DeleteObject[obj]}})

({{DeleteObject[{(Subscript[obj, 1]),(Subscript[obj, 2]),…}]}})

({{DeleteSearchIndex[obj]}})

({{DeleteSearchIndex["name"]}})

({{DeleteStopwords[list]}})

({{DeleteStopwords["string"]}})

({{DeleteStopwords[{"(Subscript[string, 1])","(Subscript[string, 2])",…}]}})

({{DelimitedSequence[form]}})

({{DelimitedSequence[form,sep]}})

({{DelimitedSequence[form,{left,sep,right}]}})

({{Deploy[expr]}})

({{DepthFirstScan[g,s,{"(Subscript[event, 1])"->(Subscript[f, 1]),"(Subscript[event, 2])"->(Subscript[f, 2]),…}]}})

({{DepthFirstScan[g,{"(Subscript[event, 1])"->(Subscript[f, 1]),"(Subscript[event, 2])"->(Subscript[f, 2]),…}]}})

({{DepthFirstScan[{v->w,…},…]}})

({{DeviceClose[device]}})

({{DeviceConfigure[device,config]}})

({{DeviceExecute[device,"command"]}})

({{DeviceExecute[device,"command",params]}})

({{DeviceExecuteAsynchronous[device,"command",fun]}})

({{DeviceExecuteAsynchronous[device,"command",params,fun]}})

({{DeviceObject[…]}})

({{DeviceOpen["devclass"]}})

({{DeviceOpen["devclass",spec]}})

({{DeviceOpen[device]}})

({{DeviceRead[devobj]}})

({{DeviceRead["devclass"]}})

({{DeviceRead[device,param]}})

({{DeviceRead[device,{(Subscript[param, 1]),(Subscript[param, 2]),…}]}})

({{DeviceReadBuffer[device]}})

({{DeviceReadBuffer[device,n]}})

({{DeviceReadBuffer[device,crit]}})

({{DeviceReadBuffer[device,crit,param]}})

({{DeviceReadBuffer[device,crit,{(Subscript[param, 1]),(Subscript[param, 2]),…}]}})

({{DeviceReadLatest[device]}})

({{DeviceReadLatest[device,n]}})

({{DeviceReadLatest[device,n,param]}})

({{DeviceReadLatest[device,n,{(Subscript[param, 1]),(Subscript[param, 2]),…}]}})

({{DeviceReadList[device,n]}})

({{DeviceReadList[device,n,param]}})

({{DeviceReadList[device,n,{(Subscript[param, 1]),(Subscript[param, 2]),…}]}})

({{DeviceReadTimeSeries[device,{t,dt}]}})

({{DeviceReadTimeSeries[device,{t,dt},param]}})

({{DeviceReadTimeSeries[device,{t,dt},{(Subscript[param, 1]),(Subscript[param, 2]),…}]}})

({{DeviceStreams[device]}})

({{DeviceStreams[device,patt]}})

({{DeviceStreams[device,{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{DeviceWrite[device,val]}})

({{DeviceWrite[device,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{DeviceWrite[device,param->val]}})

({{DeviceWrite[device,{(Subscript[param, 1])->(Subscript[val, 1]),(Subscript[param, 2])->(Subscript[val, 2]),…}]}})

({{DeviceWriteBuffer[device,vals]}})

({{DeviceWriteBuffer[device,param->vals]}})

({{DGaussianWavelet[]}})

({{DGaussianWavelet[n]}})

({{Diagonal[m]}})

({{Diagonal[m,k]}})

({{DiagonalMatrix[list]}})

({{DiagonalMatrix[list,k]}})

({{DiagonalMatrix[list,k,n]}})

({{DialogReturn[expr]}})

({{DialogReturn[]}})

({{Diamond[x,y,…]}})

({{DiamondMatrix[r]}})

({{DiamondMatrix[r,w]}})

({{DiamondMatrix[{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{DiceDissimilarity[x,y]}})

({{DifferenceRoot[lde]}})

({{Differences[list]}})

({{Differences[list,n]}})

({{Differences[list,n,s]}})

({{Differences[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{DifferentialD[x]}})

({{DifferentialRoot[lde]}})

({{DigitCount[n,b,d]}})

({{DigitCount[n,b]}})

({{DigitCount[n]}})

({{DigitQ[string]}})

({{DihedralGroup[n]}})

({{DiracComb[x]}})

({{DiracComb[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{DiracDelta[x]}})

({{DiracDelta[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{DirectedEdge[u,v]}})

({{DirectedGraphQ[g]}})

({{DirectedInfinity[]}})

({{DirectedInfinity[z]}})

({{Directive[(Subscript[g, 1]),(Subscript[g, 2]),…]}})

({{Directory[]}})

({{DirectoryQ["name"]}})

({{DirectoryStack[]}})

({{DirichletBeta[s]}})

({{DirichletCharacter[k,j,n]}})

({{DirichletCondition[beqn,pred]}})

({{DirichletConvolve[f,g,n,m]}})

({{DirichletDistribution[{(Subscript[α, 1]),…,(Subscript[α, k+1])}]}})

({{DirichletEta[s]}})

({{DirichletL[k,j,s]}})

({{DirichletLambda[s]}})

({{DirichletWindow[x]}})

({{DisableFormatting[expr]}})

({{DiscreteChirpZTransform[list]}})

({{DiscreteChirpZTransform[list,n]}})

({{DiscreteChirpZTransform[list,n,w]}})

({{DiscreteChirpZTransform[list,n,w,a]}})

({{DiscreteChirpZTransform[list,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[w, 1]),(Subscript[w, 2]),…},{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{DiscreteDelta[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{DiscreteIndicator[x,(Subscript[x, 1]),{(Subscript[u, 1]),(Subscript[u, 2]),…}]}})

({{DiscreteLyapunovSolve[a,c]}})

({{DiscreteLyapunovSolve[a,b,c]}})

({{DiscreteLyapunovSolve[{a,d},c]}})

({{DiscreteLyapunovSolve[{a,d},{b,e},c]}})

({{DiscreteMarkovProcess[(Subscript[i, 0]),m]}})

({{DiscreteMarkovProcess[(Subscript[p, 0]),m]}})

({{DiscreteMarkovProcess[…,g]}})

({{DiscreteTimeModelQ[lsys]}})

({{DiscreteUniformDistribution[{(Subscript[i, min]),(Subscript[i, max])}]}})

({{DiscreteUniformDistribution[{{(Subscript[i, min]),(Subscript[i, max])},{(Subscript[j, min]),(Subscript[j, max])},…}]}})

({{DisjointQ[(Subscript[list, 1]),(Subscript[list, 2])]}})

({{Disjunction[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{Disk[{x,y},r]}})

({{Disk[{x,y}]}})

({{Disk[{x,y},{(Subscript[r, x]),(Subscript[r, y])}]}})

({{Disk[{x,y},…,{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{DiskSegment[{x,y},r,{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{DiskSegment[{x,y},{(Subscript[r, x]),(Subscript[r, y])},{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{Dispatch[{(Subscript[lhs, 1])->(Subscript[rhs, 1]),(Subscript[lhs, 2])->(Subscript[rhs, 2]),…}]}})

({{DisplayEndPacket[]}})

({{DisplayForm[expr]}})

({{DisplayPacket[]}})

({{Distribute[f[(Subscript[x, 1]),(Subscript[x, 2]),…]]}})

({{Distribute[expr,g]}})

({{Distribute[expr,g,f]}})

({{Distributed[x,dist]}})

({{Distributed[{(Subscript[x, 1]),(Subscript[x, 2]),…},dist]}})

({{DistributionParameterAssumptions[dist]}})

({{DistributionParameterQ[dist]}})

({{Divide[x,y]}})

({{Divisible[n,m]}})

({{DivisorSum[n,form]}})

({{DivisorSum[n,form,cond]}})

({{DMSList[θ]}})

({{DMSList["dms"]}})

({{DMSList["latlong"]}})

({{DMSString[θ]}})

({{DMSString[{ϕ,λ}]}})

({{DMSString[{d,m,s}]}})

({{DocumentGeneratorInformation[cloudobj]}})

({{DocumentGeneratorInformation[cloudobj,property]}})

({{DocumentGenerators[]}})

({{Dot[a,b,c]}})

({{DotEqual[x,y,…]}})

({{DoubleBracketingBar[x,y,…]}})

({{DoubleDownArrow[x,y,…]}})

({{DoubleLeftArrow[x,y,…]}})

({{DoubleLeftRightArrow[x,y,…]}})

({{DoubleLeftTee[x,y]}})

({{DoubleLongLeftArrow[x,y,…]}})

({{DoubleLongLeftRightArrow[x,y,…]}})

({{DoubleLongRightArrow[x,y,…]}})

({{DoubleRightArrow[x,y,…]}})

({{DoubleRightTee[x,y]}})

({{DoubleUpArrow[x,y,…]}})

({{DoubleUpDownArrow[x,y,…]}})

({{DoubleVerticalBar[x,y,…]}})

({{DownArrow[x,y,…]}})

({{DownArrowBar[x,y,…]}})

({{DownArrowUpArrow[x,y,…]}})

({{DownLeftRightVector[x,y,…]}})

({{DownLeftTeeVector[x,y,…]}})

({{DownLeftVector[x,y,…]}})

({{DownLeftVectorBar[x,y,…]}})

({{DownRightTeeVector[x,y,…]}})

({{DownRightVector[x,y,…]}})

({{DownRightVectorBar[x,y,…]}})

({{Downsample[array,n]}})

({{Downsample[array,n,offset]}})

({{Downsample[image,…]}})

({{DownTee[x,y]}})

({{DownTeeArrow[x,y,…]}})

({{Drop[list,n]}})

({{Drop[list,-n]}})

({{Drop[list,{n}]}})

({{Drop[list,{m,n}]}})

({{Drop[list,{m,n,s}]}})

({{Drop[list,(Subscript[seq, 1]),(Subscript[seq, 2]),…]}})

({{DualSystemsModel[ssm]}})

({{DumpGet[ "filename"]}})

({{DuplicateFreeQ[list]}})

({{DuplicateFreeQ[list,test]}})

({{Duration[expr]}})

({{DynamicSetting[e]}})

({{DynamicSetting[f,e]}})

({{EarthImpactData[entity,property]}})

({{EarthImpactData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{EarthImpactData[entity,property,annotation]}})

({{EccentricityCentrality[g]}})

({{EccentricityCentrality[{v->w,…}]}})

({{Echo[expr]}})

({{Echo[expr,label]}})

({{Echo[expr,label,f]}})

({{EdgeAdd[g,e]}})

({{EdgeAdd[g,{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{EdgeAdd[{v->w,…},…]}})

({{EdgeBetweennessCentrality[g]}})

({{EdgeBetweennessCentrality[{v->w,…}]}})

({{EdgeContract[g,e]}})

({{EdgeContract[g,{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{EdgeContract[{v->w,…},…]}})

({{EdgeCount[g]}})

({{EdgeCount[g,patt]}})

({{EdgeCount[{v->w,…},…]}})

({{EdgeCoverQ[g,elist]}})

({{EdgeCycleMatrix[g]}})

({{EdgeCycleMatrix[{v->w,…}]}})

({{EdgeDelete[g,e]}})

({{EdgeDelete[g,{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{EdgeDelete[g,patt]}})

({{EdgeDelete[{v->w,…},…]}})

({{EdgeForm[g]}})

({{EdgeIndex[g,e]}})

({{EdgeIndex[{v->w,…},…]}})

({{EdgeList[g]}})

({{EdgeList[g,patt]}})

({{EdgeList[{v->w,…},…]}})

({{EdgeQ[g,e]}})

({{EdgeRules[g]}})

({{EdgeRules[{v->w,…}]}})

({{Edit[expr,…]}})

({{EditDefinition[syms,…]}})

({{EditIn[n,…]}})

({{EditIn[]}})

({{Element[x,dom]}})

({{Element[x,reg]}})

({{Element[(Subscript[x, 1])|(Subscript[x, 2])|…,dom]}})

({{Element[patt,dom]}})

({{ElementData["name","property"]}})

({{ElementData[n,"property"]}})

({{Ellipsoid[p,{(Subscript[r, 1]),…}]}})

({{Ellipsoid[p,Σ]}})

({{EllipticE[m]}})

({{EllipticE[ϕ,m]}})

({{EllipticExp[u,{a,b}]}})

({{EllipticExpPrime[u,{a,b}]}})

({{EllipticF[ϕ,m]}})

({{EllipticFilterModel[n]}})

({{EllipticFilterModel[{n,(Subscript[ω, c])}]}})

({{EllipticFilterModel[{"type",spec}]}})

({{EllipticFilterModel[{"type",spec},var]}})

({{EllipticK[m]}})

({{EllipticLog[{x,y},{a,b}]}})

({{EllipticNomeQ[m]}})

({{EllipticPi[n,m]}})

({{EllipticPi[n,ϕ,m]}})

({{EllipticReducedHalfPeriods[{u, v}]}})

({{EllipticTheta[a,u,q]}})

({{EllipticTheta[a,q]}})

({{EllipticThetaPrime[a,u,q]}})

({{EllipticThetaPrime[a,q]}})

({{EmbeddedHTML["string"]}})

({{EmbeddedHTML[CloudObject[…]]}})

({{EmbeddedService[service]}})

({{EmitSound[snd]}})

({{EmitSound[{(Subscript[snd, 1]),(Subscript[snd, 2]),…}]}})

({{EmpiricalDistribution[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{EmpiricalDistribution[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…}]}})

({{EmpiricalDistribution[{(Subscript[w, 1]),(Subscript[w, 2]),…}->{(Subscript[d, 1]),(Subscript[d, 2]),…}]}})

({{EmptyGraphQ[g]}})

({{EmptyRegion[n]}})

({{Encrypt["password",expr]}})

({{Encrypt[keyspec,expr]}})

({{EncryptedObject[…]}})

({{End[]}})

({{EndAdd[ ]}})

({{EndDialogPacket[integer]}})

({{EndPackage[]}})

({{EnterExpressionPacket[expr]}})

({{EnterTextPacket[string]}})

({{Entity["type",name]}})

({{EntityClass["type",name]}})

({{EntityClass["type",{(Subscript[property, 1])->(Subscript[value, 1]),(Subscript[property, 2])->(Subscript[value, 2]),…}]}})

({{EntityClassList["type"]}})

({{EntityCopies[entity,n]}})

({{EntityGroup[{(Subscript[entity, 1]),(Subscript[entity, 2]),…}]}})

({{EntityInstance[entity,qual->val]}})

({{EntityInstance[entity,{(Subscript[qual, 1])->(Subscript[val, 1]),(Subscript[qual, 2])->(Subscript[val, 2]),…}]}})

({{EntityInstance[entity,quantity]}})

({{EntityList[class]}})

({{EntityList["type"]}})

({{EntityProperties[type]}})

({{EntityRegister[estore]}})

({{EntityStores[]}})

({{EntityTypeName[entity]}})

({{EntityTypeName[{(Subscript[entity, 1]),…,(Subscript[entity, n])}]}})

({{EntityUnregister["type"]}})

({{EntityUnregister[store]}})

({{EntityValue[entity,property]}})

({{EntityValue[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},{(Subscript[property, 1]),(Subscript[property, 2]),…}]}})

({{EntityValue[entity,property,annotation]}})

({{EntropyFilter[data,r]}})

({{EntropyFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{Environment["var"]}})

({{EqualTilde[x,y,…]}})

({{EqualTo[y]}})

({{Equilibrium[x,y,…]}})

({{Equivalent[(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{Erf[z]}})

({{Erf[(Subscript[z, 0]),(Subscript[z, 1])]}})

({{Erfc[z]}})

({{Erfi[z]}})

({{ErlangB[c,a]}})

({{ErlangC[c,a]}})

({{ErlangDistribution[k,λ]}})

({{ErrorBox[boxes]}})

({{EuclideanDistance[u,v]}})

({{EulerAngles[r]}})

({{EulerAngles[r,{a,b,c}]}})

({{EulerE[n]}})

({{EulerE[n,x]}})

({{EulerianGraphQ[g]}})

({{EulerMatrix[{α,β,γ}]}})

({{EulerMatrix[{α,β,γ},{a,b,c}]}})

({{EulerPhi[n]}})

({{Evaluate[expr]}})

({{EvaluatePacket[expr]}})

({{EvaluateScheduledTask[expr]}})

({{EvaluationBox[]}})

({{EvaluationCell[]}})

({{EvaluationData[expr]}})

({{EvaluationNotebook[]}})

({{EvaluationObject[n,expr,…]}})

({{EvenQ[expr]}})

({{EventData[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{EventData[{(Subscript[e, 1]),(Subscript[e, 2]),…},{(Subscript[ci, 1]),(Subscript[ci, 2]),…}]}})

({{EventData[{(Subscript[e, 1]),(Subscript[e, 2]),…},{(Subscript[cc, 1]),(Subscript[cc, 2]),…}]}})

({{EventData[{(Subscript[e, 1]),(Subscript[e, 2]),…},cspec,{(Subscript[tr, 1]),(Subscript[tr, 2]),…}]}})

({{ExactBlackmanWindow[x]}})

({{ExactNumberQ[expr]}})

({{ExampleData["type"]}})

({{ExampleData[{"type","name"}]}})

({{ExampleData[{"type","name"},"elem"]}})

({{Except[c]}})

({{Except[c,p]}})

({{Exists[x,expr]}})

({{Exists[x,cond,expr]}})

({{Exists[{(Subscript[x, 1]),(Subscript[x, 2]),…},expr]}})

({{Exit[]}})

({{ExoplanetData[entity,property]}})

({{ExoplanetData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{ExoplanetData[entity,property,annotation]}})

({{Exp[z]}})

({{ExpandFileName["name"]}})

({{ExpGammaDistribution[κ,θ,μ]}})

({{ExpIntegralE[n,z]}})

({{ExpIntegralEi[z]}})

({{ExponentialDistribution[λ]}})

({{ExponentialMovingAverage[list,α]}})

({{ExponentialPowerDistribution[κ,μ,σ]}})

({{ExponentialPowerDistribution[κ]}})

({{Export["file.ext",expr]}})

({{Export[file,expr,"format"]}})

({{Export[file,exprs,elems]}})

({{ExportByteArray[expr,"format"]}})

({{ExportByteArray[exprs,elems]}})

({{ExportForm[expr,"fmt"]}})

({{ExportForm[expr,{"fmt","type"}]}})

({{ExportString[expr,"format"]}})

({{ExportString[rules,{"format","Rules"}]}})

({{ExportString[exprs,elems]}})

({{ExpToTrig[expr]}})

({{ExtendedGCD[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{ExternalBundle[{"(Subscript[name, 1])"->(Subscript[obj, 1]),"(Subscript[name, 2])"->(Subscript[obj, 2]),…}]}})

({{ExternalBundle[{(Subscript[name, 11])->{(Subscript[name, 1])->…,…},…}]}})

({{ExternalEvaluate["sys","cmd"]}})

({{ExternalEvaluate[{"sys",opts},"cmd"]}})

({{ExternalEvaluate[assoc,"cmd"]}})

({{ExternalEvaluate[session,"cmd"]}})

({{ExternalEvaluate[sys->"type",…]}})

({{ExternalEvaluate[spec,obj]}})

({{ExternalEvaluate[spec,assoc]}})

({{ExternalEvaluate[spec,{(Subscript[cmd, 1]),(Subscript[cmd, 2]),…}]}})

({{ExternalEvaluate[spec]}})

({{ExternalSessionObject[…]}})

({{ExternalSessions[]}})

({{ExternalSessions[sys]}})

({{Extract[expr,pos]}})

({{Extract[expr,{(Subscript[pos, 1]),(Subscript[pos, 2]),…}]}})

({{Extract[expr,pos,h]}})

({{Extract[pos]}})

({{ExtremeValueDistribution[α,β]}})

({{ExtremeValueDistribution[]}})

({{FaceForm[g]}})

({{FaceForm[g,gback]}})

({{FactorialMoment[list,r]}})

({{FactorialMoment[dist,r]}})

({{FactorialMoment[r]}})

({{FactorialMomentGeneratingFunction[dist,t]}})

({{FactorialMomentGeneratingFunction[dist,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{FactorialPower[x,n]}})

({{FactorialPower[x,n,h]}})

({{Failure["tag",assoc]}})

({{FailureDistribution[bexpr,{{(Subscript[x, 1]),(Subscript[dist, 1])},{(Subscript[x, 2]),(Subscript[dist, 2])},…}]}})

({{FailureQ[expr]}})

({{FareySequence[n]}})

({{FareySequence[n,k]}})

({{FARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},v]}})

({{FARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{FARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[d, 1]),…,(Subscript[d, n])},{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{Fibonacci[n]}})

({{Fibonacci[n,x]}})

({{Fibonorial[n]}})

({{File["path"]}})

({{FileByteCount["file"]}})

({{FileDate["file"]}})

({{FileDate["file","type"]}})

({{FileExistsQ["name"]}})

({{FileFormat["name"]}})

({{FileHash["file"]}})

({{FileHash["file","type"]}})

({{FilePrint["file"]}})

({{FilePrint["file",n]}})

({{FilePrint["file",-n]}})

({{FilePrint["file",m;;n]}})

({{FilePrint["file",m;;n;;s]}})

({{FileSize[file]}})

({{FileType["file"]}})

({{FilterRules[rules,patt]}})

({{FilterRules[rules,{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{FinancialData["name"]}})

({{FinancialData["name",start]}})

({{FinancialData["name",{start,end}]}})

({{FinancialData["name",{start,end,period}]}})

({{FinancialData["name","prop"]}})

({{FinancialData["name","prop",{start,end,…}]}})

({{FinancialIndicator["ind",(Subscript[par, 1]),(Subscript[par, 2]),…]}})

({{FindClique[g]}})

({{FindClique[g,n]}})

({{FindClique[g,{n}]}})

({{FindClique[g,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{FindClique[g,nspec,s]}})

({{FindClique[{g,v},…]}})

({{FindClique[{v->w,…},…]}})

({{FindCookies[]}})

({{FindCookies[domain]}})

({{FindCookies[assoc]}})

({{FindCurvePath[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{FindCycle[g]}})

({{FindCycle[g,k]}})

({{FindCycle[g,{k}]}})

({{FindCycle[g,{(Subscript[k, min]),(Subscript[k, max])}]}})

({{FindCycle[g,kspec,s]}})

({{FindCycle[{g,v},…]}})

({{FindCycle[{v->w,…},…]}})

({{FindEdgeCover[g]}})

({{FindEdgeCover[{v->w,…}]}})

({{FindEdgeIndependentPaths[g,s,t,k]}})

({{FindEdgeIndependentPaths[{v->w,…},…]}})

({{FindEulerianCycle[g]}})

({{FindEulerianCycle[g,k]}})

({{FindEulerianCycle[{v->w,…},…]}})

({{FindExternalEvaluators[]}})

({{FindExternalEvaluators["sys"]}})

({{FindFaces[image]}})

({{FindFaces[image,{min,max}]}})

({{FindFile[name]}})

({{FindGeoLocation[]}})

({{FindGeoLocation["ip"]}})

({{FindGeoLocation["address"]}})

({{FindGeoLocation[entity]}})

({{FindGraphPartition[g]}})

({{FindGraphPartition[g,k]}})

({{FindGraphPartition[g,{(Subscript[n, 1]),…,(Subscript[n, k])}]}})

({{FindGraphPartition[g,{(Subscript[α, 1]),…,(Subscript[α, k])}]}})

({{FindGraphPartition[{v->w,…},…]}})

({{FindHiddenMarkovStates[data,hmm]}})

({{FindHiddenMarkovStates[data,hmm,crit]}})

({{FindIndependentVertexSet[g]}})

({{FindIndependentVertexSet[g,n]}})

({{FindIndependentVertexSet[g,{n}]}})

({{FindIndependentVertexSet[g,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{FindIndependentVertexSet[g,nspec,s]}})

({{FindIndependentVertexSet[{g,v},…]}})

({{FindIndependentVertexSet[{v->w,…},…]}})

({{FindKClan[g,k]}})

({{FindKClan[g,k,n]}})

({{FindKClan[g,k,{n}]}})

({{FindKClan[g,k,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{FindKClan[g,k,nspec,s]}})

({{FindKClan[{g,v},k,…]}})

({{FindKClan[{v->w,…},…]}})

({{FindKClique[g,k]}})

({{FindKClique[g,k,n]}})

({{FindKClique[g,k,{n}]}})

({{FindKClique[g,k,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{FindKClique[g,k,nspec,s]}})

({{FindKClique[{g,v},k,…]}})

({{FindKClique[{v->w,…},…]}})

({{FindKClub[g,k]}})

({{FindKPlex[g,k]}})

({{FindKPlex[g,k,n]}})

({{FindKPlex[g,k,{n}]}})

({{FindKPlex[g,k,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{FindKPlex[g,k,nspec,s]}})

({{FindKPlex[{g,v},k,…]}})

({{FindKPlex[{v->w,…},…]}})

({{FindLibrary[lib]}})

({{FindLinearRecurrence[list]}})

({{FindLinearRecurrence[list,d]}})

({{FindPath[g,s,t]}})

({{FindPath[g,s,t,k]}})

({{FindPath[g,s,t,{k}]}})

({{FindPath[g,s,t,{(Subscript[k, min]),(Subscript[k, max])}]}})

({{FindPath[g,s,t,kspec,n]}})

({{FindPath[{v->w,…},…]}})

({{FindPermutation[expr]}})

({{FindPermutation[(Subscript[expr, 1]),(Subscript[expr, 2])]}})

({{FindPostmanTour[g]}})

({{FindPostmanTour[g,k]}})

({{FindPostmanTour[{v->w,…},…]}})

({{FindVertexCover[g]}})

({{FindVertexCover[{v->w,…}]}})

({{FindVertexCut[g]}})

({{FindVertexCut[g,s,t]}})

({{FindVertexCut[{v->w,…},…]}})

({{FindVertexIndependentPaths[g,s,t,k]}})

({{FindVertexIndependentPaths[{v->w,…},…]}})

({{FinishDynamic[]}})

({{FiniteAbelianGroupCount[n]}})

({{FiniteGroupCount[n]}})

({{FiniteGroupData[name,"property"]}})

({{FiniteGroupData["class"]}})

({{First[expr]}})

({{First[expr,def]}})

({{FirstPassageTimeDistribution[mproc,f]}})

({{FischerGroupFi22[]}})

({{FischerGroupFi23[]}})

({{FischerGroupFi24Prime[]}})

({{FisherHypergeometricDistribution[n,(Subscript[n, succ]),(Subscript[n, tot]),w]}})

({{FisherZDistribution[n,m]}})

({{Fit[data,funs,vars]}})

({{FittedModel[…]}})

({{FixedOrder[(Subscript[p, 1]),(Subscript[p, 2]),…]}})

({{Flatten[list]}})

({{Flatten[list,n]}})

({{Flatten[list,n,h]}})

({{Flatten[list,{{(Subscript[s, 11]),(Subscript[s, 12]),…},{(Subscript[s, 21]),(Subscript[s, 22]),…},…}]}})

({{FlattenAt[list,n]}})

({{FlattenAt[expr,{i,j,…}]}})

({{FlattenAt[expr,{{(Subscript[i, 1]),(Subscript[j, 1]),…},{(Subscript[i, 2]),(Subscript[j, 2]),…},…}]}})

({{FlatTopWindow[x]}})

({{Floor[x]}})

({{Floor[x,a]}})

({{FlowPolynomial[g,k]}})

({{FlowPolynomial[{v->w,…},…]}})

({{Fold[f,x,list]}})

({{Fold[f,list]}})

({{Fold[f,First[list],Rest[list]]}})

({{Fold[f]}})

({{FoldList[f,x,{a,b,…}]}})

({{FoldList[f,{a,b,c,…}]}})

({{FoldList[f]}})

({{FoldPair[f,(Subscript[y, 0]),list]}})

({{FoldPair[f,(Subscript[y, 0]),list,g]}})

({{FoldPair[f,{(Subscript[a, 0]),(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{FoldPair[f,(Subscript[a, 0]),{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{FoldPairList[f,(Subscript[y, 0]),{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{FoldPairList[f,(Subscript[y, 0]),list,g]}})

({{FoldPairList[f,{(Subscript[a, 0]),(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{FoldPairList[f,(Subscript[a, 0]),{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{ForAll[x,expr]}})

({{ForAll[x,cond,expr]}})

({{ForAll[{(Subscript[x, 1]),(Subscript[x, 2]),…},expr]}})

({{Format[expr]}})

({{Format[expr]}})

({{Format[expr,form]}})

({{FormControl[assoc,struct]}})

({{FormControl[Dynamic[x],struct]}})

({{FormulaData[name]}})

({{FormulaData[name,{(Subscript[var, 1])->(Subscript[quantity, 1]),(Subscript[var, 2])->(Subscript[quantity, 2]),…}]}})

({{FormulaData[name,"property"]}})

({{FortranForm[expr]}})

({{FourierDCT[list]}})

({{FourierDCT[list,m]}})

({{FourierDCTFilter[image,t]}})

({{FourierDST[list]}})

({{FourierDST[list,m]}})

({{FractionalBrownianMotionProcess[μ,σ,h]}})

({{FractionalBrownianMotionProcess[h]}})

({{FractionalGaussianNoiseProcess[μ,σ,h]}})

({{FractionalGaussianNoiseProcess[h]}})

({{FractionalPart[x]}})

({{FRatioDistribution[n,m]}})

({{FrechetDistribution[α,β]}})

({{FrechetDistribution[α,β,μ]}})

({{FresnelC[z]}})

({{FresnelF[z]}})

({{FresnelG[z]}})

({{FresnelS[z]}})

({{FrobeniusNumber[{(Subscript[a, 1]),…,(Subscript[a, n])}]}})

({{FrobeniusSolve[{(Subscript[a, 1]),…,(Subscript[a, n])},b]}})

({{FrobeniusSolve[{(Subscript[a, 1]),…,(Subscript[a, n])},b,m]}})

({{FromCharacterCode[n]}})

({{FromCharacterCode[{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FromCharacterCode[{{(Subscript[n, 11]),(Subscript[n, 12]),…},{(Subscript[n, 21]),…},…}]}})

({{FromCharacterCode[…,"encoding"]}})

({{FromCoefficientRules[list,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{FromContinuedFraction[list]}})

({{FromDate[date]}})

({{FromDigits[list]}})

({{FromDigits[list,b]}})

({{FromDigits[list,MixedRadix[blist]]}})

({{FromDigits["string"]}})

({{FromDigits["string","Roman"]}})

({{FromDMS[{d,m,s}]}})

({{FromDMS["dms"]}})

({{FromDMS["latlon"]}})

({{FromEntity[entity]}})

({{FromLetterNumber[n]}})

({{FromLetterNumber[n,alpha]}})

({{FromPolarCoordinates[{r,θ}]}})

({{FromPolarCoordinates[{r,(Subscript[θ, 1]),…,(Subscript[θ, n-2]),ϕ}]}})

({{FromRomanNumeral["string"]}})

({{FromSphericalCoordinates[{r,θ,ϕ}]}})

({{FrontEndExecute[expr]}})

({{FrontEndToken["cmd"]}})

({{FrontEndToken[nb,"cmd"]}})

({{FrontEndToken[nb,"cmd",param]}})

({{FrontEndTokenExecute["cmd"]}})

({{FullAxes[graphics]}})

({{FullDefinition[symbol]}})

({{FullGraphics[g]}})

({{FullRegion[n]}})

({{Function[body]}})

({{Function[x,body]}})

({{Function[{(Subscript[x, 1]),(Subscript[x, 2]),…},body]}})

({{FunctionPeriod[f,x]}})

({{FunctionPeriod[f,x,dom]}})

({{FunctionPeriod[{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…},…]}})

({{FussellVeselyImportance[rdist,t]}})

({{FussellVeselyImportance[fdist,t]}})

({{GaborWavelet[]}})

({{GaborWavelet[w]}})

({{GalaxyData[entity,property]}})

({{GalaxyData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{GalaxyData[entity,property,annotation]}})

({{Gamma[z]}})

({{Gamma[a,z]}})

({{Gamma[a,(Subscript[z, 0]),(Subscript[z, 1])]}})

({{GammaDistribution[α,β]}})

({{GammaDistribution[α,β,γ,μ]}})

({{GammaRegularized[a,z]}})

({{GARCHProcess[κ,{(Subscript[α, 1]),…,(Subscript[α, q])},{(Subscript[β, 1]),…,(Subscript[β, p])}]}})

({{GARCHProcess[κ,{(Subscript[α, 1]),…,(Subscript[α, q])},{(Subscript[β, 1]),…,(Subscript[β, p])},init]}})

({{Gather[list]}})

({{Gather[list,test]}})

({{GatherBy[list,f]}})

({{GatherBy[list,{(Subscript[f, 1]),(Subscript[f, 2]),…}]}})

({{GaussianOrthogonalMatrixDistribution[σ,n]}})

({{GaussianOrthogonalMatrixDistribution[n]}})

({{GaussianSymplecticMatrixDistribution[σ,n]}})

({{GaussianSymplecticMatrixDistribution[n]}})

({{GaussianUnitaryMatrixDistribution[σ,n]}})

({{GaussianUnitaryMatrixDistribution[n]}})

({{GaussianWindow[x]}})

({{GaussianWindow[x,σ]}})

({{GCD[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{GegenbauerC[n,m,x]}})

({{GegenbauerC[n,x]}})

({{GenerateDocument[nb]}})

({{GenerateDocument[nb,args]}})

({{GenerateDocument[nb,output]}})

({{GenerateDocument[nb,args,output]}})

({{GenerateHTTPResponse[expr]}})

({{GenerateHTTPResponse[expr,req]}})

({{GenomeData["gene"]}})

({{GenomeData["gene","property"]}})

({{GenomeData[{"chr",{(Subscript[n, 1]),(Subscript[n, 2])}}]}})

({{GenomeLookup["seq"]}})

({{GenomeLookup["seq",n]}})

({{GeoAntipode[loc]}})

({{GeoAntipode[g]}})

({{GeoBoundsRegion[{{(Subscript[lat, min]),(Subscript[lat, max])},{(Subscript[lon, min]),(Subscript[lon, max])}}]}})

({{GeoBoundsRegion[g]}})

({{GeoBoundsRegion[g,δ]}})

({{GeoCircle[loc,r]}})

({{GeoCircle[loc,r,{(Subscript[α, 1]),(Subscript[α, 2])}]}})

({{GeodesicClosing[image,ker]}})

({{GeodesicClosing[image,r]}})

({{GeodesicClosing[data,…]}})

({{GeodesicOpening[image,ker]}})

({{GeodesicOpening[image,r]}})

({{GeodesicOpening[data,…]}})

({{GeoDestination[loc,{d,α}]}})

({{GeodesyData["name","property"]}})

({{GeodesyData[{a,b},"property"]}})

({{GeodesyData[obj,{"property",coords}]}})

({{GeoDirection[{(Subscript[lat, 1]),(Subscript[lon, 1])},{(Subscript[lat, 2]),(Subscript[lon, 2])}]}})

({{GeoDirection[(Subscript[loc, 1]),(Subscript[loc, 2])]}})

({{GeoDisk[loc,r,{(Subscript[α, 1]),(Subscript[α, 2])}]}})

({{GeoDisplacement[{dist,α}]}})

({{GeoDisplacement[{dist,α},pathtype]}})

({{GeoDisplacement[(Subscript[loc, 1]),(Subscript[loc, 2]),pathtype]}})

({{GeoGridPosition[{x,y},proj]}})

({{GeoGridPosition[{x,y,h},proj]}})

({{GeoGridPosition[{x,y,h},proj,datum]}})

({{GeoGroup[geoobjects]}})

({{GeoHemisphere[]}})

({{GeoHemisphere[loc]}})

({{GeoHemisphereBoundary[]}})

({{GeoHemisphereBoundary[loc]}})

({{GeologicalPeriodData[entity,property]}})

({{GeologicalPeriodData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{GeologicalPeriodData[entity,property,annotation]}})

({{GeometricBrownianMotionProcess[μ,σ,(Subscript[x, 0])]}})

({{GeometricDistribution[p]}})

({{GeometricMean[list]}})

({{GeometricMeanFilter[data,r]}})

({{GeometricMeanFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{GeoPosition[{lat,lon}]}})

({{GeoPosition[{lat,lon,h}]}})

({{GeoPosition[{lat,lon,h},datum]}})

({{GeoPosition[{{(Subscript[lat, 1]),(Subscript[lon, 1])},{(Subscript[lat, 2]),(Subscript[lon, 2])},…},datum]}})

({{GeoPosition[entity]}})

({{GeoPositionENU[{{(Subscript[e, 1]),(Subscript[n, 1]),(Subscript[u, 1])},{(Subscript[e, 2]),(Subscript[n, 2]),(Subscript[u, 2])},…},p]}})

({{GeoPositionENU[entity,p]}})

({{GeoPositionXYZ[{x,y,z}]}})

({{GeoPositionXYZ[{x,y,z},datum]}})

({{GeoPositionXYZ[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…},datum]}})

({{GeoPositionXYZ[entity]}})

({{GeoProjectionData["projection","property"]}})

({{GeoProjectionData["projection"]}})

({{GeoVariant[obj,qual]}})

({{GeoVisibleRegion[{lat,lon,h}]}})

({{GeoVisibleRegion[pos]}})

({{GeoVisibleRegionBoundary[{lat,lon,h}]}})

({{GeoVisibleRegionBoundary[pos]}})

({{GestureHandler[expr,{"gesture":>{fun,(Subscript[fun, end])},…}]}})

({{GestureHandler[expr,{"gesture":>{(Subscript[fun, start]),fun,(Subscript[fun, end])},…}]}})

({{GetContext["context`"]}})

({{GetEnvironment["var"]}})

({{GetEnvironment[{"(Subscript[var, 1])","(Subscript[var, 2])",…}]}})

({{GetEnvironment[]}})

({{GlobalClusteringCoefficient[g]}})

({{GlobalClusteringCoefficient[{v->w,…}]}})

({{Glow[col]}})

({{Glow[]}})

({{GompertzMakehamDistribution[λ,ξ]}})

({{GompertzMakehamDistribution[λ,ξ,θ,α]}})

({{GoodmanKruskalGamma[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{GoodmanKruskalGamma[m]}})

({{GoodmanKruskalGamma[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{GoodmanKruskalGamma[dist]}})

({{GoodmanKruskalGamma[dist,i,j]}})

({{Goto[tag]}})

({{GrammarToken[form]}})

({{GraphAutomorphismGroup[g]}})

({{GraphAutomorphismGroup[{v->w,…}]}})

({{GraphCenter[g]}})

({{GraphCenter[{v->w,…}]}})

({{GraphData[name]}})

({{GraphData[name,"property"]}})

({{GraphData["class"]}})

({{GraphData[n]}})

({{GraphEmbedding[g]}})

({{GraphEmbedding[g,"emb"]}})

({{GraphEmbedding[g,"emb",dim]}})

({{GraphHub[g]}})

({{GraphHub[g,"In"]}})

({{GraphHub[g,"Out"]}})

({{GraphHub[{v->w,…},…]}})

({{GraphLinkEfficiency[g]}})

({{GraphLinkEfficiency[{v->w,…}]}})

({{GraphQ[g]}})

({{GraphRadius[g]}})

({{GraphRadius[{v->w,…}]}})

({{GrayLevel[level]}})

({{GrayLevel[g,a]}})

({{GreaterEqualLess[x,y,…]}})

({{GreaterEqualThan[y]}})

({{GreaterFullEqual[x,y,…]}})

({{GreaterGreater[x,y,…]}})

({{GreaterLess[x,y,…]}})

({{GreaterSlantEqual[x,y,…]}})

({{GreaterThan[y]}})

({{GreaterTilde[x,y,…]}})

({{GroupBy[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},f]}})

({{GroupBy[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},(Subscript[f, k])->(Subscript[f, v])]}})

({{GroupBy[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},{(Subscript[fs, 1]),(Subscript[fs, 2]),…}]}})

({{GroupBy[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},spec,red]}})

({{GroupBy[spec]}})

({{GroupCentralizer[group,g]}})

({{GroupElementFromWord[group,w]}})

({{GroupElementQ[group,g]}})

({{GroupGenerators[group]}})

({{Groupings[n,k]}})

({{Groupings[{(Subscript[a, 1]),…,(Subscript[a, n])},k]}})

({{Groupings[{{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},…},k]}})

({{Groupings[aspec,f->k]}})

({{Groupings[aspec,{(Subscript[f, 1])->(Subscript[k, 1]),(Subscript[f, 2])->(Subscript[k, 2]),…}]}})

({{Groupings[aspec,{{(Subscript[f, 1])->(Subscript[k, 1]),(Subscript[m, 1])},{(Subscript[f, 2])->(Subscript[k, 2]),(Subscript[m, 2])},…}]}})

({{Groupings[aspec,kspec,h]}})

({{GroupMultiplicationTable[group]}})

({{GroupOrbits[group,{(Subscript[p, 1]),…}]}})

({{GroupOrbits[group,{(Subscript[p, 1]),…},f]}})

({{GroupOrder[group]}})

({{GroupSetwiseStabilizer[group,{(Subscript[p, 1]),…,(Subscript[p, n])}]}})

({{GroupSetwiseStabilizer[group,{(Subscript[p, 1]),…,(Subscript[p, n])},f]}})

({{GroupStabilizer[group,{(Subscript[p, 1]),…,(Subscript[p, n])}]}})

({{GroupStabilizer[group,{(Subscript[p, 1]),…,(Subscript[p, n])},f]}})

({{Gudermannian[z]}})

({{GumbelDistribution[α,β]}})

({{GumbelDistribution[]}})

({{HaarWavelet[]}})

({{HalfLine[{(Subscript[p, 1]),(Subscript[p, 2])}]}})

({{HalfLine[p,v]}})

({{HalfNormalDistribution[θ]}})

({{HalfPlane[{(Subscript[p, 1]),(Subscript[p, 2])},w]}})

({{HalfPlane[p,v,w]}})

({{HalfSpace[n,p]}})

({{HalfSpace[n,c]}})

({{HamiltonianGraphQ[g]}})

({{HammingWindow[x]}})

({{HankelH1[n,z]}})

({{HankelH2[n,z]}})

({{HankelMatrix[n]}})

({{HankelMatrix[{(Subscript[c, 1]),(Subscript[c, 2]),…,(Subscript[c, n])}]}})

({{HankelMatrix[{(Subscript[c, 1]),(Subscript[c, 2]),…,(Subscript[c, m])},{(Subscript[r, 1]),(Subscript[r, 2]),…, (Subscript[r, n])}]}})

({{HannPoissonWindow[x]}})

({{HannPoissonWindow[x,α]}})

({{HannWindow[x]}})

({{HannWindow[x,α]}})

({{HaradaNortonGroupHN[]}})

({{HarmonicMean[list]}})

({{HarmonicMeanFilter[data,r]}})

({{HarmonicMeanFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{HarmonicNumber[n]}})

({{HarmonicNumber[n,r]}})

({{Hash[expr]}})

({{Hash[expr,"type"]}})

({{Hash[expr,"type","format"]}})

({{Haversine[z]}})

({{HazardFunction[dist,x]}})

({{HazardFunction[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{HazardFunction[dist]}})

({{Head[expr]}})

({{HeadCompose[a, b, c, d]}})

({{HeavisideLambda[x]}})

({{HeavisideLambda[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{HeavisidePi[x]}})

({{HeavisidePi[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{HeavisideTheta[x]}})

({{HeavisideTheta[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{HeldGroupHe[]}})

({{HermiteH[n,x]}})

({{HiddenMarkovProcess[(Subscript[i, 0]),m,em]}})

({{HiddenMarkovProcess[…,m,{(Subscript[dist, 1]),…}]}})

({{HiddenMarkovProcess[(Subscript[p, 0]),m,…]}})

({{HigmanSimsGroupHS[]}})

({{HistogramDistribution[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{HistogramDistribution[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…}]}})

({{HistogramDistribution[…,bspec]}})

({{HistogramTransform[image]}})

({{HistogramTransform[image,dist]}})

({{HistogramTransform[image,ref]}})

({{HistogramTransform[{(Subscript[x, 1]),(Subscript[x, 2]),…},…]}})

({{HistogramTransformInterpolation[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{HistogramTransformInterpolation[{(Subscript[x, 1]),(Subscript[x, 2]),…},dist]}})

({{HistogramTransformInterpolation[image,…]}})

({{HistoricalPeriodData[entity,property]}})

({{HistoricalPeriodData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{HistoricalPeriodData[entity,property,annotation]}})

({{HjorthDistribution[m,s,f]}})

({{HodgeDual[tensor]}})

({{HodgeDual[tensor,dim]}})

({{HodgeDual[tensor,dim,slots]}})

({{HoeffdingD[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{HoeffdingD[m]}})

({{HoeffdingD[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{HoeffdingD[dist]}})

({{HoeffdingD[dist,i,j]}})

({{Hold[expr]}})

({{HoldComplete[expr]}})

({{HoldForm[expr]}})

({{HoldPattern[expr]}})

({{HornerForm[poly]}})

({{HornerForm[poly,vars]}})

({{HornerForm[(Subscript[poly, 1])/(Subscript[poly, 2])]}})

({{HornerForm[(Subscript[poly, 1])/(Subscript[poly, 2]),(Subscript[vars, 1]),(Subscript[vars, 2])]}})

({{HostLookup[name]}})

({{HostLookup[address]}})

({{HostLookup[spec,prop]}})

({{HostLookup[spec,All]}})

({{HotellingTSquareDistribution[p,m]}})

({{HoytDistribution[q,ω]}})

({{HTMLSave["file.html"]}})

({{HTMLSave["file.html","source.nb"]}})

({{HTMLSave["file.html",notebook]}})

({{HTTPErrorResponse[code]}})

({{HTTPRedirect[uri]}})

({{HTTPRedirect[uri,metadata]}})

({{HTTPRequestData["prop"]}})

({{HTTPRequestData[]}})

({{Hue[h]}})

({{Hue[h,s,b]}})

({{Hue[h,s,b,a]}})

({{HumpDownHump[x,y,…]}})

({{HumpEqual[x,y,…]}})

({{HurwitzLerchPhi[z,s,a]}})

({{HurwitzZeta[s,a]}})

({{HyperbolicDistribution[α,β,δ,μ]}})

({{HyperbolicDistribution[λ,α,β,δ,μ]}})

({{HyperexponentialDistribution[{(Subscript[α, 1]),…,(Subscript[α, m])},{(Subscript[λ, 1]),…,(Subscript[λ, m])}]}})

({{Hyperfactorial[n]}})

({{Hypergeometric0F1[a,z]}})

({{Hypergeometric0F1Regularized[a,z]}})

({{Hypergeometric1F1[a,b,z]}})

({{Hypergeometric1F1Regularized[a,b,z]}})

({{Hypergeometric2F1[a,b,c,z]}})

({{Hypergeometric2F1Regularized[a,b,c,z]}})

({{HypergeometricDistribution[n,(Subscript[n, succ]),(Subscript[n, tot])]}})

({{HypergeometricPFQ[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},z]}})

({{HypergeometricPFQRegularized[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},z]}})

({{HypergeometricU[a,b,z]}})

({{Hyperplane[n,p]}})

({{Hyperplane[n,c]}})

({{HypoexponentialDistribution[{(Subscript[λ, 1]),…,(Subscript[λ, m])}]}})

({{HypothesisTestData[…]}})

({{Iconize[expr]}})

({{Iconize[expr,"name"]}})

({{Identity[expr]}})

({{IgnoringInactive[patt]}})

({{Im[z]}})

({{Image3DProjection[image]}})

({{Image3DProjection[image,dir]}})

({{Image3DProjection[image,dir,mode]}})

({{Image3DSlices[image]}})

({{Image3DSlices[image,n]}})

({{Image3DSlices[image,{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{Image3DSlices[image,(Subscript[s, m]);;(Subscript[s, n])]}})

({{Image3DSlices[image,…,d]}})

({{ImageAdd[image,x]}})

({{ImageAdd[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageAdd[image,(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{ImageAdjust[image]}})

({{ImageAdjust[image,c]}})

({{ImageAdjust[image,{c,b}]}})

({{ImageAdjust[image,{c,b,γ}]}})

({{ImageAdjust[image,corr,{(Subscript[in, min]),(Subscript[in, max])}]}})

({{ImageAdjust[image,corr,{(Subscript[in, min]),(Subscript[in, max])},{(Subscript[out, min]),(Subscript[out, max])}]}})

({{ImageAspectRatio[image]}})

({{ImageAssemble[{{(Subscript[image, 11]),(Subscript[image, 12]),…},{(Subscript[image, 21]),…},…}]}})

({{ImageChannels[image]}})

({{ImageClip[image]}})

({{ImageClip[image,{min,max}]}})

({{ImageClip[image,{min,max},{(Subscript[v, min]),(Subscript[v, max])}]}})

({{ImageColorSpace[image]}})

({{ImageCompose[image,overlay]}})

({{ImageCompose[image,{overlay,α}]}})

({{ImageCompose[image,overlay,pos]}})

({{ImageCompose[image,overlay,pos,opos]}})

({{ImageCompose[image,overlay,pos,opos,{(Subscript[f, i]),(Subscript[f, o]),mode}]}})

({{ImageDemosaic[image,{"cfa",{row,col}}]}})

({{ImageDifference[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageDimensions[image]}})

({{ImageForestingComponents[image]}})

({{ImageForestingComponents[image,marker]}})

({{ImageForestingComponents[image,marker,r]}})

({{ImageMarker[pos]}})

({{ImageMarker[pos,marker]}})

({{ImageMarker[pos,marker,size]}})

({{ImageMarker[pos,marker,size,opos]}})

({{ImageMarker[pos,marker,size,opos,dir]}})

({{ImageMarker[{(Subscript[pos, 1]),(Subscript[pos, 2]),…},…]}})

({{ImageMultiply[image,x]}})

({{ImageMultiply[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageMultiply[image,(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{ImagePad[image,m]}})

({{ImagePad[image,m,padding]}})

({{ImagePad[image,{{left,right},{bottom,top}},…]}})

({{ImagePad[image,{{left,right},{front,back},{bottom,top}},…]}})

({{ImageQ[image]}})

({{ImageReflect[image]}})

({{ImageReflect[image,side]}})

({{ImageReflect[image,(Subscript[side, 1])->(Subscript[side, 2])]}})

({{ImageScaled[{x,y}]}})

({{ImageScaled[{dx,dy},{(Subscript[x, 0]),(Subscript[y, 0])}]}})

({{ImageSubtract[image,x]}})

({{ImageSubtract[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageSubtract[image,(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{ImageTake[image,n]}})

({{ImageTake[image,-n]}})

({{ImageTake[image,{(Subscript[row, 1]),(Subscript[row, 2])}]}})

({{ImageTake[image,{(Subscript[row, 1]),(Subscript[row, 2])},{(Subscript[col, 1]),(Subscript[col, 2])}]}})

({{ImageTake[image3d,{(Subscript[slice, 1]),(Subscript[slice, 2])},{(Subscript[row, 1]),(Subscript[row, 2])},{(Subscript[col, 1]),(Subscript[col, 2])}]}})

({{ImageType[image]}})

({{ImageValuePositions[image,val]}})

({{ImageValuePositions[image,val,d]}})

({{ImplicitRegion[cond,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{ImplicitRegion[cond,{{(Subscript[x, 1]),(Subscript[a, 1]),(Subscript[b, 1])},…}]}})

({{Import["file"]}})

({{Import["file",elements]}})

({{Import[File["path"],$$]}})

({{Import["http://url",…]}})

({{Import["ftp://url",…]}})

({{ImportByteArray[ba,"format"]}})

({{ImportByteArray[ba,elements]}})

({{ImportByteArray[ba]}})

({{ImportString["data","format"]}})

({{ImportString["data",elements]}})

({{ImportString["data"]}})

({{ImprovementImportance[rdist,t]}})

({{ImprovementImportance[fdist,t]}})

({{In[n]}})

({{Inactive[f]}})

({{IncidenceList[g,v]}})

({{IncidenceList[g,patt]}})

({{IncidenceList[g,patt,d]}})

({{IncidenceList[{v->w,…},…]}})

({{IncidenceMatrix[g]}})

({{IncidenceMatrix[{v->w,…}]}})

({{IndependentEdgeSetQ[g,elist]}})

({{IndependentPhysicalQuantity[string]}})

({{IndependentUnit[string]}})

({{IndependentUnitDimension[dim]}})

({{IndependentVertexSetQ[g,vlist]}})

({{Indexed[expr,i]}})

({{Indexed[expr,{i,j,…}]}})

({{IndexGraph[g]}})

({{IndexGraph[g,r]}})

({{IndexGraph[{v->w,…},…]}})

({{InexactNumberQ[expr]}})

({{InfiniteLine[{(Subscript[p, 1]),(Subscript[p, 2])}]}})

({{InfiniteLine[p,v]}})

({{InfinitePlane[{(Subscript[p, 1]),(Subscript[p, 2]),(Subscript[p, 3])}]}})

({{InfinitePlane[p,{(Subscript[v, 1]),(Subscript[v, 2])}]}})

({{Infix[f[(Subscript[e, 1]),(Subscript[e, 2]),…]]}})

({{Infix[expr,h]}})

({{InhomogeneousPoissonProcess[λ[t],t]}})

({{Inner[f,(Subscript[list, 1]),(Subscript[list, 2]),g]}})

({{InputNamePacket[string]}})

({{InputNotebook[]}})

({{InputPacket[]}})

({{InputStream["name",n]}})

({{InputStringPacket[]}})

({{Insert[list,elem,n]}})

({{Insert[expr,elem,{i,j,…}]}})

({{Insert[expr,elem,{{(Subscript[i, 1]),(Subscript[j, 1]),…},{(Subscript[i, 2]),(Subscript[j, 2]),…},…}]}})

({{Insert[elem,pos]}})

({{InsertLinebreaks["string"]}})

({{InsertLinebreaks["string",n]}})

({{Insphere[{(Subscript[p, 1]),…,(Subscript[p, n+1])}]}})

({{InString[n]}})

({{IntegerDigits[n]}})

({{IntegerDigits[n,b]}})

({{IntegerDigits[n,b,len]}})

({{IntegerDigits[n,MixedRadix[blist]]}})

({{IntegerExponent[n,b]}})

({{IntegerLength[n]}})

({{IntegerLength[n,b]}})

({{IntegerPart[x]}})

({{IntegerPartitions[n]}})

({{IntegerPartitions[n,k]}})

({{IntegerPartitions[n,{k}]}})

({{IntegerPartitions[n,{(Subscript[k, min]),(Subscript[k, max])}]}})

({{IntegerPartitions[n,kspec,{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{IntegerPartitions[n,kspec,sspec,m]}})

({{IntegerQ[expr]}})

({{IntegerReverse[n]}})

({{IntegerReverse[n,b]}})

({{IntegerReverse[n,b,len]}})

({{IntegerString[n]}})

({{IntegerString[n,b]}})

({{IntegerString[n,b,len]}})

({{IntegerString[n,MixedRadix[blist]]}})

({{IntegerString[n,numsys]}})

({{InterpolatingFunction[domain,table]}})

({{InterquartileRange[list]}})

({{InterquartileRange[dist]}})

({{Interrupt[]}})

({{IntersectingQ[(Subscript[list, 1]),(Subscript[list, 2])]}})

({{Interval[{min,max}]}})

({{Interval[{(min_1),(max_1)},{(min_2),(max_2)},…]}})

({{IntervalIntersection[(Subscript[interval, 1]),(Subscript[interval, 2]),…]}})

({{IntervalMemberQ[interval,x]}})

({{IntervalMemberQ[(Subscript[interval, 1]),(Subscript[interval, 2])]}})

({{IntervalUnion[(Subscript[interval, 1]),(Subscript[interval, 2]),…]}})

({{InverseBetaRegularized[s,a,b]}})

({{InverseCDF[dist,q]}})

({{InverseChiSquareDistribution[ν]}})

({{InverseChiSquareDistribution[ν,ξ]}})

({{InverseEllipticNomeQ[q]}})

({{InverseErf[s]}})

({{InverseErfc[s]}})

({{InverseFunction[f]}})

({{InverseFunction[f,n,tot]}})

({{InverseGammaDistribution[α,β]}})

({{InverseGammaDistribution[α,β,γ,μ]}})

({{InverseGammaRegularized[a,s]}})

({{InverseGaussianDistribution[μ,λ,θ]}})

({{InverseGudermannian[z]}})

({{InverseHaversine[z]}})

({{InverseJacobiCD[v,m]}})

({{InverseJacobiCN[v,m]}})

({{InverseJacobiCS[v,m]}})

({{InverseJacobiDC[v,m]}})

({{InverseJacobiDN[v,m]}})

({{InverseJacobiDS[v,m]}})

({{InverseJacobiNC[v,m]}})

({{InverseJacobiND[v,m]}})

({{InverseJacobiNS[v,m]}})

({{InverseJacobiSC[v,m]}})

({{InverseJacobiSD[v,m]}})

({{InverseJacobiSN[v,m]}})

({{InverseLaplaceTransform[expr,s,t]}})

({{InverseLaplaceTransform[expr,{(Subscript[s, 1]),(Subscript[s, 2]),…},{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{InversePermutation[perm]}})

({{InverseSeries[s]}})

({{InverseSeries[s,x]}})

({{InverseSurvivalFunction[dist,q]}})

({{InverseWeierstrassP[p,{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{InverseWishartMatrixDistribution[ν,Σ]}})

({{Invisible[expr]}})

({{IPAddress["address"]}})

({{IslandData[entity,property]}})

({{IslandData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{IslandData[entity,property,annotation]}})

({{IsolatingInterval[a]}})

({{IsolatingInterval[a,dx]}})

({{IsomorphicGraphQ[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{IsotopeData[{Z,A},"property"]}})

({{IsotopeData["name","property"]}})

({{JaccardDissimilarity[u,v]}})

({{JacobiAmplitude[u,m]}})

({{JacobiCD[u,m]}})

({{JacobiCN[u,m]}})

({{JacobiCS[u,m]}})

({{JacobiDC[u,m]}})

({{JacobiDN[u,m]}})

({{JacobiDS[u,m]}})

({{JacobiNC[u,m]}})

({{JacobiND[u,m]}})

({{JacobiNS[u,m]}})

({{JacobiP[n,a,b,x]}})

({{JacobiSC[u,m]}})

({{JacobiSD[u,m]}})

({{JacobiSN[u,m]}})

({{JacobiSymbol[n,m]}})

({{JacobiZeta[ϕ,m]}})

({{JankoGroupJ1[]}})

({{JankoGroupJ2[]}})

({{JankoGroupJ3[]}})

({{JankoGroupJ4[]}})

({{JohnsonDistribution["SB",γ,δ,μ,σ]}})

({{JohnsonDistribution["SL",γ,δ,μ,σ]}})

({{JohnsonDistribution["SU",γ,δ,μ,σ]}})

({{JohnsonDistribution["SN",γ,δ,μ,σ]}})

({{Join[(Subscript[list, 1]),(Subscript[list, 2]),…]}})

({{Join[(Subscript[list, 1]),(Subscript[list, 2]),…,n]}})

({{JoinForm[type]}})

({{JordanDecomposition[m]}})

({{JordanModelDecomposition[ssm]}})

({{JulianDate[]}})

({{JulianDate[date]}})

({{JulianDate["type"]}})

({{JulianDate["type",date]}})

({{KaiserBesselWindow[x]}})

({{KaiserWindow[x]}})

({{KaiserWindow[x,α]}})

({{KalmanFilter[tproc,data]}})

({{KCoreComponents[g,k]}})

({{KCoreComponents[g,k,"In"]}})

({{KCoreComponents[g,k,"Out"]}})

({{KCoreComponents[{v->w,…},…]}})

({{KDistribution[ν,w]}})

({{KEdgeConnectedComponents[g,k]}})

({{KEdgeConnectedComponents[g,k,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{KEdgeConnectedComponents[{v->w,…},…]}})

({{KEdgeConnectedGraphQ[g,k]}})

({{KelvinBei[z]}})

({{KelvinBei[n,z]}})

({{KelvinBer[z]}})

({{KelvinBer[n,z]}})

({{KelvinKei[z]}})

({{KelvinKei[n,z]}})

({{KelvinKer[z]}})

({{KelvinKer[n,z]}})

({{KendallTau[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{KendallTau[m]}})

({{KendallTau[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{KendallTau[dist]}})

({{KendallTau[dist,i,j]}})

({{KernelObject[n,name,…]}})

({{Kernels[]}})

({{Key[key]}})

({{KeyDrop[assoc,{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{KeyDrop[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},keys]}})

({{KeyDrop[keys]}})

({{KeyDropFrom[a,key]}})

({{KeyDropFrom[a,{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{KeyExistsQ[assoc,key]}})

({{KeyExistsQ[key]}})

({{KeyFreeQ[assoc,form]}})

({{KeyFreeQ[form]}})

({{KeyIntersection[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{KeyMap[f,\[LeftAssociation](Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…\[RightAssociation]]}})

({{KeyMap[f]}})

({{KeyMemberQ[assoc,form]}})

({{KeyMemberQ[form]}})

({{Keys[\[LeftAssociation](Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…\[RightAssociation]]}})

({{Keys[{(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…}]}})

({{KeySelect[assoc,crit]}})

({{KeySelect[crit]}})

({{KeySort[assoc]}})

({{KeySortBy[assoc,f]}})

({{KeySortBy[f]}})

({{KeyTake[assoc,{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{KeyTake[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},keys]}})

({{KeyTake[{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{KeyUnion[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{KeyUnion[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},f]}})

({{KeyValueMap[f,<|(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…|>]}})

({{KeyValueMap[f]}})

({{KeyValuePattern[{(Subscript[patt, 1]),…}]}})

({{KillProcess[proc]}})

({{KirchhoffMatrix[g]}})

({{KirchhoffMatrix[{v->w,…}]}})

({{KleinInvariantJ[τ]}})

({{KnapsackSolve[{(Subscript[cost, 1]),(Subscript[cost, 2]),…},maxtotalcost]}})

({{KnapsackSolve[{{(Subscript[payoff, 1]),(Subscript[cost, 1])},{(Subscript[payoff, 2]),(Subscript[cost, 2])},…},maxtotalcost]}})

({{KnapsackSolve[{{(Subscript[payoff, 1]),(Subscript[cost, 1]),(Subscript[maxcount, 1])},…},maxtotalcost]}})

({{KnapsackSolve[items,{maxtotalpayoff,maxtotalcost}]}})

({{KnapsackSolve[items,{maxtotalpayoff,maxtotalcost,maxtotalcount}]}})

({{KnapsackSolve[\[LeftAssociation](Subscript[label, 1])->(Subscript[itemspec, 1]),…\[RightAssociation],maxtotals]}})

({{KnotData[knot,"property"]}})

({{KnotData[knot]}})

({{KnotData["class"]}})

({{KnownUnitQ[expr]}})

({{KroneckerDelta[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{KroneckerProduct[(Subscript[m, 1]),(Subscript[m, 2]),…]}})

({{KroneckerSymbol[n,m]}})

({{KumaraswamyDistribution[α,β]}})

({{Kurtosis[list]}})

({{Kurtosis[dist]}})

({{KuwaharaFilter[data,r]}})

({{KVertexConnectedComponents[g,k]}})

({{KVertexConnectedComponents[g,k,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{KVertexConnectedGraphQ[g,k]}})

({{LABColor[l,a,b]}})

({{LABColor[l,a,b,α]}})

({{Label[tag]}})

({{LaguerreL[n,x]}})

({{LaguerreL[n,a,x]}})

({{LakeData[entity,property]}})

({{LakeData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{LakeData[entity,property,annotation]}})

({{LambdaComponents[g]}})

({{LambdaComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{LambdaComponents[{v->w,…},…]}})

({{LaminaData[entity,property]}})

({{LaminaData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{LaminaData[entity,property,annotation]}})

({{LanczosWindow[x]}})

({{LandauDistribution[μ,σ]}})

({{LandauDistribution[]}})

({{LanguageData[entity,property]}})

({{LanguageData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{LanguageData[entity,property,annotation]}})

({{LanguageIdentify["string"]}})

({{LaplaceDistribution[μ,β]}})

({{LaplaceDistribution[]}})

({{Last[expr]}})

({{Last[expr,def]}})

({{Latitude[pos]}})

({{Latitude[pos,datum]}})

({{LatitudeLongitude[pos]}})

({{LatitudeLongitude[pos,datum]}})

({{LatticeData[lattice,"property"]}})

({{LatticeData[n]}})

({{LatticeReduce[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{LaunchKernels[]}})

({{LaunchKernels[n]}})

({{LaunchKernels[ker]}})

({{LaunchKernels[{(Subscript[ker, 1]),(Subscript[ker, 2]),…}]}})

({{LCHColor[l,c,h]}})

({{LCHColor[l,c,h,α]}})

({{LCM[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{LeafCount[expr]}})

({{LeftArrow[x,y,…]}})

({{LeftArrowBar[x,y,…]}})

({{LeftArrowRightArrow[x,y,…]}})

({{LeftDownTeeVector[x,y,…]}})

({{LeftDownVector[x,y,…]}})

({{LeftDownVectorBar[x,y,…]}})

({{LeftRightArrow[x,y,…]}})

({{LeftRightVector[x,y,…]}})

({{LeftTee[x,y]}})

({{LeftTeeArrow[x,y,…]}})

({{LeftTeeVector[x,y,…]}})

({{LeftTriangle[x,y,…]}})

({{LeftTriangleBar[x,y,…]}})

({{LeftTriangleEqual[x,y,…]}})

({{LeftUpDownVector[x,y,…]}})

({{LeftUpTeeVector[x,y,…]}})

({{LeftUpVector[x,y,…]}})

({{LeftUpVectorBar[x,y,…]}})

({{LeftVector[x,y,…]}})

({{LeftVectorBar[x,y,…]}})

({{Legended[expr,leg]}})

({{Legended[expr,lbl]}})

({{LegendreP[n,x]}})

({{LegendreP[n,m,x]}})

({{LegendreQ[n,z]}})

({{LegendreQ[n,m,z]}})

({{Length[expr]}})

({{LengthWhile[list,crit]}})

({{LessEqualGreater[x,y,…]}})

({{LessEqualThan[y]}})

({{LessFullEqual[x,y,…]}})

({{LessGreater[x,y,…]}})

({{LessLess[x,y,…]}})

({{LessSlantEqual[x,y,…]}})

({{LessThan[y]}})

({{LessTilde[x,y,…]}})

({{LetterNumber["c"]}})

({{LetterNumber["c",alpha]}})

({{LetterNumber["string",…]}})

({{LetterQ[string]}})

({{LeviCivitaTensor[d]}})

({{LevyDistribution[μ,σ]}})

({{LibraryDataType[datatype]}})

({{LibraryDataType[datatype,etype]}})

({{LibraryDataType[datatype,etype,d]}})

({{LibraryFunction[ args]}})

({{LibraryFunctionError[name,code]}})

({{LibraryFunctionInformation[fun]}})

({{LibraryFunctionUnload[fun]}})

({{LibraryLoad[lib]}})

({{LibraryUnload[lib]}})

({{Lighter[color]}})

({{Lighter[color,f]}})

({{Lighter[image,…]}})

({{Likelihood[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Likelihood[proc,{{(Subscript[t, 1]),(Subscript[x, 1])},{(Subscript[t, 2]),(Subscript[x, 2])},…}]}})

({{Likelihood[proc,{(Subscript[path, 1]),(Subscript[path, 2]),…}]}})

({{LindleyDistribution[δ]}})

({{LinearFractionalTransform[m]}})

({{LinearFractionalTransform[{a,b,c,d}]}})

({{LinearizingTransformationData[…]}})

({{LinearRecurrence[ker,init,n]}})

({{LinearRecurrence[ker,init,{n}]}})

({{LinearRecurrence[ker,init,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{LinearSolveFunction[dimensions,data]}})

({{LineForm[g]}})

({{LinkActivate[lnk]}})

({{LinkClose[link]}})

({{LinkError[link]}})

({{LinkFlush[link]}})

({{LinkInterrupt[link]}})

({{LinkObject["name",(Subscript[n, 1]),(Subscript[n, 2])]}})

({{LinkPatterns[link]}})

({{LinkRead[link]}})

({{LinkRead[link,h]}})

({{LinkReadHeld[link]}})

({{LinkReadyQ[link]}})

({{LinkReadyQ[link,t]}})

({{LinkReadyQ[{(Subscript[link, 1]),(Subscript[link, 2]),…},t]}})

({{Links[]}})

({{Links[patt]}})

({{LinkWrite[link,expr]}})

({{LinkWriteHeld[link, Hold[expr], (flush:True)]}})

({{ListConvolve[ker,list]}})

({{ListConvolve[ker,list,k]}})

({{ListConvolve[ker,list,{(Subscript[k, L]),(Subscript[k, R])}]}})

({{ListConvolve[ker,list,klist,p]}})

({{ListConvolve[ker,list,klist,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{ListConvolve[ker,list,klist,padding,g,h]}})

({{ListConvolve[ker,list,klist,padding,g,h,lev]}})

({{ListCorrelate[ker,list]}})

({{ListCorrelate[ker,list,k]}})

({{ListCorrelate[ker,list,{(Subscript[k, L]),(Subscript[k, R])}]}})

({{ListCorrelate[ker,list,klist,p]}})

({{ListCorrelate[ker,list,klist,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{ListCorrelate[ker,list,klist,padding,g,h]}})

({{ListCorrelate[ker,list,klist,padding,g,h,lev]}})

({{ListPickerBox[list,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{ListQ[expr]}})

({{ListZTransform[list,z]}})

({{ListZTransform[list,z,k]}})

({{ListZTransform[list,{(Subscript[z, 1]),(Subscript[z, 2]),…},{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{LocalCache[CloudObject[uri]]}})

({{LocalCache[URL[url]]}})

({{LocalCache[obj,LocalObject[name]]}})

({{LocalClusteringCoefficient[g]}})

({{LocalClusteringCoefficient[g,v]}})

({{LocalClusteringCoefficient[{v->w,…},…]}})

({{LocalObject[]}})

({{LocalObject["file:/// …"]}})

({{LocalObject["relpath"]}})

({{LocalObject["relpath","lbase"]}})

({{LocalObjects[]}})

({{LocalObjects[dir]}})

({{LocalSymbol["name"]}})

({{LocalSymbol[obj]}})

({{LocalTime[]}})

({{LocalTime[loc]}})

({{LocalTime[loc,time]}})

({{LocalTime[loc,time,func]}})

({{LocalTimeZone[]}})

({{LocalTimeZone[loc]}})

({{LocalTimeZone[loc,date]}})

({{LocalTimeZone[loc,date,"prop"]}})

({{Log[z]}})

({{Log[b,z]}})

({{Log10[x]}})

({{Log2[x]}})

({{LogBarnesG[z]}})

({{LogGamma[z]}})

({{LogGammaDistribution[α,β,μ]}})

({{LogIntegral[z]}})

({{LogisticDistribution[μ,β]}})

({{LogisticDistribution[]}})

({{LogisticSigmoid[z]}})

({{LogLikelihood[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{LogLikelihood[proc,{(Subscript[path, 1]),(Subscript[path, 2]),…}]}})

({{LogLogisticDistribution[γ,σ]}})

({{LogMultinormalDistribution[μ,Σ]}})

({{LogNormalDistribution[μ,σ]}})

({{LogSeriesDistribution[θ]}})

({{Longest[p]}})

({{Longitude[pos]}})

({{Longitude[pos,datum]}})

({{LongLeftArrow[x,y,…]}})

({{LongLeftRightArrow[x,y,…]}})

({{LongRightArrow[x,y,…]}})

({{Lookup[assoc,key]}})

({{Lookup[assoc,{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{Lookup[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},key]}})

({{Lookup[assoc,key,default]}})

({{Lookup[key]}})

({{LoopFreeGraphQ[g]}})

({{LowerCaseQ[string]}})

({{LowerCaseQ[string]}})

({{LowerLeftArrow[x,y,…]}})

({{LowerRightArrow[x,y,…]}})

({{LowerTriangularize[m]}})

({{LowerTriangularize[m,k]}})

({{LucasL[n]}})

({{LucasL[n,x]}})

({{LuccioSamiComponents[g]}})

({{LuccioSamiComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{LuccioSamiComponents[{v->w,…},…]}})

({{LUVColor[l,u,v]}})

({{LUVColor[l,u,v,α]}})

({{LyapunovSolve[a,c]}})

({{LyapunovSolve[a,b,c]}})

({{LyapunovSolve[{a,d},c]}})

({{LyapunovSolve[{a,d},{b,e},c]}})

({{LyonsGroupLy[]}})

({{MachineNumberQ[expr]}})

({{MachineNumberQ[expr]}})

({{Magnify[expr,r]}})

({{Magnify[expr]}})

({{Majority[(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{MakeBoxes[expr,form]}})

({{MakeBoxes[expr]}})

({{MakeExpression[boxes,form]}})

({{ManagedLibraryExpressionID[expr]}})

({{ManagedLibraryExpressionID[expr,mname]}})

({{ManagedLibraryExpressionQ[expr]}})

({{ManagedLibraryExpressionQ[expr,mname]}})

({{MangoldtLambda[n]}})

({{ManhattanDistance[u,v]}})

({{MannedSpaceMissionData[entity,property]}})

({{MannedSpaceMissionData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MannedSpaceMissionData[name,property,annotation]}})

({{MantissaExponent[x]}})

({{MantissaExponent[x,b]}})

({{MapAt[f,expr,n]}})

({{MapAt[f,expr,{i,j,…}]}})

({{MapAt[f,expr,{{(Subscript[i, 1]),(Subscript[j, 1]),…},{(Subscript[i, 2]),(Subscript[j, 2]),…},…}]}})

({{MapAt[f,pos]}})

({{MAProcess[{(Subscript[b, 1]),…,(Subscript[b, q])},v]}})

({{MAProcess[{(Subscript[b, 1]),…,(Subscript[b, q])},Σ]}})

({{MAProcess[{(Subscript[b, 1]),…,(Subscript[b, q])},v,init]}})

({{MAProcess[c,…]}})

({{MapThread[f,{{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},…}]}})

({{MapThread[f,{(Subscript[expr, 1]),(Subscript[expr, 2]),…},n]}})

({{MapThread[f]}})

({{MarchenkoPasturDistribution[λ,σ]}})

({{MarchenkoPasturDistribution[λ]}})

({{MarcumQ[m,a,b]}})

({{MarcumQ[m,a,(Subscript[b, 0]),(Subscript[b, 1])]}})

({{MarginalDistribution[dist,k]}})

({{MarginalDistribution[dist,{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{MarkovProcessProperties[mproc]}})

({{MarkovProcessProperties[mproc,"property"]}})

({{MatchingDissimilarity[u,v]}})

({{MatchQ[expr,form]}})

({{MatchQ[form]}})

({{MathematicalFunctionData[entity,property]}})

({{MathematicalFunctionData[entity,property,annotation]}})

({{MathematicalFunctionData[entity,property,{(Subscript[qual, 1])->(Subscript[val, 1]),(Subscript[qual, 2])->(Subscript[val, 2]),…}]}})

({{MathematicalFunctionData[entity,property,annotation,{(Subscript[qual, 1])->(Subscript[val, 1]),(Subscript[qual, 2])->(Subscript[val, 2]),…}]}})

({{MathieuC[a,q,z]}})

({{MathieuCharacteristicA[r,q]}})

({{MathieuCharacteristicB[r,q]}})

({{MathieuCharacteristicExponent[a,q]}})

({{MathieuCPrime[a,q,z]}})

({{MathieuGroupM11[]}})

({{MathieuGroupM12[]}})

({{MathieuGroupM22[]}})

({{MathieuGroupM23[]}})

({{MathieuGroupM24[]}})

({{MathieuS[a,q,z]}})

({{MathieuSPrime[a,q,z]}})

({{MathMLForm[expr]}})

({{Matrices[{(Subscript[d, 1]),(Subscript[d, 2])}]}})

({{Matrices[{(Subscript[d, 1]),(Subscript[d, 2])},dom]}})

({{Matrices[{(Subscript[d, 1]),(Subscript[d, 2])},dom,sym]}})

({{MatrixNormalDistribution[(Subscript[Σ, row]),(Subscript[Σ, col])]}})

({{MatrixNormalDistribution[μ,(Subscript[Σ, row]),(Subscript[Σ, col])]}})

({{MatrixPropertyDistribution[expr,x\[Distributed]mdist]}})

({{MatrixPropertyDistribution[expr,{(Subscript[x, 1])\[Distributed](Subscript[mdist, 1]),(Subscript[x, 2])\[Distributed](Subscript[mdist, 2]),…}]}})

({{MatrixQ[expr]}})

({{MatrixQ[expr,test]}})

({{MatrixTDistribution[(Subscript[Σ, row]),(Subscript[Σ, col]),ν]}})

({{MatrixTDistribution[μ,(Subscript[Σ, row]),(Subscript[Σ, col]),ν]}})

({{Max[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{Max[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),…},…]}})

({{MaxFilter[data,r]}})

({{MaxFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{MaximalBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{MaximalBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f,n]}})

({{MaximalBy[f]}})

({{MaxMemoryUsed[]}})

({{MaxMemoryUsed[expr]}})

({{MaxStableDistribution[μ,σ,ξ]}})

({{MaxwellDistribution[σ]}})

({{McLaughlinGroupMcL[]}})

({{Mean[list]}})

({{Mean[dist]}})

({{MeanClusteringCoefficient[g]}})

({{MeanClusteringCoefficient[{v->w,…}]}})

({{MeanDegreeConnectivity[g]}})

({{MeanDegreeConnectivity[g,"In"]}})

({{MeanDegreeConnectivity[g,"Out"]}})

({{MeanDegreeConnectivity[{v->w,…},…]}})

({{MeanDeviation[list]}})

({{MeanFilter[data,r]}})

({{MeanFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{MeanNeighborDegree[g]}})

({{MeanNeighborDegree[g,"In"]}})

({{MeanNeighborDegree[g,"Out"]}})

({{MeanNeighborDegree[{v->w,…},…]}})

({{Median[list]}})

({{Median[dist]}})

({{MedianDeviation[list]}})

({{MedianFilter[image,r]}})

({{MedianFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{MedicalTestData[entity,property]}})

({{MedicalTestData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MedicalTestData[entity,property,annotation]}})

({{MeijerG[{{(Subscript[a, 1]),…,(Subscript[a, n])},{(Subscript[a, n+1]),…,(Subscript[a, p])}},{{(Subscript[b, 1]),…,(Subscript[b, m])},{(Subscript[b, m+1]),…,(Subscript[b, q])}},z]}})

({{MeixnerDistribution[a,b,m,d]}})

({{MemoryAvailable[]}})

({{MemoryConstrained[expr,b]}})

({{MemoryConstrained[expr,b,failexpr]}})

({{MemoryConstrained[expr,b,failexpr]}})

({{MemoryInUse[]}})

({{MemoryInUse[$FrontEnd]}})

({{MenuPacket[integer,string]}})

({{Merge[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…},f]}})

({{Merge[{(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…},f]}})

({{Merge[f]}})

({{MersennePrimeExponent[n]}})

({{MersennePrimeExponentQ[n]}})

({{MeshCellCount[mreg]}})

({{MeshCellCount[mreg,d]}})

({{MeshCellCount[mreg,cellspec]}})

({{MeshCellIndex[mreg,d]}})

({{MeshCellIndex[mreg,cellspec]}})

({{MeshCells[mreg,d]}})

({{MeshCells[mreg,cellspec]}})

({{MeshCoordinates[mreg]}})

({{MeshPrimitives[mreg,d]}})

({{MeshPrimitives[mreg,cellspec]}})

({{MeshRegionQ[reg]}})

({{Message[symbol::tag]}})

({{Message[symbol::tag,(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{MessageList[n]}})

({{MessagePacket[symbol,string]}})

({{MeteorShowerData[entity,property]}})

({{MeteorShowerData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MeteorShowerData[name,property,annotation]}})

({{MexicanHatWavelet[]}})

({{MexicanHatWavelet[σ]}})

({{MeyerWavelet[]}})

({{MeyerWavelet[n]}})

({{MeyerWavelet[n,lim]}})

({{Min[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{Min[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),…},…]}})

({{MineralData[entity,property]}})

({{MineralData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MineralData[entity,property,annotation]}})

({{MinFilter[data,r]}})

({{MinFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{MinimalBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{MinimalBy[{(Subscript[e, 1]),(Subscript[e, 2]),…},f,n]}})

({{MinimalBy[f]}})

({{MinimumTimeIncrement[tseries]}})

({{MinkowskiQuestionMark[x]}})

({{MinMax[list]}})

({{MinMax[list,δ]}})

({{MinMax[list,Scaled[s]]}})

({{MinMax[list,{(Subscript[δ, min]),(Subscript[δ, max])}]}})

({{MinorPlanetData[entity,property]}})

({{MinorPlanetData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MinorPlanetData[entity,property,annotation]}})

({{Minors[m]}})

({{Minors[m,k]}})

({{MinStableDistribution[μ,σ,ξ]}})

({{MinusPlus[x]}})

({{MinusPlus[x,y,…]}})

({{Missing[]}})

({{Missing["reason"]}})

({{Missing["reason",expr]}})

({{MissingQ[expr]}})

({{MittagLefflerE[α,z]}})

({{MittagLefflerE[α,β,z]}})

({{MixedGraphQ[g]}})

({{MixedMagnitude[{(Subscript[val, 1]),(Subscript[val, 2]),…,(Subscript[val, n])}]}})

({{MixedRadix[{(Subscript[b, 1]),…,(Subscript[b, n])}]}})

({{MixedRadixQuantity[{(Subscript[value, 1]),…,(Subscript[value, n])},{(Subscript[unit, 1]),…,(Subscript[unit, n])}]}})

({{MixedUnit[{(Subscript[unit, 1]),(Subscript[unit, 2]),…,(Subscript[unit, n])}]}})

({{MixtureDistribution[{(Subscript[w, 1]),…,(Subscript[w, n])},{(Subscript[dist, 1]),…,(Subscript[dist, n])}]}})

({{Mod[m,n]}})

({{Mod[m,n,d]}})

({{ModularInverse[k,n]}})

({{ModularLambda[τ]}})

({{Module[{x,y,…},expr]}})

({{Module[{x=(Subscript[x, 0]),…},expr]}})

({{MoebiusMu[n]}})

({{Moment[list,r]}})

({{Moment[dist,r]}})

({{Moment[…,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{Moment[r]}})

({{MomentConvert[mexpr,form]}})

({{MomentEvaluate[mexpr,dist]}})

({{MomentEvaluate[mexpr,list]}})

({{MomentEvaluate[mexpr,dist,list]}})

({{MomentGeneratingFunction[dist,t]}})

({{MomentGeneratingFunction[dist,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{Monitor[expr,mon]}})

({{MonsterGroupM[]}})

({{MoonPhase[]}})

({{MoonPhase[datespec]}})

({{MoonPhase[property]}})

({{MoonPhase[datespec,property]}})

({{MorletWavelet[]}})

({{Most[expr]}})

({{MountainData[entity,property]}})

({{MountainData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MountainData[entity,property,annotation]}})

({{MouseAnnotation[]}})

({{MouseAppearance[expr,graphic]}})

({{MouseAppearance[expr,graphic,{x,y}]}})

({{MouseAppearance[expr,graphic,Scaled[{x,y}]]}})

({{MouseAppearance[expr,"cursorname"]}})

({{MouseAppearance[expr, Automatic]}})

({{MouseButtons[]}})

({{MousePosition[]}})

({{MousePosition["coords"]}})

({{MousePosition["coords",def]}})

({{MovieData[entity,property]}})

({{MovieData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{MovieData[entity,property,annotation]}})

({{MovingAverage[list,r]}})

({{MovingAverage[list,{(Subscript[w, 1]),(Subscript[w, 2]),…,(Subscript[w, r])}]}})

({{MovingMap[f,data,w]}})

({{MovingMap[f,data,wspec]}})

({{MovingMap[f,data,wspec,padding]}})

({{MovingMedian[list,r]}})

({{MoyalDistribution[μ,σ]}})

({{MoyalDistribution[]}})

({{MultigraphQ[g]}})

({{Multinomial[(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{MultinomialDistribution[n,{(Subscript[p, 1]),(Subscript[p, 2]),…,(Subscript[p, m])}]}})

({{MultinormalDistribution[μ,Σ]}})

({{MultinormalDistribution[Σ]}})

({{MultiplicativeOrder[k,n]}})

({{MultiplicativeOrder[k,n,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{MultivariateHypergeometricDistribution[n,{(Subscript[m, 1]),(Subscript[m, 2]),…,(Subscript[m, k])}]}})

({{MultivariatePoissonDistribution[(Subscript[μ, 0]),{(Subscript[μ, 1]),(Subscript[μ, 2]),…}]}})

({{MultivariateTDistribution[Σ,ν]}})

({{MultivariateTDistribution[μ,Σ,ν]}})

({{N[expr]}})

({{N[expr,n]}})

({{NakagamiDistribution[μ,ω]}})

({{NameQ["string"]}})

({{NBernoulliB[n]}})

({{NBernoulliB[n, d]}})

({{NCache[x,xn]}})

({{NearestFunction[data]}})

({{NebulaData[entity,property]}})

({{NebulaData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{NebulaData[entity,property,annotation]}})

({{Needs["context`"]}})

({{Needs["context`","file"]}})

({{Negative[x]}})

({{NegativeBinomialDistribution[n,p]}})

({{NegativeDefiniteMatrixQ[m]}})

({{NegativeMultinomialDistribution[n,p]}})

({{NeighborhoodData[entity,property]}})

({{NeighborhoodData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{NeighborhoodData[entity,property,annotation]}})

({{Nest[f,expr,n]}})

({{NestedGreaterGreater[x,y,…]}})

({{NestedLessLess[x,y,…]}})

({{NestList[f,expr,n]}})

({{NestWhile[f,expr,test]}})

({{NestWhile[f,expr,test,m]}})

({{NestWhile[f,expr,test,All]}})

({{NestWhile[f,expr,test,m,max]}})

({{NestWhile[f,expr,test,m,max,n]}})

({{NestWhile[f,expr,test,m,max,-n]}})

({{NestWhileList[f,expr,test]}})

({{NestWhileList[f,expr,test,m]}})

({{NestWhileList[f,expr,test,All]}})

({{NestWhileList[f,expr,test,m,max]}})

({{NetChain[{(Subscript[layer, 1]),(Subscript[layer, 2]),…}]}})

({{NetDecoder[type]}})

({{NetEncoder[type]}})

({{NetExtract[layer,"param"]}})

({{NetExtract[net,lspec]}})

({{NetExtract[net,{lspec,"param"}]}})

({{NetExtract[net,{(Subscript[spec, 1]),(Subscript[spec, 2]),…}]}})

({{NetGraph[{(Subscript[layer, 1]),(Subscript[layer, 2]),…},{(Subscript[m, 1])->(Subscript[n, 1]),(Subscript[m, 2])->(Subscript[n, 2]),…}]}})

({{NetGraph[\[LeftAssociation]"(Subscript[name, 1])"->(Subscript[layer, 1]),"(Subscript[name, 2])"->(Subscript[layer, 2]),…\[RightAssociation],{"(Subscript[name, m1])"->"(Subscript[name, n1])",…}]}})

({{NetInformation[net,"property"]}})

({{NetModel["name"]}})

({{NetModel["name","prop"]}})

({{NetPort[{n,"port"}]}})

({{NetPort[{"name","port"}]}})

({{NetPort[spec,port]}})

({{NetPort[{spec,port}]}})

({{NetPort["port"]}})

({{NetPortGradient["port"]}})

({{NetPortGradient["param"]}})

({{NetPortGradient[{(Subscript[layer, 1]),(Subscript[layer, 2]),…,"param"}]}})

({{NetRename[net,"old"->"new"]}})

({{NetRename[net,{(Subscript[rule, 1]),(Subscript[rule, 2]),…}]}})

({{NetRename[net,f]}})

({{NetReplacePart[layer,"array"->value]}})

({{NetReplacePart[layer,"port"->type]}})

({{NetReplacePart[net,"input"->encoder]}})

({{NetReplacePart[net,"output"->decoder]}})

({{NetReplacePart[net,{lspec,pspec}->value]}})

({{NetReplacePart[net,{(Subscript[spec, 1])->(Subscript[val, 1]),(Subscript[spec, 2])->(Subscript[val, 2]),…}]}})

({{NetworkPacketCapture[]}})

({{NetworkPacketCapture[service]}})

({{NetworkPacketCapture[port]}})

({{NetworkPacketCapture[spec]}})

({{NetworkPacketRecording[t]}})

({{NetworkPacketRecording[t,service]}})

({{NetworkPacketRecording[t,port]}})

({{NetworkPacketRecording[t,{(Subscript[port, 1]),(Subscript[port, 2]),…}]}})

({{NetworkPacketRecording[t,spec]}})

({{NeumannValue[val,pred]}})

({{NevilleThetaC[z,m]}})

({{NevilleThetaD[z,m]}})

({{NevilleThetaN[z,m]}})

({{NevilleThetaS[z,m]}})

({{NextPrime[n]}})

({{NextPrime[n,k]}})

({{NextScheduledTaskTime[obj]}})

({{NightHemisphere[]}})

({{NightHemisphere[datespec]}})

({{NoncentralBetaDistribution[α,β,δ]}})

({{NoncentralChiSquareDistribution[ν,λ]}})

({{NoncentralFRatioDistribution[n,m,λ]}})

({{NoncentralFRatioDistribution[n,m,λ, η]}})

({{NoncentralStudentTDistribution[ν,δ]}})

({{NoneTrue[{(Subscript[e, 1]),(Subscript[e, 2]),…},test]}})

({{NoneTrue[expr,test,level]}})

({{NoneTrue[test]}})

({{NonNegative[x]}})

({{NonPositive[x]}})

({{NorlundB[n,a]}})

({{NorlundB[n,a,x]}})

({{Normal[expr]}})

({{Normal[expr,h]}})

({{Normal[expr,{(Subscript[h, 1]),(Subscript[h, 2]),…}]}})

({{NormalDistribution[μ,σ]}})

({{NormalDistribution[]}})

({{Normalize[v]}})

({{Normalize[z]}})

({{Normalize[expr,f]}})

({{NormalizedSquaredEuclideanDistance[u,v]}})

({{NotCongruent[x,y,…]}})

({{NotCupCap[x,y,…]}})

({{NotDoubleVerticalBar[x,y,…]}})

({{NotebookCreate[]}})

({{NotebookCreate[options]}})

({{NotebookDirectory[]}})

({{NotebookDirectory[nb]}})

({{NotebookFileName[]}})

({{NotebookFileName[nb]}})

({{NotebookInformation[]}})

({{NotebookInformation[notebook]}})

({{NotebookLocate["tag"]}})

({{NotebookLocate[{"file","tag"}]}})

({{NotebookObject[fe,id]}})

({{NotebookOpen["name"]}})

({{NotebookOpen["name",options]}})

({{NotebookOpen["http://url",…]}})

({{NotebookSelection[]}})

({{NotebookSelection[nb]}})

({{NotebookTemplate[nb]}})

({{NotElement[x,dom]}})

({{NotElement[(Subscript[x, 1])|…|(Subscript[x, n]),dom]}})

({{NotElement[patt,dom]}})

({{NotEqualTilde[x,y,…]}})

({{NotExists[x, y]}})

({{NotGreater[x,y,…]}})

({{NotGreaterEqual[x,y,…]}})

({{NotGreaterFullEqual[x,y,…]}})

({{NotGreaterGreater[x,y,…]}})

({{NotGreaterLess[x,y,…]}})

({{NotGreaterSlantEqual[x,y,…]}})

({{NotGreaterTilde[x,y,…]}})

({{Nothing[…]}})

({{NotHumpDownHump[x,y,…]}})

({{NotHumpEqual[x,y,…]}})

({{NotLeftTriangle[x,y,…]}})

({{NotLeftTriangleBar[x,y,…]}})

({{NotLeftTriangleEqual[x,y,…]}})

({{NotLess[x,y,…]}})

({{NotLessEqual[x,y,…]}})

({{NotLessFullEqual[x,y,…]}})

({{NotLessGreater[x,y,…]}})

({{NotLessLess[x,y,…]}})

({{NotLessSlantEqual[x,y,…]}})

({{NotLessTilde[x,y,…]}})

({{NotNestedGreaterGreater[x,y,…]}})

({{NotNestedLessLess[x,y,…]}})

({{NotPrecedes[x,y,…]}})

({{NotPrecedesEqual[x,y,…]}})

({{NotPrecedesSlantEqual[x,y,…]}})

({{NotPrecedesTilde[x,y,…]}})

({{NotReverseElement[x,y,…]}})

({{NotRightTriangle[x,y,…]}})

({{NotRightTriangleBar[x,y,…]}})

({{NotRightTriangleEqual[x,y,…]}})

({{NotSquareSubset[x,y,…]}})

({{NotSquareSubsetEqual[x,y,…]}})

({{NotSquareSuperset[x,y,…]}})

({{NotSquareSupersetEqual[x,y,…]}})

({{NotSubset[x,y,…]}})

({{NotSubsetEqual[x,y,…]}})

({{NotSucceeds[x,y,…]}})

({{NotSucceedsEqual[x,y,…]}})

({{NotSucceedsSlantEqual[x,y,…]}})

({{NotSucceedsTilde[x,y,…]}})

({{NotSuperset[x,y,…]}})

({{NotSupersetEqual[x,y,…]}})

({{NotTilde[x,y,…]}})

({{NotTildeEqual[x,y,…]}})

({{NotTildeFullEqual[x,y,…]}})

({{NotTildeTilde[x,y,…]}})

({{NotVerticalBar[x,y,…]}})

({{NuclearExplosionData[entity,property]}})

({{NuclearExplosionData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{NuclearExplosionData[entity,property,annotation]}})

({{NuclearReactorData[entity,property]}})

({{NuclearReactorData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{NuclearReactorData[entity,property,annotation]}})

({{NumberCompose[{(Subscript[c, 1]),…,(Subscript[c, n])},{(Subscript[u, 1]),…,(Subscript[u, n])}]}})

({{NumberDecompose[x,{(Subscript[u, 1]),…,(Subscript[u, n])}]}})

({{NumberExpand[x]}})

({{NumberExpand[x,b]}})

({{NumberExpand[x,b,len]}})

({{NumberFieldClassNumber[θ]}})

({{NumberFieldDiscriminant[a]}})

({{NumberFieldFundamentalUnits[a]}})

({{NumberFieldIntegralBasis[a]}})

({{NumberFieldNormRepresentatives[a,m]}})

({{NumberFieldRegulator[a]}})

({{NumberFieldRootsOfUnity[a]}})

({{NumberFieldSignature[a]}})

({{NumberQ[expr]}})

({{NumericalOrder[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{NumericalSort[list]}})

({{NumericQ[expr]}})

({{NuttallWindow[x]}})

({{ObservabilityMatrix[ssm]}})

({{OceanData[entity,property]}})

({{OceanData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{OceanData[entity,property,annotation]}})

({{OddQ[expr]}})

({{Off[symbol::tag]}})

({{Off["name"]}})

({{Off[s]}})

({{Off[(Subscript[m, 1]),(Subscript[m, 2]),…]}})

({{Offset[{dx,dy},position]}})

({{On[symbol::tag]}})

({{On["name"]}})

({{On[s]}})

({{On[(Subscript[m, 1]),(Subscript[m, 2]),…]}})

({{ONanGroupON[]}})

({{Opacity[a]}})

({{Opacity[a,color]}})

({{Opening[image,ker]}})

({{Opening[image,r]}})

({{Opening[data,…]}})

({{Operate[p,f[x,y]]}})

({{Operate[p,expr,n]}})

({{OptimumFlowData[…]}})

({{OptionalElement[patt]}})

({{OptionalElement[patt,default]}})

({{OptionQ[e]}})

({{Options[symbol]}})

({{Options[expr]}})

({{Options[stream]}})

({{Options["sname"]}})

({{Options[object]}})

({{Options[obj,name]}})

({{Options[obj,{(Subscript[name, 1]),(Subscript[name, 2]),…}]}})

({{OptionsPattern[]}})

({{OptionsPattern[f]}})

({{OptionsPattern[{(Subscript[opt, 1])->(Subscript[val, 1]),(Subscript[opt, 2])->(Subscript[val, 2]),…}]}})

({{OptionValue[name]}})

({{OptionValue[f,name]}})

({{OptionValue[f,opts,name]}})

({{OptionValue[…,{(Subscript[name, 1]),(Subscript[name, 2]),…}]}})

({{Order[(Subscript[expr, 1]),(Subscript[expr, 2])]}})

({{OrderDistribution[{dist,n},k]}})

({{OrderDistribution[{dist,n},{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{OrderDistribution[{(Subscript[dist, 1]),…,(Subscript[dist, n])},…]}})

({{OrderDistribution[mdist,…]}})

({{OrderedQ[h[(Subscript[e, 1]),(Subscript[e, 2]),…]]}})

({{Ordering[list]}})

({{Ordering[list,n]}})

({{Ordering[list,-n]}})

({{Ordering[list,n,p]}})

({{OrderlessPatternSequence[(Subscript[p, 1]),(Subscript[p, 2]),…]}})

({{OrnsteinUhlenbeckProcess[μ,σ,θ]}})

({{OrnsteinUhlenbeckProcess[μ,σ,θ,(Subscript[x, 0])]}})

({{Out[n]}})

({{Outer[f,(Subscript[list, 1]),(Subscript[list, 2]),…]}})

({{Outer[f,(Subscript[list, 1]),(Subscript[list, 2]),…,n]}})

({{Outer[f,(Subscript[list, 1]),(Subscript[list, 2]),…,(Subscript[n, 1]),(Subscript[n, 2]),…]}})

({{OutputControllabilityMatrix[ssm]}})

({{OutputForm[expr]}})

({{OutputNamePacket[string]}})

({{OutputResponse[sys,u,{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{OutputResponse[sys,{u[0],u[1],…}]}})

({{OutputResponse[sys,u,t]}})

({{OutputResponse[sys,{(Subscript[u, 1]),…,(Subscript[u, m])},…]}})

({{OutputStream["name",n]}})

({{OverBar[expr]}})

({{OverDot[expr]}})

({{Overflow[]}})

({{OverHat[expr]}})

({{Overscript[x,y]}})

({{OverTilde[expr]}})

({{OverVector[expr]}})

({{OwenT[x,a]}})

({{PadeApproximant[expr,{x,(Subscript[x, 0]),{m,n}}]}})

({{PadeApproximant[expr,{x,(Subscript[x, 0]),n}]}})

({{PadLeft[list,n]}})

({{PadLeft[list,n,x]}})

({{PadLeft[list,n,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{PadLeft[list,n,padding,m]}})

({{PadLeft[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{PadLeft[list]}})

({{PadRight[list,n]}})

({{PadRight[list,n,x]}})

({{PadRight[list,n,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{PadRight[list,n,padding,m]}})

({{PadRight[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{PadRight[list]}})

({{ParabolicCylinderD[ν,z]}})

({{Parallelepiped[p,{(Subscript[v, 1]),…,(Subscript[v, k])}]}})

({{ParallelNeeds["context`"]}})

({{Parallelogram[p,{(Subscript[v, 1]),(Subscript[v, 2])}]}})

({{ParametricFunction[pars,…]}})

({{ParametricRegion[{(Subscript[f, 1]),…,(Subscript[f, n])},{(Subscript[u, 1]),…,(Subscript[u, m])}]}})

({{ParametricRegion[{(Subscript[f, 1]),…,(Subscript[f, n])},{{(Subscript[u, 1]),(Subscript[a, 1]),(Subscript[b, 1])},…}]}})

({{ParametricRegion[{{(Subscript[f, 1]),…,(Subscript[f, n])},cond},…]}})

({{ParentBox[obj]}})

({{ParentCell[obj]}})

({{ParentDirectory[]}})

({{ParentDirectory["dir"]}})

({{ParentDirectory["dir",n]}})

({{Parenthesize[ expr, fmt, prec, group]}})

({{ParentNotebook[obj]}})

({{ParetoDistribution[k,α]}})

({{ParetoDistribution[k,α,μ]}})

({{ParetoDistribution[k,α,γ,μ]}})

({{ParkData[entity,property]}})

({{ParkData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{ParkData[entity,property,annotation]}})

({{Part[expr,i]}})

({{Part[expr,i,j,…]}})

({{PartialCorrelationFunction[data,hspec]}})

({{PartialCorrelationFunction[tproc,hspec]}})

({{ParticleAcceleratorData[entity,property]}})

({{ParticleAcceleratorData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{ParticleAcceleratorData[entity,property,annotation]}})

({{ParticleData[name,"property"]}})

({{ParticleData[{name,q},"property"]}})

({{Partition[list,n]}})

({{Partition[list,n,d]}})

({{Partition[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{Partition[list,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[d, 1]),(Subscript[d, 2]),…}]}})

({{Partition[list,n,d,{(Subscript[k, L]),(Subscript[k, R])}]}})

({{Partition[list,n,d,{(Subscript[k, L]),(Subscript[k, R])},x]}})

({{Partition[list,n,d,{(Subscript[k, L]),(Subscript[k, R])},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Partition[list,n,d,{(Subscript[k, L]),(Subscript[k, R])},{}]}})

({{Partition[list,nlist,dlist,{(Subscript[klist, L]),(Subscript[klist, R])},padlist]}})

({{PartitionsP[n]}})

({{PartitionsQ[n]}})

({{PartOfSpeech["word"]}})

({{ParzenWindow[x]}})

({{PascalDistribution[n,p]}})

({{PathGraphQ[g]}})

({{PatternSequence[(Subscript[p, 1]),(Subscript[p, 2]),…]}})

({{PauliMatrix[k]}})

({{PaulWavelet[]}})

({{PaulWavelet[n]}})

({{Pause[n]}})

({{PDF[dist,x]}})

({{PDF[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{PDF[dist]}})

({{PearsonDistribution[(Subscript[a, 1]),(Subscript[a, 0]),(Subscript[b, 2]),(Subscript[b, 1]),(Subscript[b, 0])]}})

({{PearsonDistribution[type,(Subscript[a, 1]),(Subscript[a, 0]),(Subscript[b, 2]),(Subscript[b, 1]),(Subscript[b, 0])]}})

({{PerfectNumber[n]}})

({{PerfectNumberQ[n]}})

({{PeriodicBoundaryCondition[u[(Subscript[x, 1]),…],pred,f]}})

({{PeriodicBoundaryCondition[a+b u[(Subscript[x, 1]),…],pred,f]}})

({{PermissionsGroup["name"]}})

({{PermissionsGroup[user,"name"]}})

({{PermissionsGroups[]}})

({{PermissionsKey["key"]}})

({{PermutationCycles[perm]}})

({{PermutationCyclesQ[expr]}})

({{PermutationGroup[{(Subscript[perm, 1]),…,(Subscript[perm, n])}]}})

({{PermutationLength[perm]}})

({{PermutationList[perm]}})

({{PermutationList[perm,len]}})

({{PermutationListQ[expr]}})

({{PermutationMax[perm]}})

({{PermutationMin[perm]}})

({{PermutationOrder[perm]}})

({{PermutationPower[perm,n]}})

({{PermutationProduct[a,b,c]}})

({{PermutationReplace[expr,perm]}})

({{PermutationReplace[expr,gr]}})

({{Permutations[list]}})

({{Permutations[list,n]}})

({{Permutations[list,{n}]}})

({{PermutationSupport[perm]}})

({{Permute[expr,perm]}})

({{Permute[expr,gr]}})

({{PeronaMalikFilter[image]}})

({{PeronaMalikFilter[image,t]}})

({{PeronaMalikFilter[image,t,k]}})

({{PeronaMalikFilter[image,t,k,σ]}})

({{PersistenceLocation["type"]}})

({{PersistenceLocation["type",base]}})

({{PersistentObject["name",loc]}})

({{PersistentObjects[]}})

({{PersistentObjects[patt]}})

({{PersistentObjects[patt,loc]}})

({{PersistentObjects[patt,{(Subscript[loc, 1]),…}]}})

({{PersonData[entity,property]}})

({{PersonData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PersonData[entity,property,annotation]}})

({{PERTDistribution[{min,max},c]}})

({{PERTDistribution[{min,max},c,λ]}})

({{PhysicalSystemData[entity,property]}})

({{PhysicalSystemData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PhysicalSystemData[entity,property,annotation]}})

({{Pick[list,sel]}})

({{Pick[list,sel,patt]}})

({{PIDData[…]}})

({{Piecewise[{{(Subscript[val, 1]),(Subscript[cond, 1])},{(Subscript[val, 2]),(Subscript[cond, 2])},…}]}})

({{Piecewise[{{(Subscript[val, 1]),(Subscript[cond, 1])},…},val]}})

({{PillaiTrace[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{PixelValuePositions[image,val]}})

({{PixelValuePositions[image,val,d]}})

({{Placed[expr,pos]}})

({{Placed[{(Subscript[e, 1]),(Subscript[e, 2]),…},pos]}})

({{Placed[{(Subscript[e, 1]),(Subscript[e, 2]),…},pos,f]}})

({{Placeholder[name]}})

({{Placeholder[]}})

({{PlanarGraphQ[g]}})

({{PlanckRadiationLaw[temperature,λ]}})

({{PlanckRadiationLaw[temperature,f]}})

({{PlanckRadiationLaw[temperature,property]}})

({{PlanckRadiationLaw[temperature,{(Subscript[λ, 1]),(Subscript[λ, 2])}]}})

({{PlanckRadiationLaw[temperature,{(Subscript[f, 1]),(Subscript[f, 2])}]}})

({{PlaneCurveData[entity,property]}})

({{PlaneCurveData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PlaneCurveData[entity,property,annotation]}})

({{PlanetaryMoonData[entity,property]}})

({{PlanetaryMoonData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PlanetaryMoonData[entity,property,annotation]}})

({{PlanetData[entity,property]}})

({{PlanetData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PlanetData[entity,property,annotation]}})

({{PlantData[entity,property]}})

({{PlantData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PlantData[entity,property,annotation]}})

({{Pluralize["noun"]}})

({{Pluralize["noun",n]}})

({{Pluralize[{"singular","plural"},n]}})

({{Pluralize[spec,list]}})

({{PlusMinus[x]}})

({{PlusMinus[x,y,…]}})

({{Pochhammer[a,n]}})

({{PointForm[g]}})

({{PointSize[d]}})

({{PoissonConsulDistribution[μ,λ]}})

({{PoissonDistribution[μ]}})

({{PoissonProcess[μ]}})

({{PoissonWindow[x]}})

({{PoissonWindow[x,α]}})

({{PolyaAeppliDistribution[θ,p]}})

({{PolyGamma[z]}})

({{PolyGamma[n,z]}})

({{PolygonalNumber[n]}})

({{PolygonalNumber[r,n]}})

({{PolyhedronData[poly,"property"]}})

({{PolyhedronData[poly]}})

({{PolyhedronData["class"]}})

({{PolyLog[n,z]}})

({{PolyLog[n,p,z]}})

({{PolynomialQ[expr,var]}})

({{PolynomialQ[expr,{(Subscript[var, 1]),…}]}})

({{Polynomials[x]}})

({{PositionIndex[list]}})

({{PositionIndex[assoc]}})

({{Positive[x]}})

({{PositiveDefiniteMatrixQ[m]}})

({{Postfix[f[expr]]}})

({{Postfix[f[expr],h]}})

({{PowerDistribution[k,a]}})

({{PowerMod[a,b,m]}})

({{PowerMod[a,-1,m]}})

({{PowerMod[a,1/r,m]}})

({{PowerModList[a,s/r,m]}})

({{PowerRange[b]}})

({{PowerRange[a,b]}})

({{PowerRange[a,b,r]}})

({{PowersRepresentations[n,k,p]}})

({{PowerSymmetricPolynomial[r]}})

({{PowerSymmetricPolynomial[{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{PowerSymmetricPolynomial[rspec,data]}})

({{PrecedenceForm[expr,prec]}})

({{Precedes[x,y,…]}})

({{PrecedesEqual[x,y,…]}})

({{PrecedesSlantEqual[x,y,…]}})

({{PrecedesTilde[x,y,…]}})

({{Precision[x]}})

({{PredictorInformation[predictor]}})

({{PredictorInformation[predictor,prop]}})

({{PreemptProtect[expr]}})

({{Prefix[f[expr]]}})

({{Prefix[f[expr],h]}})

({{Prepend[expr,elem]}})

({{Prepend[elem]}})

({{PrependTo[s,elem]}})

({{Prime[n]}})

({{PrimePi[x]}})

({{PrimeZetaP[s]}})

({{PrimitivePolynomialQ[poly,p]}})

({{PrimitiveRoot[n]}})

({{PrimitiveRoot[n,k]}})

({{PrimitiveRootList[n]}})

({{Print[expr]}})

({{PrintableASCIIQ[string]}})

({{PrintTemporary[expr]}})

({{PrivateKey[assoc]}})

({{ProcessConnection[proc,"stream"]}})

({{Processes[]}})

({{ProcessInformation[proc]}})

({{ProcessInformation[proc,"prop"]}})

({{ProcessObject[…]}})

({{ProcessObject[pid]}})

({{ProcessParameterAssumptions[proc]}})

({{ProcessParameterQ[proc]}})

({{ProcessStatus[proc]}})

({{ProcessStatus[proc,"status"]}})

({{ProductDistribution[(Subscript[dist, 1]),(Subscript[dist, 2]),…]}})

({{ProductLog[z]}})

({{ProductLog[k,z]}})

({{Projection[u,v]}})

({{Projection[u,v,f]}})

({{PromptForm[prompt, expr]}})

({{ProofObject[…]}})

({{Property[item,name->value]}})

({{PropertyList[{obj,itemspec}]}})

({{Proportion[x,y,…]}})

({{Proportional[x,y,…]}})

({{Protect[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{Protect["(Subscript[form, 1])","(Subscript[form, 2])",…]}})

({{ProteinData[entity]}})

({{ProteinData[entity,property]}})

({{ProteinData[entity,property,annotation]}})

({{PublicKey[assoc]}})

({{PulsarData[entity,property]}})

({{PulsarData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{PulsarData[entity,property,annotation]}})

({{Put[(Subscript[expr, 1]),(Subscript[expr, 2]),…,"filename"]}})

({{Put["filename"]}})

({{PutAppend[(Subscript[expr, 1]),(Subscript[expr, 2]),…,"filename"]}})

({{QBinomial[n,m,q]}})

({{QFactorial[n,q]}})

({{QGamma[z,q]}})

({{QHypergeometricPFQ[{(Subscript[a, 1]),…,(Subscript[a, r])},{(Subscript[b, 1]),…,(Subscript[b, s])},q,z]}})

({{QPochhammer[a,q,n]}})

({{QPochhammer[a,q]}})

({{QPochhammer[q]}})

({{QPolyGamma[z,q]}})

({{QPolyGamma[n,z,q]}})

({{QuadraticIrrationalQ[x]}})

({{Quantile[list,q]}})

({{Quantile[list,{(Subscript[q, 1]),(Subscript[q, 2]),…}]}})

({{Quantile[list,q,{{a,b},{c,d}}]}})

({{Quantile[dist,q]}})

({{QuantityArray[mags,unit]}})

({{QuantityArray[mags,{(Subscript[unit, 1]),(Subscript[unit, 2]),…}]}})

({{QuantityArray[quants]}})

({{QuantityDistribution[dist,unit]}})

({{QuantityDistribution[dist,{(Subscript[unit, 1]),(Subscript[unit, 2]),…}]}})

({{QuantityForm[expr,form]}})

({{QuantityForm[expr,{forms}]}})

({{QuantityMagnitude[quantity]}})

({{QuantityMagnitude[quantity,unit]}})

({{QuantityQ[expr]}})

({{QuantityThread[quantity]}})

({{QuantityThread[quantity,n]}})

({{QuantityUnit[quantity]}})

({{QuantityVariable[var,"pq"]}})

({{QuantityVariable["pq"]}})

({{QuantityVariableCanonicalUnit[quantityvariable]}})

({{QuantityVariableDimensions[quantityvariable]}})

({{QuantityVariableIdentifier[quantityvariable]}})

({{QuantityVariablePhysicalQuantity[var]}})

({{QuartileDeviation[list]}})

({{QuartileDeviation[dist]}})

({{Quartiles[list]}})

({{Quartiles[dist]}})

({{QuartileSkewness[list]}})

({{QuartileSkewness[dist]}})

({{QueueingNetworkProcess[γ,r,μ,c]}})

({{QueueingNetworkProcess[γ,r,μ,c,k]}})

({{QueueingProcess[λ,μ]}})

({{QueueingProcess[λ,sdist]}})

({{QueueingProcess[adist,μ]}})

({{QueueingProcess[adist,sdist]}})

({{QueueingProcess[…,…,c]}})

({{QueueingProcess[…,…,c,k]}})

({{QueueingProcess[…,…,c,k,(Subscript[x, 0])]}})

({{QueueProperties[qproc]}})

({{QueueProperties[{qproc,i}]}})

({{QueueProperties[data]}})

({{QueueProperties[…,"property"]}})

({{Quiet[expr]}})

({{Quiet[expr,{(Subscript[s, 1])::(Subscript[t, 1]),(Subscript[s, 2])::(Subscript[t, 2]),…}]}})

({{Quiet[expr,"name"]}})

({{Quit[]}})

({{Quotient[m,n]}})

({{Quotient[m,n,d]}})

({{QuotientRemainder[m,n]}})

({{RadialityCentrality[g]}})

({{RadialityCentrality[g,"In"]}})

({{RadialityCentrality[g,"Out"]}})

({{RadialityCentrality[{v->w,…},…]}})

({{RamanujanTau[n]}})

({{RamanujanTauL[s]}})

({{RamanujanTauTheta[t]}})

({{RamanujanTauZ[t]}})

({{Ramp[x]}})

({{Random[]}})

({{Random[type,range]}})

({{RandomChoice[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{RandomChoice[list,n]}})

({{RandomChoice[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomChoice[{(Subscript[w, 1]),(Subscript[w, 2]),…}->{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{RandomChoice[wlist->elist,n]}})

({{RandomChoice[wlist->elist,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomEntity[spec]}})

({{RandomEntity[spec,n]}})

({{RandomInteger[{(Subscript[i, min]),(Subscript[i, max])}]}})

({{RandomInteger[(Subscript[i, max])]}})

({{RandomInteger[]}})

({{RandomInteger[range,n]}})

({{RandomInteger[range,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomPermutation[gr]}})

({{RandomPermutation[gr,n]}})

({{RandomPrime[{(Subscript[i, min]),(Subscript[i, max])}]}})

({{RandomPrime[(Subscript[i, max])]}})

({{RandomPrime[range,n]}})

({{RandomSample[{(Subscript[e, 1]),(Subscript[e, 2]),…},n]}})

({{RandomSample[{(Subscript[w, 1]),(Subscript[w, 2]),…}->{(Subscript[e, 1]),(Subscript[e, 2]),…},n]}})

({{RandomSample[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{RandomWalkProcess[p]}})

({{RandomWalkProcess[p,q]}})

({{Range[(Subscript[i, max])]}})

({{Range[(Subscript[i, min]),(Subscript[i, max])]}})

({{Range[(Subscript[i, min]),(Subscript[i, max]),di]}})

({{RangeFilter[data,r]}})

({{RangeFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{RankedMax[list,n]}})

({{RankedMax[list,-n]}})

({{RankedMin[list,n]}})

({{RankedMin[list,-n]}})

({{RasterArray[{{(Subscript[g, 11]),(Subscript[g, 12]),…},…}]}})

({{Rationalize[x]}})

({{Rationalize[x,dx]}})

({{Ratios[list]}})

({{Ratios[list,n]}})

({{Ratios[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RawBoxes[boxes]}})

({{RawData[data]}})

({{RayleighDistribution[σ]}})

({{Re[z]}})

({{RealAbs[x]}})

({{RealDigits[x]}})

({{RealDigits[x,b]}})

({{RealDigits[x,b,len]}})

({{RealDigits[x,b,len,n]}})

({{RealExponent[x]}})

({{RealExponent[x,b]}})

({{RealSign[x]}})

({{Reap[expr]}})

({{Reap[expr,patt]}})

({{Reap[expr,{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{Reap[expr,patt,f]}})

({{RectangularRepeatingElement[elem]}})

({{RectangularRepeatingElement[elem,{maxrows,maxcolumns}]}})

({{RectangularRepeatingElement[elem,{{minrows,maxrows},{mincolumns,maxcolumns}}]}})

({{ReflectionMatrix[v]}})

({{ReflectionTransform[v]}})

({{ReflectionTransform[v,p]}})

({{RegionBoundary[reg]}})

({{RegionBounds[reg]}})

({{RegionBounds[reg,"type"]}})

({{RegionDistance[reg,p]}})

({{RegionDistance[reg]}})

({{RegionEmbeddingDimension[reg]}})

({{RegionMember[reg,{x,y,…}]}})

({{RegionMember[reg,{x,y,…}]}})

({{RegionMember[reg]}})

({{RegionNearest[reg,p]}})

({{RegionNearest[reg]}})

({{RegionProduct[(Subscript[reg, 1]),(Subscript[reg, 2])]}})

({{RegionProduct[(Subscript[reg, 1]),(Subscript[reg, 2]),…]}})

({{RegionQ[reg]}})

({{RegionResize[reg,l]}})

({{RegionResize[reg,{(Subscript[l, max])}]}})

({{RegionResize[reg,{(Subscript[l, 1]),(Subscript[l, 2]),…}]}})

({{RegionResize[reg,{{(Subscript[x, 1,min]),(Subscript[x, 1,max])},{(Subscript[x, 2,min]),(Subscript[x, 2,max])},…}]}})

({{RegisterExternalEvaluator[sys,exec]}})

({{RegularExpression["regex"]}})

({{RegularlySampledQ[tseries]}})

({{RegularPolygon[n]}})

({{RegularPolygon[r,n]}})

({{RegularPolygon[{r,(Subscript[θ, 1])},n]}})

({{RegularPolygon[{x,y},rspec,n]}})

({{ReIm[z]}})

({{Reinstall[link]}})

({{ReleaseHold[expr]}})

({{ReliabilityDistribution[bexpr,{{(Subscript[x, 1]),(Subscript[dist, 1])},{(Subscript[x, 2]),(Subscript[dist, 2])},…}]}})

({{Remove[(Subscript[symbol, 1]),…]}})

({{Remove["(Subscript[form, 1])","(Subscript[form, 2])",…]}})

({{RemoveAlphaChannel[image]}})

({{RemoveAlphaChannel[image,c]}})

({{RemoveAsynchronousTask[asyncTask]}})

({{RemoveAudioStream[]}})

({{RemoveAudioStream[stream]}})

({{RemoveAudioStream[audio]}})

({{RemoveBackground[image]}})

({{RemoveBackground[image,model]}})

({{RemoveChannelListener[obj]}})

({{RemoveChannelListener[{(Subscript[obj, 1]),(Subscript[obj, 2]),…}]}})

({{RemoveChannelListener[]}})

({{Removed[string]}})

({{RemoveInputStreamMethod["name"]}})

({{RemoveOutputStreamMethod["name"]}})

({{RemoveProperty[{obj,itemspec}]}})

({{RemoveProperty[{obj,itemspec},name]}})

({{RemoveScheduledTask[obj]}})

({{RemoveUsers[group,{(Subscript[user, 1]),…}]}})

({{RenameDirectory["(Subscript[dir, 1])","(Subscript[dir, 2])"]}})

({{RenewalProcess[rdist]}})

({{Repeated[p]}})

({{Repeated[p,max]}})

({{Repeated[p,{min,max}]}})

({{Repeated[p,{n}]}})

({{RepeatedNull[p]}})

({{RepeatedNull[p,max]}})

({{RepeatedNull[p,{min,max}]}})

({{RepeatedTiming[expr]}})

({{RepeatedTiming[expr,t]}})

({{ReplaceAll[rules]}})

({{ReplaceList[expr,rules]}})

({{ReplaceList[expr,rules,n]}})

({{ReplacePixelValue[image,ppos->val]}})

({{ReplacePixelValue[image,ppos->val,"type"]}})

({{ResamplingAlgorithmData[rs,"prop"]}})

({{Rescale[x,{min,max}]}})

({{Rescale[x,{min,max},{(Subscript[x, min]),(Subscript[x, max])}]}})

({{Rescale[list]}})

({{RescalingTransform[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…},{{(Subscript[xp, min]),(Subscript[xp, max])},…}]}})

({{RescalingTransform[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…}]}})

({{ResetDirectory[]}})

({{ResourceRemove[resource]}})

({{ResponseForm[expr,"fmt"]}})

({{ResponseForm[expr,"fmt",{"(Subscript[elem, 1])","(Subscript[elem, 2])",…}]}})

({{Rest[expr]}})

({{Restricted[form,cond,…]}})

({{ResumePacket[]}})

({{Return[expr]}})

({{Return[]}})

({{ReturnExpressionPacket[expr]}})

({{ReturnPacket[expr]}})

({{ReturnTextPacket[string]}})

({{Reverse[expr]}})

({{Reverse[expr,n]}})

({{Reverse[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{ReverseBiorthogonalSplineWavelet[]}})

({{ReverseBiorthogonalSplineWavelet[n,m]}})

({{ReverseElement[x,y,…]}})

({{ReverseEquilibrium[x,y,…]}})

({{ReverseSort[list]}})

({{ReverseSort[list,p]}})

({{ReverseUpEquilibrium[x,y,…]}})

({{RGBColor[red,green,blue]}})

({{RGBColor[r,g,b,a]}})

({{RGBColor["string"]}})

({{RiceDistribution[α,β]}})

({{RiceDistribution[m,α,β]}})

({{RiemannR[x]}})

({{RiemannSiegelTheta[t]}})

({{RiemannSiegelZ[t]}})

({{RiemannXi[s]}})

({{Riffle[{(Subscript[e, 1]),(Subscript[e, 2]),…},x]}})

({{Riffle[{(Subscript[e, 1]),(Subscript[e, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Riffle[list,x,n]}})

({{Riffle[list,x,{(Subscript[i, min]),(Subscript[i, max]),n}]}})

({{RightArrow[x,y,…]}})

({{RightArrowBar[x,y,…]}})

({{RightArrowLeftArrow[x,y,…]}})

({{RightComposition[(Subscript[f, 1]),(Subscript[f, 2]),(Subscript[f, 3]),…]}})

({{RightDownTeeVector[x,y,…]}})

({{RightDownVector[x,y,…]}})

({{RightDownVectorBar[x,y,…]}})

({{RightTee[x,y]}})

({{RightTeeArrow[x,y,…]}})

({{RightTeeVector[x,y,…]}})

({{RightTriangle[x,y,…]}})

({{RightTriangleBar[x,y,…]}})

({{RightTriangleEqual[x,y,…]}})

({{RightUpDownVector[x,y,…]}})

({{RightUpTeeVector[x,y,…]}})

({{RightUpVector[x,y,…]}})

({{RightUpVectorBar[x,y,…]}})

({{RightVector[x,y,…]}})

({{RightVectorBar[x,y,…]}})

({{RiskAchievementImportance[rdist,t]}})

({{RiskAchievementImportance[fdist,t]}})

({{RiskReductionImportance[rdist,t]}})

({{RiskReductionImportance[fdist,t]}})

({{RogersTanimotoDissimilarity[u,v]}})

({{RollPitchYawAngles[r]}})

({{RollPitchYawAngles[r,{a,b,c}]}})

({{RollPitchYawMatrix[{α,β,γ}]}})

({{RollPitchYawMatrix[{α,β,γ},{a,b,c}]}})

({{RomanNumeral[n]}})

({{RootIntervals[{(Subscript[poly, 1]),(Subscript[poly, 2]),…}]}})

({{RootIntervals[poly]}})

({{RootIntervals[polys,Complexes]}})

({{RootMeanSquare[list]}})

({{RootMeanSquare[dist]}})

({{RootOfUnityQ[a]}})

({{RootSum[f,form]}})

({{RotateLeft[expr,n]}})

({{RotateLeft[expr]}})

({{RotateLeft[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RotateRight[expr,n]}})

({{RotateRight[expr]}})

({{RotateRight[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RotationMatrix[θ]}})

({{RotationMatrix[θ,w]}})

({{RotationMatrix[{u,v}]}})

({{RotationMatrix[θ,{u,v}]}})

({{RotationTransform[θ]}})

({{RotationTransform[θ,p]}})

({{RotationTransform[θ,w]}})

({{RotationTransform[θ,w,p]}})

({{RotationTransform[{u,v}]}})

({{RotationTransform[{u,v},p]}})

({{RotationTransform[θ,{u,v},…]}})

({{Round[x]}})

({{Round[x,a]}})

({{RowBox[{(Subscript[box, 1]),(Subscript[box, 2]),…}]}})

({{RudvalisGroupRu[]}})

({{Run["command"]}})

({{RunProcess["command"]}})

({{RunProcess[{"command",(Subscript[arg, 1]),(Subscript[arg, 2]),…}]}})

({{RunProcess[command,"prop"]}})

({{RunProcess[command,prop,input]}})

({{RunThrough["command",expr]}})

({{RussellRaoDissimilarity[u,v]}})

({{SampledSoundFunction[f,n,r]}})

({{SampledSoundList[{(Subscript[a, 1]),(Subscript[a, 2]),…},r]}})

({{SARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},{s,{(Subscript[α, 1]),…,(Subscript[α, m])},δ,{(Subscript[β, 1]),…,(Subscript[β, r])}},v]}})

({{SARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},{s,{(Subscript[α, 1]),…,(Subscript[α, m])},δ,{(Subscript[β, 1]),…,(Subscript[β, r])}},Σ]}})

({{SARIMAProcess[{(Subscript[a, 1]),…},{(Subscript[d, 1]),…},{(Subscript[b, 1]),…},{{(Subscript[s, 1]),…},{(Subscript[α, 1]),…},{(Subscript[δ, 1]),…},{(Subscript[β, 1]),…}},Σ]}})

({{SARIMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},d,{(Subscript[b, 1]),…,(Subscript[b, q])},{s,{(Subscript[α, 1]),…,(Subscript[α, m])},δ,{(Subscript[β, 1]),…,(Subscript[β, r])}},v,init]}})

({{SARIMAProcess[c,…]}})

({{SARMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},{s,{(Subscript[α, 1]),…,(Subscript[α, m])},{(Subscript[β, 1]),…,(Subscript[β, r])}},v]}})

({{SARMAProcess[{(Subscript[a, 1]),…,(Subscript[a, p])},{(Subscript[b, 1]),…,(Subscript[b, q])},{{(Subscript[s, 1]),…},{(Subscript[α, 1]),…,(Subscript[α, m])},{(Subscript[β, 1]),…,(Subscript[β, r])}},Σ]}})

({{SARMAProcess[c,…]}})

({{SASTriangle[a,γ,b]}})

({{SatelliteData[entity,property]}})

({{SatelliteData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SatelliteData[entity,property,annotation]}})

({{SatisfiabilityCount[bf]}})

({{SatisfiabilityCount[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{Save["filename",symbol]}})

({{Save["filename","patt"]}})

({{Save["filename","context`"]}})

({{Save["filename",{(Subscript[object, 1]),(Subscript[object, 2]),…}]}})

({{SawtoothWave[x]}})

({{SawtoothWave[{min,max},x]}})

({{Scale[g,s]}})

({{Scale[g,s,{x,y,…}]}})

({{Scale[g,{(Subscript[s, x]),(Subscript[s, y]),…},…]}})

({{Scaled[{x,y,…}]}})

({{Scaled[{dx,dy,…},{(Subscript[x, 0]),(Subscript[y, 0]),…}]}})

({{ScalingMatrix[{(Subscript[s, x]),(Subscript[s, y]),…}]}})

({{ScalingMatrix[s,v]}})

({{ScalingTransform[{(Subscript[s, x]),(Subscript[s, y]),…}]}})

({{ScalingTransform[{(Subscript[s, x]),(Subscript[s, y]),…},p]}})

({{ScalingTransform[s,v]}})

({{ScalingTransform[s,v,p]}})

({{ScheduledTaskActiveQ[obj]}})

({{ScheduledTaskInformation[cloudobj]}})

({{ScheduledTaskInformation[cloudobj,property]}})

({{ScheduledTaskObject[id,expr,spec,…]}})

({{ScorerGi[z]}})

({{ScorerGiPrime[z]}})

({{ScorerHi[z]}})

({{ScorerHiPrime[z]}})

({{SearchIndexObject[loc]}})

({{SearchIndices[]}})

({{SearchQueryString["query"]}})

({{SearchResultObject[…]}})

({{Sec[z]}})

({{Sech[z]}})

({{SechDistribution[μ,σ]}})

({{SechDistribution[]}})

({{SecuredAuthenticationKey[assoc]}})

({{Select[list,crit]}})

({{Select[list,crit,n]}})

({{Select[crit]}})

({{SelectedNotebook[]}})

({{SelectFirst[{(Subscript[e, 1]),(Subscript[e, 2]),…},crit]}})

({{SelectFirst[{(Subscript[e, 1]),(Subscript[e, 2]),…},crit,default]}})

({{SelectFirst[crit]}})

({{SelectionCreateCell[notebook]}})

({{SelectionCreateCell[notebook,sel]}})

({{SelectionEvaluate[notebook]}})

({{SelectionEvaluate[notebook,sel]}})

({{SelectionEvaluateCreateCell[notebook]}})

({{SelectionEvaluateCreateCell[notebook,sel]}})

({{SemialgebraicComponentInstances[ineqs,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{SendMessage[channel,message]}})

({{SendMessage[channel->dest,message]}})

({{Sequence[(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{SequenceFold[f,{(Subscript[x, 1]),…,(Subscript[x, n])},{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{SequenceFold[f,{(Subscript[x, 1]),…,(Subscript[x, n])},{(Subscript[a, 1]),(Subscript[a, 2]),…},k]}})

({{SequenceFoldList[f,{(Subscript[x, 1]),…,(Subscript[x, n])},{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{SequenceFoldList[f,{(Subscript[x, 1]),…,(Subscript[x, n])},{(Subscript[a, 1]),(Subscript[a, 2]),…},k]}})

({{SequenceForm[(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{SequenceLimit[list]}})

({{SequenceReplace[list,rules]}})

({{SequenceReplace[list,rules,n]}})

({{SequenceReplace[rules]}})

({{SequenceSplit[list,patt]}})

({{SequenceSplit[list,{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{SequenceSplit[list,patt->rhs]}})

({{SequenceSplit[list,{(Subscript[patt, 1])->(Subscript[rhs, 1]),…}]}})

({{SequenceSplit[list,patt,n]}})

({{SeriesData[x,(Subscript[x, 0]),{(Subscript[a, 0]),(Subscript[a, 1]),…},(Subscript[n, min]),(Subscript[n, max]),den]}})

({{ServiceDisconnect[service]}})

({{ServiceExecute[service,"req"]}})

({{ServiceExecute[service,"req",{(Subscript[par, 1])->(Subscript[val, 1]),…}]}})

({{ServiceObject["service",…]}})

({{SessionTime[]}})

({{SetAccuracy[expr,a]}})

({{SetAlphaChannel[image]}})

({{SetAlphaChannel[image,a]}})

({{SetAlphaChannel[image,aimage]}})

({{SetAttributes[s,attr]}})

({{SetCloudDirectory[dir]}})

({{SetCloudDirectory[]}})

({{SetCookies[assoc]}})

({{SetCookies[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{SetDirectory["dir"]}})

({{SetDirectory[]}})

({{SetEnvironment["var"->value]}})

({{SetEnvironment[{"var"->value,…}]}})

({{SetFileDate["file"]}})

({{SetOptions[s,(Subscript[name, 1])->(Subscript[value, 1]),(Subscript[name, 2])->(Subscript[value, 2]),…]}})

({{SetOptions[stream,…]}})

({{SetOptions["name",…]}})

({{SetOptions[object,…]}})

({{SetPermissions[obj,"pstring"]}})

({{SetPermissions[obj,class->per]}})

({{SetPermissions[pers]}})

({{SetPrecision[expr,p]}})

({{SetProperty[{obj,itemspec},name->value]}})

({{SetSelectedNotebook[notebook]}})

({{SetSharedFunction[(Subscript[f, 1]),(Subscript[f, 2]),…]}})

({{SetSharedVariable[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{SetStreamPosition[stream,n]}})

({{SetSystemModel[model,spec]}})

({{SetSystemOptions["name"->value]}})

({{Setting[expr]}})

({{SetUsers[group,{(Subscript[user, 1]),…}]}})

({{Shallow[expr]}})

({{Shallow[expr,depth]}})

({{Shallow[expr,{depth,length}]}})

({{Shallow[expr,{depth,length},form]}})

({{ShannonWavelet[]}})

({{ShannonWavelet[lim]}})

({{Share[expr]}})

({{Share[]}})

({{Sharpen[image]}})

({{Sharpen[image,r]}})

({{ShearingMatrix[θ,v,n]}})

({{ShearingTransform[θ,v,n]}})

({{ShearingTransform[θ,v,n,p]}})

({{ShellRegion[reg]}})

({{ShellRegion[reg,t]}})

({{ShiftedGompertzDistribution[λ,ξ]}})

({{Short[expr]}})

({{Short[expr,n]}})

({{ShortDownArrow[x,y,…]}})

({{Shortest[p]}})

({{ShortestMatch[p]}})

({{ShortestPathFunction[type,data]}})

({{ShortLeftArrow[x,y,…]}})

({{ShortRightArrow[x,y,…]}})

({{ShortUpArrow[x,y,…]}})

({{Show[graphics,options]}})

({{Show[(Subscript[g, 1]),(Subscript[g, 2]),…]}})

({{SiderealTime[]}})

({{SiderealTime[date]}})

({{SiderealTime[loc]}})

({{SiderealTime[loc,date]}})

({{SiderealTime[{{(Subscript[loc, 1]),(Subscript[date, 1])},{(Subscript[loc, 2]),(Subscript[date, 2])},…}]}})

({{SiderealTime[loc,date,func]}})

({{SiegelTheta[Ω,s]}})

({{SiegelTheta[{(Subscript[ν, 1]),(Subscript[ν, 2])},Ω,s]}})

({{Sign[x]}})

({{Signature[list]}})

({{SignedRegionDistance[reg,p]}})

({{SignedRegionDistance[reg]}})

({{SimpleGraphQ[g]}})

({{Sin[z]}})

({{Sinc[z]}})

({{SinghMaddalaDistribution[q,a,b]}})

({{Sinh[z]}})

({{SinhIntegral[z]}})

({{SinIntegral[z]}})

({{SixJSymbol[{(Subscript[j, 1]),(Subscript[j, 2]),(Subscript[j, 3])},{(Subscript[j, 4]),(Subscript[j, 5]),(Subscript[j, 6])}]}})

({{Skeleton[n]}})

({{SkellamDistribution[(Subscript[μ, 1]),(Subscript[μ, 2])]}})

({{Skewness[list]}})

({{Skewness[dist]}})

({{SkewNormalDistribution[μ,σ,α]}})

({{SliceDistribution[proc,t]}})

({{SliceDistribution[proc,{(Subscript[t, 1]),…,(Subscript[t, k])}]}})

({{SmallCircle[x,y,…]}})

({{SmithDecomposition[m]}})

({{SocialMediaData["name"]}})

({{SocialMediaData["name","property"]}})

({{SocialMediaData[{"name",id},"property"]}})

({{SocketConnect[address]}})

({{SocketConnect[address,"protocol"]}})

({{SocketConnect[socket]}})

({{SocketListener[…]}})

({{SocketObject[…]}})

({{SocketOpen[port]}})

({{SocketOpen[address]}})

({{SocketOpen[address,"protocol"]}})

({{SocketReadyQ[socket]}})

({{SocketReadyQ[socket,t]}})

({{Sockets[]}})

({{Sockets[All]}})

({{Sockets[spec]}})

({{SocketWaitAll[{(Subscript[socket, 1]),(Subscript[socket, 2]),…}]}})

({{SocketWaitNext[{(Subscript[socket, 1]),(Subscript[socket, 2]),…}]}})

({{SokalSneathDissimilarity[u,v]}})

({{SolarSystemFeatureData[entity,property]}})

({{SolarSystemFeatureData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SolarSystemFeatureData[entity,property,annotation]}})

({{SolidData[entity,property]}})

({{SolidData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SolidData[entity,property,annotation]}})

({{SolidRegionQ[reg]}})

({{Sort[list]}})

({{Sort[list,p]}})

({{SortBy[list,f]}})

({{SortBy[f]}})

({{Sow[e]}})

({{Sow[e,tag]}})

({{Sow[e,{(Subscript[tag, 1]),(Subscript[tag, 2]),…}]}})

({{SpaceCurveData[entity,property]}})

({{SpaceCurveData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SpaceCurveData[entity,property,annotation]}})

({{SpaceForm[n]}})

({{Spacer[w]}})

({{Spacer[{w,h}]}})

({{Spacer[{w,h,dh}]}})

({{SparseArray[{(Subscript[pos, 1])->(Subscript[val, 1]),(Subscript[pos, 2])->(Subscript[val, 2]),…}]}})

({{SparseArray[{(Subscript[pos, 1]),(Subscript[pos, 2]),…}->{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{SparseArray[list]}})

({{SparseArray[data,{(Subscript[d, 1]),(Subscript[d, 2]),…}]}})

({{SparseArray[data,dims,val]}})

({{SpearmanRho[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{SpearmanRho[m]}})

({{SpearmanRho[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{SpearmanRho[dist]}})

({{SpearmanRho[dist,i,j]}})

({{SpeciesData[name,property]}})

({{SpeciesData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SpeciesData[entity,property,annotation]}})

({{SpectralLineData[entity]}})

({{SpectralLineData[entity,property]}})

({{SpectralLineData[quantity]}})

({{SpectralLineData[class,quantity]}})

({{SpectralLineData[spec,{(Subscript[quantity, 1]),(Subscript[quantity, 2])}]}})

({{Specularity[s]}})

({{Specularity[s,n]}})

({{Sphere[p]}})

({{Sphere[p,r]}})

({{Sphere[{(Subscript[p, 1]),(Subscript[p, 2]),…},r]}})

({{SpherePoints[n]}})

({{SphericalBesselJ[n,z]}})

({{SphericalBesselY[n,z]}})

({{SphericalHankelH1[n,z]}})

({{SphericalHankelH2[n,z]}})

({{SphericalHarmonicY[l,m,θ,ϕ]}})

({{SphericalShell[c,{(Subscript[r, inner]),(Subscript[r, outer])}]}})

({{SpheroidalEigenvalue[n,m,γ]}})

({{SpheroidalJoiningFactor[n,m,γ]}})

({{SpheroidalPS[n,m,γ,z]}})

({{SpheroidalPSPrime[n,m,γ,z]}})

({{SpheroidalQS[n,m,γ,z]}})

({{SpheroidalQSPrime[n,m,γ,z]}})

({{SpheroidalRadialFactor[n,m,c]}})

({{SpheroidalS1[n,m,γ,z]}})

({{SpheroidalS1Prime[n,m,γ,z]}})

({{SpheroidalS2[n,m,γ,z]}})

({{SpheroidalS2Prime[n,m,γ,z]}})

({{SplicedDistribution[{(Subscript[w, 1]),(Subscript[w, 2]),…,(Subscript[w, n])},{(Subscript[c, 0]),(Subscript[c, 1]),…,(Subscript[c, n])},{(Subscript[dist, 1,])(Subscript[dist, 2]),…,(Subscript[dist, n])}]}})

({{Split[list]}})

({{Split[list,test]}})

({{SplitBy[list,f]}})

({{SplitBy[list,{(Subscript[f, 1]),(Subscript[f, 2]),…}]}})

({{Sqrt[z]}})

({{Square[x]}})

({{SquaredEuclideanDistance[u,v]}})

({{SquareIntersection[x,y,…]}})

({{SquareMatrixQ[m]}})

({{SquareRepeatingElement[spec]}})

({{SquareRepeatingElement[spec,max]}})

({{SquareRepeatingElement[spec,{min,max}]}})

({{SquaresR[d,n]}})

({{SquareSubset[x,y,…]}})

({{SquareSubsetEqual[x,y,…]}})

({{SquareSuperset[x,y,…]}})

({{SquareSupersetEqual[x,y,…]}})

({{SquareUnion[x,y,…]}})

({{SquareWave[x]}})

({{SquareWave[{(Subscript[y, 1]),(Subscript[y, 2])},x]}})

({{SSSTriangle[a,b,c]}})

({{StableDistribution[type,α,β,μ,σ]}})

({{Stack[]}})

({{Stack[pattern]}})

({{StackBegin[expr]}})

({{StackComplete[expr]}})

({{StackInhibit[expr]}})

({{StadiumShape[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])}},r]}})

({{StandardDeviation[list]}})

({{StandardDeviation[dist]}})

({{StandardDeviationFilter[data,r]}})

({{StandardDeviationFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{StandardForm[expr]}})

({{Standardize[list]}})

({{Standardize[list,(Subscript[f, 1])]}})

({{Standardize[list,(Subscript[f, 1]),(Subscript[f, 2])]}})

({{StandardOceanData[spec]}})

({{StandardOceanData[spec,property]}})

({{StandbyDistribution[(Subscript[dist, 1]),{(Subscript[dist, 2]),…,(Subscript[dist, n])}]}})

({{StandbyDistribution[(Subscript[dist, 1]),{(Subscript[dist, 2]),…,(Subscript[dist, n])},p]}})

({{StandbyDistribution[(Subscript[dist, 1]),{(Subscript[dist, 2]),…,(Subscript[dist, n])},sdist]}})

({{StandbyDistribution[(Subscript[dist, 1]),{…,{(Subscript[dist, i,inactive]),(Subscript[dist, i,active])},…},…]}})

({{Star[x,y,…]}})

({{StarClusterData[entity,property]}})

({{StarClusterData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{StarClusterData[entity,property,annotation]}})

({{StarData[entity,property]}})

({{StarData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{StarData[entity,property,annotation]}})

({{StartAsynchronousTask[task]}})

({{StartExternalSession["sys"]}})

({{StartExternalSession[{"sys",opts}]}})

({{StartExternalSession[assoc]}})

({{StartExternalSession[sys->type]}})

({{StartScheduledTask[obj]}})

({{StateResponse[sys,u,{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{StateResponse[sys,{u[0],u[1],…}]}})

({{StateResponse[sys,u,t]}})

({{StateResponse[sys,{(Subscript[u, 1]),…,(Subscript[u, m])},…]}})

({{StateResponse[{sys,{(Subscript[x, 10]),(Subscript[x, 20]),…,(Subscript[(Subscript[x, n]), 0])}},…, …]}})

({{StationaryDistribution[proc]}})

({{StatusArea[expr,string]}})

({{StieltjesGamma[n]}})

({{StieltjesGamma[n,a]}})

({{StirlingS1[n,m]}})

({{StirlingS2[n,m]}})

({{StopAsynchronousTask[task]}})

({{StoppingPowerData[entity,{"Particle"->particle,"Energy"->quantity},property]}})

({{StopScheduledTask[obj]}})

({{StreamPosition[stream]}})

({{Streams[]}})

({{Streams["name"]}})

({{StringByteCount["string"]}})

({{StringDrop["string",n]}})

({{StringDrop["string",-n]}})

({{StringDrop["string",{n}]}})

({{StringDrop["string",{m,n}]}})

({{StringDrop[{(Subscript[s, 1]),(Subscript[s, 2]),…},spec]}})

({{StringExpression[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{StringExtract["string",n]}})

({{StringExtract["string",{(Subscript[pos, 1]),(Subscript[pos, 2]),…}]}})

({{StringExtract["string",sep->pos]}})

({{StringExtract["string",(Subscript[pos, 1]),(Subscript[pos, 2]),…]}})

({{StringExtract["string",(Subscript[sep, 1])->(Subscript[pos, 1]),(Subscript[sep, 2])->(Subscript[pos, 2]),…]}})

({{StringForm["controlstring",(Subscript[expr, 1]),…]}})

({{StringFormat["string"]}})

({{StringInsert["string","snew",n]}})

({{StringInsert["string","snew",-n]}})

({{StringInsert["string","snew",{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{StringInsert[{(Subscript[s, 1]),(Subscript[s, 2]),…},"snew",n]}})

({{StringJoin["(Subscript[s, 1])","(Subscript[s, 2])",…]}})

({{StringJoin[{"(Subscript[s, 1])","(Subscript[s, 2])",…}]}})

({{StringLength["string"]}})

({{StringPadLeft["string",n]}})

({{StringPadLeft["string",n,"padding"]}})

({{StringPadLeft[{"(Subscript[s, 1])","(Subscript[s, 2])",…}]}})

({{StringPadLeft[{"(Subscript[s, 1])","(Subscript[s, 2])",…},n,…]}})

({{StringPadRight["string",n]}})

({{StringPadRight["string",n,"padding"]}})

({{StringPadRight[{"(Subscript[s, 1])","(Subscript[s, 2])",…}]}})

({{StringPadRight[{"(Subscript[s, 1])","(Subscript[s, 2])",…},n,…]}})

({{StringPart["string",n]}})

({{StringPart["string",{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{StringPart["string",m;;n;;s]}})

({{StringPart[{(Subscript[s, 1]),(Subscript[s, 2]),…},spec]}})

({{StringPartition["string",n]}})

({{StringPartition["string",n,d]}})

({{StringQ[expr]}})

({{StringRepeat["str",n]}})

({{StringRepeat["str",n,max]}})

({{StringReplacePart["string","snew",{m,n}]}})

({{StringReplacePart["string","snew",{{(Subscript[m, 1]),(Subscript[n, 1])},{(Subscript[m, 2]),(Subscript[n, 2])},…}]}})

({{StringReplacePart["string",{"(Subscript[snew, 1])","(Subscript[snew, 2])",…},{{(Subscript[m, 1]),(Subscript[n, 1])},{(Subscript[m, 2]),(Subscript[n, 2])},…}]}})

({{StringReplacePart["snew",{m,n}]}})

({{StringReverse["string"]}})

({{StringRiffle[{(Subscript[s, 1]),(Subscript[s, 2]),(Subscript[s, 3]),…}]}})

({{StringRiffle[{{(Subscript[s, 11]),(Subscript[s, 12]),…},{(Subscript[s, 21]),(Subscript[s, 22]),…},…}]}})

({{StringRiffle[list,sep]}})

({{StringRiffle[list,{"left","sep","right"}]}})

({{StringRiffle[list,(Subscript[sep, 1]),(Subscript[sep, 2]),…]}})

({{StringRotateLeft[string,n]}})

({{StringRotateLeft[string]}})

({{StringRotateRight[string,n]}})

({{StringRotateRight[string]}})

({{StringSkeleton[n]}})

({{StringSplit["string"]}})

({{StringSplit["string",patt]}})

({{StringSplit["string",{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{StringSplit["string",patt->val]}})

({{StringSplit["string",{(Subscript[p, 1])->(Subscript[v, 1]),…}]}})

({{StringSplit["string",patt,n]}})

({{StringSplit[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringTake["string",n]}})

({{StringTake["string",-n]}})

({{StringTake["string",{n}]}})

({{StringTake["string",{m,n}]}})

({{StringTake["string",{(Subscript[spec, 1]),(Subscript[spec, 2]),…}]}})

({{StringTake[{(Subscript[s, 1]),(Subscript[s, 2]),…},spec]}})

({{StringToByteArray["string"]}})

({{StringToByteArray["string","encoding"]}})

({{StringToStream["string"]}})

({{StripBoxes[expr]}})

({{StructuralImportance[rdist]}})

({{StructuralImportance[fdist]}})

({{StructuralImportance[bexpr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{StructuredArray[st,{(Subscript[d, 1]),(Subscript[d, 2]),…},data]}})

({{StruveH[n,z]}})

({{StruveL[n,z]}})

({{StudentTDistribution[ν]}})

({{StudentTDistribution[μ,σ,ν]}})

({{StyleData["style"]}})

({{StyleData["style","environment"]}})

({{StyleForm[expr,options]}})

({{StyleForm[expr,"style"]}})

({{StylePrint[expr,"style"]}})

({{StylePrint[expr]}})

({{Subdivide[n]}})

({{Subdivide[(Subscript[x, max]),n]}})

({{Subdivide[(Subscript[x, min]),(Subscript[x, max]),n]}})

({{Subfactorial[n]}})

({{SubMinus[expr]}})

({{SubPlus[expr]}})

({{Subscript[x,y]}})

({{Subscript[x,(Subscript[y, 1]),(Subscript[y, 2]),…]}})

({{Subsequences[list]}})

({{Subsequences[list,n]}})

({{Subsequences[list,{n}]}})

({{Subsequences[list,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{Subsequences[list,nspec,s]}})

({{Subsequences[list,nspec,{s}]}})

({{Subset[x,y,…]}})

({{SubsetEqual[x,y,…]}})

({{SubsetQ[(Subscript[list, 1]),(Subscript[list, 2])]}})

({{Subsets[list]}})

({{Subsets[list,n]}})

({{Subsets[list,{n}]}})

({{Subsets[list,{(Subscript[n, min]),(Subscript[n, max])}]}})

({{Subsets[list,nspec,s]}})

({{Subsets[list,nspec,{s}]}})

({{SubStar[expr]}})

({{SubstitutionSystem[rule,init,t]}})

({{SubstitutionSystem[rule,init]}})

({{SubstitutionSystem[rule]}})

({{Subsuperscript[x,y,z]}})

({{SubtractSides[rel,x]}})

({{SubtractSides[(Subscript[rel, 1]),(Subscript[rel, 2])]}})

({{SubtractSides[rel]}})

({{Succeeds[x,y,…]}})

({{SucceedsEqual[x,y,…]}})

({{SucceedsSlantEqual[x,y,…]}})

({{SucceedsTilde[x,y,…]}})

({{Success["tag",assoc]}})

({{SuchThat[x,y]}})

({{SuperDagger[expr]}})

({{SuperMinus[expr]}})

({{SupernovaData[entity,property]}})

({{SupernovaData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SupernovaData[entity,property,annotation]}})

({{SuperPlus[expr]}})

({{Superscript[x,y]}})

({{Superset[x,y,…]}})

({{SupersetEqual[x,y,…]}})

({{SuperStar[expr]}})

({{Surd[x,n]}})

({{SurfaceColor[dcol]}})

({{SurfaceColor[dcol,scol]}})

({{SurfaceColor[dcol,{scol,n}]}})

({{SurfaceColor[dcol,scol,gcol]}})

({{SurfaceData[entity,property]}})

({{SurfaceData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{SurfaceData[entity, property, annotation]}})

({{SurvivalFunction[dist,x]}})

({{SurvivalFunction[dist,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{SurvivalFunction[dist]}})

({{SuspendPacket[]}})

({{SuzukiDistribution[μ,ν]}})

({{SuzukiGroupSuz[]}})

({{Switch[expr,(Subscript[form, 1]),(Subscript[value, 1]),(Subscript[form, 2]),(Subscript[value, 2]),…]}})

({{Symbol["name"]}})

({{SymbolName[symbol]}})

({{SymletWavelet[]}})

({{SymletWavelet[n]}})

({{Symmetric[{(Subscript[s, 1]),…,(Subscript[s, n])}]}})

({{SymmetricGroup[n]}})

({{SymmetricKey[assoc]}})

({{SymmetricPolynomial[k,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{SymmetricReduction[f,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{SymmetricReduction[f,{(Subscript[x, 1]),…,(Subscript[x, n])},{(Subscript[s, 1]),…,(Subscript[s, n])}]}})

({{Symmetrize[tensor,sym]}})

({{SymmetrizedArray[{(Subscript[pos, 1])->(Subscript[val, 1]),(Subscript[pos, 2])->(Subscript[val, 2]),…},dims,sym]}})

({{SymmetrizedArray[list]}})

({{SymmetrizedArrayRules[sa]}})

({{SymmetrizedArrayRules[a,sym]}})

({{SymmetrizedDependentComponents[comp,sym]}})

({{SymmetrizedIndependentComponents[dims,sym]}})

({{SymmetrizedReplacePart[sa,{(Subscript[pos, 1])->(Subscript[val, 1]),(Subscript[pos, 2])->(Subscript[val, 2]),…}]}})

({{SyntaxInformation[f]}})

({{SyntaxLength["string"]}})

({{SyntaxPacket[integer]}})

({{SyntaxQ["string"]}})

({{SyntaxQ["string"]}})

({{SyntaxQ["string",form]}})

({{SystemInformation[]}})

({{SystemInformation["comp"]}})

({{SystemInformation["comp","prop"]}})

({{SystemModeler[]}})

({{SystemModeler[model]}})

({{SystemModeler[simulation]}})

({{SystemModeler[…,"action"]}})

({{SystemModelExamples[]}})

({{SystemModelExamples["Models"]}})

({{SystemModelExamples["Models",patt]}})

({{SystemModelLinearize[model]}})

({{SystemModelLinearize[model,{{{(Subscript[x, 1]),(Subscript[x, 10])},…},{{(Subscript[u, 1]),(Subscript[u, 10])},…}}]}})

({{SystemModelParametricSimulate[model,v,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelParametricSimulate[model,{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelParametricSimulate[model,vars,(Subscript[t, max]),…]}})

({{SystemModelParametricSimulate[model,vars,{(Subscript[t, min]),(Subscript[t, max])},…]}})

({{SystemModelReliability[model]}})

({{SystemModelReliability[model,"Components"]}})

({{SystemModelReliability[model,"ComponentRules"]}})

({{SystemModels[]}})

({{SystemModels[patt]}})

({{SystemModels[patt,"spec"]}})

({{SystemModelSimulate[model]}})

({{SystemModelSimulate[model,(Subscript[t, max])]}})

({{SystemModelSimulate[model,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{SystemModelSimulate[model,vars,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{SystemModelSimulateSensitivity[model,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelSimulateSensitivity[model,(Subscript[t, max]),{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelSimulateSensitivity[model,{(Subscript[t, min]),(Subscript[t, max])},{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelSimulateSensitivity[model,vars,{(Subscript[t, min]),(Subscript[t, max])},{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{SystemModelSimulationData[…]}})

({{SystemOptions["name"]}})

({{SystemOptions[]}})

({{SystemProcessData[]}})

({{SystemProcessData[All]}})

({{SystemProcessData[patt]}})

({{SystemProcessData[prop->val]}})

({{SystemProcessData[{(Subscript[prop, 1])->(Subscript[val, 1]),…}]}})

({{SystemsModelDelay[δ]}})

({{SystemsModelDelete[sys,{(Subscript[in, 1]),…}]}})

({{SystemsModelDelete[sys,{(Subscript[in, 1]),…},{(Subscript[out, 1]),…}]}})

({{SystemsModelDelete[sys,{(Subscript[in, 1]),…},{(Subscript[out, 1]),…},{(Subscript[s, 1]), (Subscript[s, 2]),…}]}})

({{SystemsModelDimensions[sys]}})

({{SystemsModelExtract[sys,{(Subscript[in, 1]),…}]}})

({{SystemsModelExtract[sys,{(Subscript[in, 1]),…},{(Subscript[out, 1]),…}]}})

({{SystemsModelExtract[sys,{(Subscript[in, 1]),…},{(Subscript[out, 1]),…},{(Subscript[s, 1]),…}]}})

({{SystemsModelFeedbackConnect[sys]}})

({{SystemsModelFeedbackConnect[sys,{(Subscript[con, 1]),…}]}})

({{SystemsModelFeedbackConnect[(Subscript[sys, 1]),(Subscript[sys, 2])]}})

({{SystemsModelFeedbackConnect[(Subscript[sys, 1]),(Subscript[sys, 2]),{(Subscript[out, 1]),…},{{(Subscript[in, 1]),(Subscript[ftype, 1])},…}]}})

({{SystemsModelLinearity[sys]}})

({{SystemsModelMerge[{(Subscript[sys, 1]),(Subscript[sys, 2]),…}]}})

({{SystemsModelOrder[sys]}})

({{SystemsModelParallelConnect[(Subscript[sys, 1]),(Subscript[sys, 2])]}})

({{SystemsModelParallelConnect[(Subscript[sys, 1]),(Subscript[sys, 2]),{{(Subscript[in, 11]),(Subscript[in, 21])},…},{{(Subscript[out, 11]),(Subscript[out, 21])},…}]}})

({{SystemsModelSeriesConnect[(Subscript[sys, 1]),(Subscript[sys, 2])]}})

({{SystemsModelSeriesConnect[(Subscript[sys, 1]),(Subscript[sys, 2]),{{(Subscript[out, 11]),(Subscript[in, 21])},…}]}})

({{SystemsModelStateFeedbackConnect[sys,con]}})

({{SystemsModelStateFeedbackConnect[sys,con,{(Subscript[s, 1]),…},{{(Subscript[in, 1]),(Subscript[ftype, 1])},…}]}})

({{Take[list,n]}})

({{Take[list,-n]}})

({{Take[list,{m,n}]}})

({{Take[list,(Subscript[seq, 1]),(Subscript[seq, 2]),…]}})

({{TakeDrop[list,n]}})

({{TakeDrop[list,seq]}})

({{TakeList[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{TakeList[list,{(Subscript[seq, 1]),(Subscript[seq, 2]),…}]}})

({{TakeList[list,(Subscript[seqs, 1]),(Subscript[seqs, 2]),…]}})

({{TakeWhile[list,crit]}})

({{Tally[list]}})

({{Tally[list,test]}})

({{Tan[z]}})

({{Tanh[z]}})

({{TaskAbort[task]}})

({{TaskExecute[task]}})

({{TaskObject[spec]}})

({{TaskRemove[task]}})

({{TaskResume[task]}})

({{Tasks[]}})

({{TaskSuspend[task]}})

({{TelegraphProcess[μ]}})

({{TemplateWith["name"->value,expr]}})

({{TemplateWith[{"(Subscript[name, 1])"->(Subscript[value, 1]),"(Subscript[name, 2])"->(Subscript[value, 2]), …},expr]}})

({{TensorContract[tensor,{{(Subscript[s, 11]),(Subscript[s, 12])},{(Subscript[s, 21]),(Subscript[s, 22])},…}]}})

({{TensorProduct[(Subscript[tensor, 1]),(Subscript[tensor, 2]),…]}})

({{TensorTranspose[tensor,perm]}})

({{TensorWedge[(Subscript[tensor, 1]),(Subscript[tensor, 2]),…]}})

({{TestReportObject[…]}})

({{TestResultObject[…]}})

({{TeXForm[expr]}})

({{TeXSave["file.tex"]}})

({{TeXSave["file.tex","source.nb"]}})

({{TeXSave["file.tex",notebook]}})

({{TextData[exprs]}})

({{TextElement[text,props]}})

({{TextElement[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},props]}})

({{TextElement[elems]}})

({{TextPacket[string]}})

({{TextSentences["string"]}})

({{TextSentences["string",n]}})

({{TextStructure["text"]}})

({{TextStructure["text",form]}})

({{Texture[obj]}})

({{TextWords["string"]}})

({{TextWords["string",n]}})

({{Therefore[x,y]}})

({{ThermodynamicData["name","property"]}})

({{ThermodynamicData["name","property",{"Temperature"->(Subscript[quantity, 1]),"Pressure"->quantity}]}})

({{Thickness[r]}})

({{ThompsonGroupTh[]}})

({{Thread[f[args]]}})

({{Thread[f[args],h]}})

({{Thread[f[args],h,n]}})

({{ThreeJSymbol[{(Subscript[j, 1]),(Subscript[m, 1])},{(Subscript[j, 2]),(Subscript[m, 2])},{(Subscript[j, 3]),(Subscript[m, 3])}]}})

({{Threshold[data]}})

({{Threshold[data,tspec]}})

({{Threshold[image,…]}})

({{Threshold[sound,…]}})

({{Through[p[(Subscript[f, 1]),(Subscript[f, 2])][x]]}})

({{Through[expr,h]}})

({{Throw[value]}})

({{Throw[value,tag]}})

({{ThueMorse[n]}})

({{Tilde[x,y,…]}})

({{TildeEqual[x,y,…]}})

({{TildeFullEqual[x,y,…]}})

({{TildeTilde[x,y,…]}})

({{TimeConstrained[expr,t]}})

({{TimeConstrained[expr,t,failexpr]}})

({{TimeObjectQ[expr]}})

({{TimeSeriesAggregate[tseries,dt]}})

({{TimeSeriesAggregate[tseries,dt,f]}})

({{TimeSeriesInsert[tseries,{t,v}]}})

({{TimeSeriesInsert[(Subscript[tseries, 1]),(Subscript[tseries, 2])]}})

({{TimeSeriesInvertibility[tproc]}})

({{TimeSeriesMap[f,tseries]}})

({{TimeSeriesMapThread[f,tseries]}})

({{TimeSeriesMapThread[f,tseries,{{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},…}]}})

({{TimeSeriesRescale[tseries,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{TimeSeriesRescale[tseries,{(Subscript[t, min]),(Subscript[t, max]),(Subscript[t, u])}]}})

({{TimeUsed[]}})

({{TimeWarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{TimeWarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2]),r]}})

({{TimeWarpingDistance[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{TimeWarpingDistance[(Subscript[s, 1]),(Subscript[s, 2]),r]}})

({{TimeZoneConvert[time,timezone]}})

({{TimeZoneConvert[time]}})

({{TimeZoneConvert[{(Subscript[time, 1]),…,(Subscript[time, n])},timezone]}})

({{TimeZoneOffset[tz]}})

({{TimeZoneOffset[loc]}})

({{TimeZoneOffset[tz,base]}})

({{TimeZoneOffset[tz,base,date]}})

({{Timing[expr]}})

({{TitsGroupT[]}})

({{ToBoxes[expr]}})

({{ToBoxes[expr,form]}})

({{ToCharacterCode["string"]}})

({{ToCharacterCode["string","encoding"]}})

({{ToColor[color, form]}})

({{ToDate[time]}})

({{ToEntity[expr]}})

({{ToEntity[expr,type]}})

({{ToeplitzMatrix[n]}})

({{ToeplitzMatrix[{(Subscript[c, 1]),(Subscript[c, 2]),…,(Subscript[c, n])}]}})

({{ToeplitzMatrix[{(Subscript[c, 1]),(Subscript[c, 2]),…,(Subscript[c, m])},{(Subscript[r, 1]),(Subscript[r, 2]),…, (Subscript[r, n])}]}})

({{ToExpression[input]}})

({{ToExpression[input,form]}})

({{ToExpression[input,form,h]}})

({{ToFileName["directory","name"]}})

({{ToFileName[{(Subscript[dir, 1]),(Subscript[dir, 2]),…},name]}})

({{ToFileName[{(Subscript[dir, 1]),(Subscript[dir, 2]),…}]}})

({{ToInvertibleTimeSeries[tproc]}})

({{ToLowerCase[string]}})

({{ToNumberField[a,θ]}})

({{ToNumberField[{(Subscript[a, 1]),(Subscript[a, 2]),…},θ]}})

({{ToNumberField[{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{TopHatTransform[image,ker]}})

({{TopHatTransform[image,r]}})

({{TopHatTransform[data,…]}})

({{ToPolarCoordinates[{x,y}]}})

({{ToPolarCoordinates[{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])}]}})

({{TopologicalSort[g]}})

({{TopologicalSort[{v->w,…}]}})

({{ToRules[eqns]}})

({{ToSphericalCoordinates[{x,y,z}]}})

({{TouchPosition[]}})

({{TouchPosition["coords"]}})

({{TouchPosition["coords",n]}})

({{TouchPosition["coords",n,def]}})

({{ToUpperCase[string]}})

({{Tr[list]}})

({{Tr[list,f]}})

({{Tr[list,f,n]}})

({{TraceLevel[]}})

({{TracyWidomDistribution[β]}})

({{TransferFunctionExpand[tfm]}})

({{TransferFunctionFactor[tfm]}})

({{TransferFunctionPoles[tfm]}})

({{TransferFunctionPoles[tfm,reg]}})

({{TransferFunctionTransform[f,tf]}})

({{TransferFunctionZeros[tfm]}})

({{TransferFunctionZeros[tfm,reg]}})

({{TransformationFunction[data]}})

({{TransformationMatrix[tfun]}})

({{TransformedField[t,f,{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])}->{(Subscript[y, 1]),(Subscript[y, 2]),…,(Subscript[y, n])}]}})

({{Translate[g,{x,y,…}]}})

({{Translate[g,{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…}, …}]}})

({{TranslationTransform[v]}})

({{TreeGraphQ[g]}})

({{TriangleWave[x]}})

({{TriangleWave[{min,max},x]}})

({{TriangularDistribution[{min,max}]}})

({{TriangularDistribution[]}})

({{TriangularDistribution[{min,max},c]}})

({{TrigExpand[expr]}})

({{TrigFactor[expr]}})

({{TrigFactorList[expr]}})

({{TrigToExp[expr]}})

({{TrimmedMean[list,f]}})

({{TrimmedMean[list,{(Subscript[f, 1]),(Subscript[f, 2])}]}})

({{TrimmedMean[list]}})

({{TrimmedMean[list,0.05]}})

({{TrimmedMean[dist,…]}})

({{TrimmedVariance[list,f]}})

({{TrimmedVariance[list,{(Subscript[f, 1]),(Subscript[f, 2])}]}})

({{TrimmedVariance[list]}})

({{TrimmedVariance[list,0.05]}})

({{TrimmedVariance[dist,…]}})

({{TropicalStormData[entity,property]}})

({{TropicalStormData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{TropicalStormData[entity,property,annotation]}})

({{TrueQ[expr]}})

({{TruncatedDistribution[{(Subscript[x, min]),(Subscript[x, max])},dist]}})

({{TruncatedDistribution[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…},dist]}})

({{TsallisQExponentialDistribution[λ,q]}})

({{TsallisQGaussianDistribution[μ,β,q]}})

({{TsallisQGaussianDistribution[q]}})

({{TukeyLambdaDistribution[λ]}})

({{TukeyLambdaDistribution[λ,μ,σ]}})

({{TukeyLambdaDistribution[{(Subscript[λ, 1]),(Subscript[λ, 2])},μ,{(Subscript[σ, 1]),(Subscript[σ, 2])}]}})

({{TukeyWindow[x]}})

({{TukeyWindow[x,α]}})

({{TunnelData[entity,property]}})

({{TunnelData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{TunnelData[entity,property,annotation]}})

({{Tuples[list,n]}})

({{Tuples[{(Subscript[list, 1]),(Subscript[list, 2]),…}]}})

({{TuringMachine[rule,init,t]}})

({{TuringMachine[rule,init]}})

({{TuringMachine[rule]}})

({{TuttePolynomial[g,{x,y}]}})

({{TuttePolynomial[{v->w,…},…]}})

({{UnateQ[bexpr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{UnateQ[bexpr,{¬(Subscript[x, 1]),¬(Subscript[x, 2]),…}]}})

({{Uncompress["string"]}})

({{Uncompress["string",h]}})

({{UnderBar[expr]}})

({{Underflow[]}})

({{Underoverscript[x,y,z]}})

({{Underscript[x,y]}})

({{UnderseaFeatureData[entity,property]}})

({{UnderseaFeatureData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{UnderseaFeatureData["name","property",annotation]}})

({{UndirectedEdge[u,v]}})

({{UndirectedGraphQ[g]}})

({{UnequalTo[y]}})

({{Unevaluated[expr]}})

({{Unevaluated[expr]}})

({{UniformDistribution[{min,max}]}})

({{UniformDistribution[]}})

({{UniformDistribution[{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…}]}})

({{UniformDistribution[n]}})

({{UniformSumDistribution[n]}})

({{UniformSumDistribution[n,{min,max}]}})

({{Uninstall[link]}})

({{UnionPlus[x,y,…]}})

({{Unique[]}})

({{Unique[x]}})

({{Unique[{x,y,…}]}})

({{Unique["xxx"]}})

({{UnitBox[x]}})

({{UnitBox[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{UnitConvert[quantity,targetunit]}})

({{UnitConvert[quantity,unitsystem]}})

({{UnitDimensions[unit]}})

({{UnitDimensions[quantity]}})

({{Unitize[x]}})

({{UnitStep[x]}})

({{UnitStep[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{UnitTriangle[x]}})

({{UnitTriangle[(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{UniverseModelData[spec]}})

({{UniverseModelData[spec,model]}})

({{UniverseModelData[spec,property]}})

({{UniverseModelData[spec,property,model]}})

({{UniversityData[entity,property]}})

({{UniversityData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{UniversityData[entity,property,annotation]}})

({{UnixTime[]}})

({{UnixTime[{y,m,d,h,m,s}]}})

({{UnixTime[date]}})

({{UnixTime["string"]}})

({{UnixTime[{"string",{"(Subscript[e, 1])","(Subscript[e, 2])",…}}]}})

({{Unprotect[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{Unprotect["(Subscript[form, 1])","(Subscript[form, 2])",…]}})

({{UnregisterExternalEvaluator[sys,exec]}})

({{UnregisterExternalEvaluator[uuid]}})

({{UnsetShared[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{UnsetShared[patt]}})

({{UpArrow[x,y,…]}})

({{UpArrowBar[x,y,…]}})

({{UpArrowDownArrow[x,y,…]}})

({{Update[symbol]}})

({{Update[]}})

({{UpdateSearchIndex[index]}})

({{UpDownArrow[x,y,…]}})

({{UpEquilibrium[x,y,…]}})

({{UpperCaseQ[string]}})

({{UpperLeftArrow[x,y,…]}})

({{UpperRightArrow[x,y,…]}})

({{UpperTriangularize[m]}})

({{UpperTriangularize[m,k]}})

({{Upsample[array,n]}})

({{Upsample[array,n,offset]}})

({{Upsample[array,n,offset,val]}})

({{Upsample[image,…]}})

({{UpTee[x,y]}})

({{UpTeeArrow[x,y,…]}})

({{UpTo[n]}})

({{URL["url"]}})

({{URLDispatcher[{(Subscript[patt, 1]):>(Subscript[content, 1]),(Subscript[patt, 2]):>(Subscript[content, 2]),…}]}})

({{URLShorten["url"]}})

({{URLShorten[CloudObject[…]]}})

({{UsingFrontEnd[expr]}})

({{V2Get[name]}})

({{ValueQ[expr]}})

({{Values[\[LeftAssociation](Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…\[RightAssociation]]}})

({{Values[{(Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…}]}})

({{Variance[list]}})

({{Variance[dist]}})

({{VarianceGammaDistribution[λ,α,β,μ]}})

({{VectorAngle[u,v]}})

({{VectorQ[expr]}})

({{VectorQ[expr,test]}})

({{Vectors[d]}})

({{Vectors[d,dom]}})

({{Vee[x,y,…]}})

({{Verbatim[expr]}})

({{VertexAdd[g,v]}})

({{VertexAdd[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexAdd[{v->w,…},…]}})

({{VertexComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…},k]}})

({{VertexComponent[{v->w,…},…]}})

({{VertexConnectivity[g]}})

({{VertexConnectivity[g,s,t]}})

({{VertexConnectivity[{v->w,…},…]}})

({{VertexContract[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexContract[g,{{(Subscript[v, 1]),(Subscript[v, 2]),…},…}]}})

({{VertexContract[{v->w,…},…]}})

({{VertexCorrelationSimilarity[g,u,v]}})

({{VertexCorrelationSimilarity[{v->w,…},…]}})

({{VertexCosineSimilarity[g,u,v]}})

({{VertexCosineSimilarity[{v->w,…},…]}})

({{VertexCount[g]}})

({{VertexCount[g,patt]}})

({{VertexCount[{v->w,…},…]}})

({{VertexCoverQ[g,vlist]}})

({{VertexDegree[g]}})

({{VertexDegree[g,v]}})

({{VertexDegree[{v->w,…},…]}})

({{VertexDelete[g,v]}})

({{VertexDelete[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexDelete[g,patt]}})

({{VertexDelete[{v->w,…},…]}})

({{VertexDiceSimilarity[g,u,v]}})

({{VertexDiceSimilarity[{v->w,…},…]}})

({{VertexEccentricity[g,s]}})

({{VertexEccentricity[{v->w,…},…]}})

({{VertexInComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexInComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…},k]}})

({{VertexInComponent[{v->w,…},…]}})

({{VertexInDegree[g]}})

({{VertexInDegree[g,v]}})

({{VertexInDegree[{v->w,…},…]}})

({{VertexIndex[g,v]}})

({{VertexIndex[{v->w,…},…]}})

({{VertexJaccardSimilarity[g,u,v]}})

({{VertexJaccardSimilarity[{v->w,…},…]}})

({{VertexList[g]}})

({{VertexList[g,patt]}})

({{VertexList[{v->w,…},…]}})

({{VertexOutComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{VertexOutComponent[g,{(Subscript[v, 1]),(Subscript[v, 2]),…},k]}})

({{VertexOutComponent[{v->w,…},…]}})

({{VertexOutDegree[g]}})

({{VertexOutDegree[g,v]}})

({{VertexOutDegree[{v->w,…},…]}})

({{VertexQ[g,v]}})

({{VertexReplace[g,{(Subscript[v, 1])->(Subscript[w, 1]),(Subscript[v, 2])->(Subscript[w, 2]),…}]}})

({{VertexReplace[{v->w,…},…]}})

({{VerticalBar[x,y,…]}})

({{VerticalSeparator[x,y,…]}})

({{VerticalTilde[x,y,…]}})

({{VoigtDistribution[δ,σ]}})

({{VolcanoData[entity,property]}})

({{VolcanoData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{VolcanoData[entity,property,annotation]}})

({{VonMisesDistribution[μ,κ]}})

({{WaitAll[expr]}})

({{WaitNext[{(Subscript[eid, 1]),(Subscript[eid, 2]),…}]}})

({{WakebyDistribution[α,β,γ,δ,μ]}})

({{WalleniusHypergeometricDistribution[n,(Subscript[n, succ]),(Subscript[n, tot]),w]}})

({{WaringYuleDistribution[α]}})

({{WaringYuleDistribution[α,β]}})

({{WattsStrogatzGraphDistribution[n,p]}})

({{WattsStrogatzGraphDistribution[n,p,k]}})

({{WaveletMapIndexed[f,wd]}})

({{WaveletMapIndexed[f,dwd,wind]}})

({{WaveletMapIndexed[f,cwd,octvoc]}})

({{WaveletThreshold[dwd]}})

({{WaveletThreshold[dwd,tspec]}})

({{WaveletThreshold[dwd,tspec,wind]}})

({{WeaklyConnectedComponents[g]}})

({{WeaklyConnectedComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{WeaklyConnectedComponents[g,patt]}})

({{WeaklyConnectedComponents[{v->w,…},…]}})

({{WeaklyConnectedGraphQ[g]}})

({{WeakStationarity[proc]}})

({{WeatherData[loc,"property"]}})

({{WeatherData[loc,"property",date]}})

({{WeatherData[loc,"property",{start,end}]}})

({{WeatherData[loc,"property",{start,end,step}]}})

({{WeberE[ν,z]}})

({{WeberE[ν,μ,z]}})

({{Wedge[x,y,…]}})

({{WeibullDistribution[α,β]}})

({{WeibullDistribution[α,β,μ]}})

({{WeierstrassE1[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassE2[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassE3[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassEta1[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassEta2[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassEta3[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassHalfPeriods[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassHalfPeriodW1[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassHalfPeriodW2[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassHalfPeriodW3[{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassInvariantG2[{ω,ω'}]}})

({{WeierstrassInvariants[{(Subscript[ω, 1]),(Subscript[ω, 3])}]}})

({{WeierstrassP[u,{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassPPrime[u,{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassSigma[u,{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeierstrassZeta[u,{(Subscript[g, 2]),(Subscript[g, 3])}]}})

({{WeightedData[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[w, 1]),(Subscript[w, 2]),…}]}})

({{WeightedData[{(Subscript[x, 1]),(Subscript[x, 2]),…},fn]}})

({{WeightedGraphQ[g]}})

({{WelchWindow[x]}})

({{WelchWindow[x,α]}})

({{WhiteNoiseProcess[]}})

({{WhiteNoiseProcess[σ]}})

({{WhiteNoiseProcess[dist]}})

({{WhittakerM[k,m,z]}})

({{WhittakerW[k,m,z]}})

({{WienerProcess[μ,σ]}})

({{WienerProcess[]}})

({{WignerD[{j,(Subscript[m, 1]),(Subscript[m, 2])},ψ,θ,ϕ]}})

({{WignerD[{j,(Subscript[m, 1]),(Subscript[m, 2])},θ,ϕ]}})

({{WignerD[{j,(Subscript[m, 1]),(Subscript[m, 2])},θ]}})

({{WignerSemicircleDistribution[r]}})

({{WignerSemicircleDistribution[a,r]}})

({{WilksW[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{WinsorizedMean[list,f]}})

({{WinsorizedMean[list,{(Subscript[f, 1]),(Subscript[f, 2])}]}})

({{WinsorizedMean[list]}})

({{WinsorizedMean[list,0.05]}})

({{WinsorizedMean[dist,…]}})

({{WinsorizedVariance[list,f]}})

({{WinsorizedVariance[list,{(Subscript[f, 1]),(Subscript[f, 2])}]}})

({{WinsorizedVariance[list]}})

({{WinsorizedVariance[list,0.05]}})

({{WinsorizedVariance[dist,…]}})

({{WishartMatrixDistribution[ν,Σ]}})

({{With[{x=(Subscript[x, 0]),y=(Subscript[y, 0]),…},expr]}})

({{WolframLanguageData[entity,property]}})

({{WolframLanguageData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{WolframLanguageData[entity,property,annotation]}})

({{WordCount["string"]}})

({{WordData["word","property"]}})

({{WordData["word"]}})

({{WordData[wordspec,"property"]}})

({{WordDefinition["word"]}})

({{WordTranslation["word",lang]}})

({{WordTranslation["word",(Subscript[lang, 1])->(Subscript[lang, 2])]}})

({{Write[channel,(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{WriteLine["file","string"]}})

({{WriteLine[stream,"string"]}})

({{WriteLine[proc,"string"]}})

({{WriteString["file","string"]}})

({{WriteString[channel,"string"]}})

({{WriteString[channel,(Subscript[expr, 1]),(Subscript[expr, 2]),…]}})

({{Wronskian[{(Subscript[y, 1]),(Subscript[y, 2]),…},x]}})

({{Wronskian[eqn,y,x]}})

({{Wronskian[eqns,{(Subscript[y, 1]),(Subscript[y, 2]),…},x]}})

({{XMLElement[tag,{(Subscript[attr, 1])->(Subscript[val, 1]),…},{(Subscript[data, 1]),…}]}})

({{XMLObject["type"]}})

({{Xnor[(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{XYZColor[x,y,z]}})

({{XYZColor[x,y,z,α]}})

({{YuleDissimilarity[u,v]}})

({{ZernikeR[n,m,r]}})

({{ZeroSymmetric[{(Subscript[s, 1]),…,(Subscript[s, n])}]}})

({{ZetaZero[k]}})

({{ZetaZero[k,t]}})

({{ZIPCodeData[entity,property]}})

({{ZIPCodeData[{(Subscript[entity, 1]),(Subscript[entity, 2]),…},property]}})

({{ZIPCodeData[entity,property,annotation]}})

({{ZipfDistribution[ρ]}})

({{ZipfDistribution[n,ρ]}})

({{AbsoluteTime[]}})

({{AbsoluteTime[{y,m,d,h,m,s}]}})

({{AbsoluteTime[date]}})

({{AbsoluteTime["string"]}})

({{AbsoluteTime[{"string",{"(Subscript[e, 1])","(Subscript[e, 2])",…}}]}})

({{AccountingForm[expr]}})

({{AccountingForm[expr,n]}})

({{Accumulate[list]}})

({{ActionMenu[name,{(Subscript[lbl, 1]):>(Subscript[act, 1]),(Subscript[lbl, 2]):>(Subscript[act, 2]),…}]}})

({{Activate[expr]}})

({{Activate[expr,patt]}})

({{ActiveClassification[f,{(Subscript[conf, 1]),(Subscript[conf, 2]),…}]}})

({{ActiveClassification[f,reg]}})

({{ActiveClassification[f,sampler]}})

({{ActiveClassification[f,{(Subscript[conf, 1]),(Subscript[conf, 2]),…}->nsampler]}})

({{ActiveClassificationObject[…]}})

({{ActivePrediction[f,{(Subscript[conf, 1]),(Subscript[conf, 2]), …}]}})

({{ActivePrediction[f,reg]}})

({{ActivePrediction[f,sampler]}})

({{ActivePrediction[f,{(Subscript[conf, 1]),(Subscript[conf, 2]),…}->nsampler]}})

({{ActivePredictionObject[…]}})

({{AdjacencyGraph[amat]}})

({{AdjacencyGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},amat]}})

({{AdjustmentBox[box,opts]}})

({{AffineStateSpaceModel[{a,b,c,d},x]}})

({{AffineStateSpaceModel[sys]}})

({{AffineStateSpaceModel[eqns,{{(Subscript[x, 1]),(Subscript[x, 10])},…},{{(Subscript[u, 1]),(Subscript[u, 10])},…},{(Subscript[g, 1]),…},t]}})

({{AggregationLayer[f]}})

({{AggregationLayer[f,n]}})

({{AggregationLayer[f,(Subscript[n, 1]);;(Subscript[n, 2])]}})

({{AggregationLayer[f,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{AirPressureData[]}})

({{AirPressureData[datespec]}})

({{AirPressureData[locationspec]}})

({{AirPressureData[locationspec,datespec]}})

({{AirPressureData[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{AirTemperatureData[]}})

({{AirTemperatureData[datespec]}})

({{AirTemperatureData[locationspec]}})

({{AirTemperatureData[locationspec,datespec]}})

({{AirTemperatureData[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{AlgebraicNumberNorm[a]}})

({{AlgebraicNumberTrace[a]}})

({{Alphabet[]}})

({{Alphabet[type]}})

({{Alphabet[type,prop]}})

({{AlphabeticOrder["(Subscript[string, 1])","(Subscript[string, 2])"]}})

({{AlphabeticOrder["(Subscript[string, 1])","(Subscript[string, 2])",lang]}})

({{AlphabeticOrder[lang]}})

({{AlphabeticSort[list]}})

({{AlphabeticSort[list,lang]}})

({{AnatomyPlot3D[primitives,options]}})

({{AndersonDarlingTest[data]}})

({{AndersonDarlingTest[data,dist]}})

({{AndersonDarlingTest[data,dist,"property"]}})

({{AngularGauge[value]}})

({{AngularGauge[value,{min,max}]}})

({{AngularGauge[Dynamic[value],…]}})

({{AngularGauge[{(Subscript[value, 1]),(Subscript[value, 2]),…},…]}})

({{Animator[u]}})

({{Animator[u,{(Subscript[u, min]),(Subscript[u, max])}]}})

({{Animator[u,{(Subscript[u, min]),(Subscript[u, max]),du}]}})

({{Animator[u,{(Subscript[u, min]),(Subscript[u, max])},ups]}})

({{Annuity[p,t]}})

({{Annuity[p,t,q]}})

({{Annuity[{p,{(Subscript[p, initial]),(Subscript[p, final])}},t,q]}})

({{AntihermitianMatrixQ[m]}})

({{AntisymmetricMatrixQ[m]}})

({{APIFunction[{"(Subscript[name, 1])"->(Subscript[type, 1]),"(Subscript[name, 2])"->(Subscript[type, 2]),…},fun]}})

({{APIFunction[{"(Subscript[name, 1])"->(Subscript[type, 1])->(Subscript[default, 1]),…},fun]}})

({{APIFunction[params,fun,fmt]}})

({{APIFunction[params,fun,{fmt,rform}]}})

({{APIFunction[params,fun,{fmt,rform,failfmt}]}})

({{AppendLayer[]}})

({{Apply[f,expr]}})

({{Apply[f,expr,{1}]}})

({{Apply[f,expr,levelspec]}})

({{Apply[f]}})

({{Area[reg]}})

({{Area[{(Subscript[x, 1]),…,(Subscript[x, n])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{Area[{(Subscript[x, 1]),…,(Subscript[x, n])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])},chart]}})

({{ArgMax[f,x]}})

({{ArgMax[f,{x,y,…}]}})

({{ArgMax[{f,cons},{x,y,…}]}})

({{ArgMax[…,x∈reg]}})

({{ArgMax[…,…,dom]}})

({{ArgMin[f,x]}})

({{ArgMin[f,{x,y,…}]}})

({{ArgMin[{f,cons},{x,y,…}]}})

({{ArgMin[…,x∈reg]}})

({{ArgMin[…,…,dom]}})

({{ArrayDepth[expr]}})

({{ArrayFilter[f,array,r]}})

({{ArrayFilter[f,array,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{ArrayFilter[f,array,template]}})

({{ArrayMesh[array]}})

({{ArrayPad[array,m]}})

({{ArrayPad[array,m,padding]}})

({{ArrayPad[array,{m,n},…]}})

({{ArrayPad[array,{{(Subscript[m, 1]),(Subscript[n, 1])},{(Subscript[m, 2]),(Subscript[n, 2])},…},…]}})

({{ArrayPlot[array]}})

({{ArrayResample[array,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{ArrayResample[array,dspec]}})

({{ArrayResample[array,dspec,scheme]}})

({{ArrayResample[array,dspec,scheme,{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{Arrowheads[spec]}})

({{AskFunction[body]}})

({{AskFunction[{"(Subscript[key, 1])"->(Subscript[spec, 1]),"(Subscript[key, 2])"->(Subscript[spec, 2]),…},body]}})

({{AsymptoticDSolveValue[eqn,f,{x,(Subscript[x, 0]),n}]}})

({{AsymptoticDSolveValue[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, 0]),n}]}})

({{AsymptoticDSolveValue[eqn,f,x,{ϵ,(Subscript[ϵ, 0]),n}]}})

({{AsymptoticEqual[f,g,x->(SuperStar[x])]}})

({{AsymptoticEqual[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticEquivalent[f,g,x->(SuperStar[x])]}})

({{AsymptoticEquivalent[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticGreater[f,g,x->(SuperStar[x])]}})

({{AsymptoticGreater[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticGreaterEqual[f,g,x->(SuperStar[x])]}})

({{AsymptoticGreaterEqual[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticIntegrate[f,x,{x,(Subscript[x, 0]),n}]}})

({{AsymptoticLess[f,g,x->(SuperStar[x])]}})

({{AsymptoticLess[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticLessEqual[f,g,x->(SuperStar[x])]}})

({{AsymptoticLessEqual[f,g,{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{AsymptoticOutputTracker[sys,{(Subscript[f, 1]),…},{(Subscript[p, 1]),…}]}})

({{AsymptoticOutputTracker[{sys,{(Subscript[out, 1]),…},{(Subscript[in, 1]),…}},…]}})

({{Audio[file]}})

({{Audio[url]}})

({{Audio[data]}})

({{AudioBlockMap[f,audio,dur]}})

({{AudioBlockMap[f,audio,{dur,offset}]}})

({{AudioBlockMap[f,audio,{dur,offset,wfun}]}})

({{AudioCapture[]}})

({{AudioCapture[file]}})

({{AudioChannelCombine[{(Subscript[audio, 1]),(Subscript[audio, 2]),…}]}})

({{AudioData[audio]}})

({{AudioData[audio,"type"]}})

({{AudioDelay[audio,delay]}})

({{AudioDelay[audio,delay,feedback]}})

({{AudioDelay[audio,delay,feedback,mix]}})

({{AudioDistance[(Subscript[audio, 1]),(Subscript[audio, 2])]}})

({{AudioFade[audio]}})

({{AudioFade[audio,t]}})

({{AudioFade[audio,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{AudioFrequencyShift[audio,freq]}})

({{AudioFrequencyShift[audio,freq,mix]}})

({{AudioGenerator[model]}})

({{AudioGenerator[model,t]}})

({{AudioGenerator[model,t,"type"]}})

({{AudioIntervals[audio]}})

({{AudioIntervals[audio,crit]}})

({{AudioIntervals[audio,crit,mindur]}})

({{AudioJoin[{(Subscript[audio, 1]),(Subscript[audio, 2]),…}]}})

({{AudioJoin[{{(Subscript[audio, 1]),(Subscript[t, 1])},{(Subscript[audio, 2]),(Subscript[t, 2])},…}]}})

({{AudioLocalMeasurements[audio,"prop"]}})

({{AudioLocalMeasurements[audio,{"(Subscript[prop, 1])","(Subscript[prop, 2])",…}]}})

({{AudioLocalMeasurements[audio,"prop",format]}})

({{AudioLoudness[audio]}})

({{AudioLoudness[audio,def]}})

({{AudioMeasurements[audio,"prop"]}})

({{AudioMeasurements[audio,{"(Subscript[prop, 1])","(Subscript[prop, 2])",…}]}})

({{AudioMeasurements[audio,"prop",format]}})

({{AudioMeasurements[{(Subscript[audio, 1]),(Subscript[audio, 2]),…},…]}})

({{AudioOverlay[{(Subscript[audio, 1]),(Subscript[audio, 2]),…}]}})

({{AudioPartition[audio,dur]}})

({{AudioPartition[audio,dur,offset]}})

({{AudioPitchShift[audio,r]}})

({{AudioPlay[audio]}})

({{AudioPlay[astream]}})

({{AudioPlot[audio]}})

({{AudioPlot[{(Subscript[audio, 1]),(Subscript[audio, 2]),…}]}})

({{AudioRecord[inputdev]}})

({{AudioRecord[astream]}})

({{AudioResample[audio,sr]}})

({{AudioReverb[audio]}})

({{AudioReverb[audio,model]}})

({{AudioReverb[audio,model,mix]}})

({{AudioSpectralMap[f,audio]}})

({{AudioSpectralMap[f,{(Subscript[audio, 1]),…}]}})

({{AudioSpectralTransformation[f,audio]}})

({{AudioStream[audio]}})

({{AudioStream[inputdev]}})

({{AudioStream[id]}})

({{AudioTimeStretch[audio,r]}})

({{AudioTrim[audio]}})

({{AudioTrim[audio,t]}})

({{AudioTrim[audio,-t]}})

({{AudioTrim[audio,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{AudioTrim[audio,{{(Subscript[t, 11]),(Subscript[t, 12])},…}]}})

({{AutocorrelationTest[data]}})

({{AutocorrelationTest[data,k]}})

({{AutocorrelationTest[data,k,"property"]}})

({{BandpassFilter[data,{(Subscript[ω, 1]),(Subscript[ω, 2])}]}})

({{BandpassFilter[data,{{ω,q}}]}})

({{BandpassFilter[data,spec,n]}})

({{BandpassFilter[data,spec,n,wfun]}})

({{BandstopFilter[data,{(Subscript[ω, 1]),(Subscript[ω, 2])}]}})

({{BandstopFilter[data,{{ω,q}}]}})

({{BandstopFilter[data,spec,n]}})

({{BandstopFilter[data,spec,n,wfun]}})

({{BarChart[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{BarChart[{…,(Subscript[w, i])[(Subscript[y, i]),…],…,(Subscript[w, j])[(Subscript[y, j]),…],…}]}})

({{BarChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{BarChart3D[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{BarChart3D[{…,(Subscript[w, i])[(Subscript[y, i]),…],…,(Subscript[w, j])[(Subscript[y, j]),…],…}]}})

({{BarChart3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{BaringhausHenzeTest[data]}})

({{BaringhausHenzeTest[data,MultinormalDistribution[μ,Σ]]}})

({{BaringhausHenzeTest[data,"property"]}})

({{BarLegend[cf]}})

({{BarLegend[{cf,{min,max}}]}})

({{BarLegend[cf,contours]}})

({{BasicRecurrentLayer[n]}})

({{BasicRecurrentLayer[n,opts]}})

({{BatchNormalizationLayer[]}})

({{BayesianMaximization[f,{(Subscript[conf, 1]),(Subscript[conf, 2]),…}]}})

({{BayesianMaximization[f,reg]}})

({{BayesianMaximization[f,sampler]}})

({{BayesianMaximization[f,{(Subscript[conf, 1]),(Subscript[conf, 2]),…}->nsampler]}})

({{BayesianMaximizationObject[…]}})

({{BayesianMinimization[f,reg]}})

({{BayesianMinimization[f,sampler]}})

({{BayesianMinimizationObject[…]}})

({{BernoulliGraphDistribution[n,p]}})

({{BezierCurve[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{BezierFunction[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{BezierFunction[array]}})

({{BilateralFilter[data,σ,μ]}})

({{Binarize[image]}})

({{Binarize[image,t]}})

({{Binarize[image,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{Binarize[image,f]}})

({{BinaryRead[stream]}})

({{BinaryRead[stream,type]}})

({{BinaryRead[stream,{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{BinaryReadList["file"]}})

({{BinaryReadList["file",type]}})

({{BinaryReadList["file",{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{BinaryReadList["file",types,n]}})

({{BinarySerialize[expr]}})

({{BinaryWrite[channel,b]}})

({{BinaryWrite[channel,{(Subscript[b, 1]),(Subscript[b, 2]),…}]}})

({{BinaryWrite[channel,"string"]}})

({{BinaryWrite[channel,x,type]}})

({{BinaryWrite[channel,{(Subscript[x, 1]),(Subscript[x, 2]),…},type]}})

({{BinaryWrite[channel,{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{BiweightLocation[list]}})

({{BiweightLocation[list,c]}})

({{BlockchainBlockData["hash"]}})

({{BlockchainBlockData[n]}})

({{BlockchainBlockData[-n]}})

({{BlockchainBlockData[bspec,prop]}})

({{BlockchainData[]}})

({{BlockchainData[property]}})

({{BlockchainTransactionData[txid]}})

({{BlockchainTransactionData[txid,prop]}})

({{BlockRandom[expr]}})

({{BlomqvistBetaTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{BlomqvistBetaTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{BlomqvistBetaTest[…,"property"]}})

({{BooleanConvert[expr]}})

({{BooleanConvert[expr,form]}})

({{BooleanConvert[expr,form,cond]}})

({{BooleanGraph[bfunc,(Subscript[g, 1]),…,(Subscript[g, n])]}})

({{BooleanMinimize[expr]}})

({{BooleanMinimize[expr,form]}})

({{BooleanMinimize[expr,form,cond]}})

({{BooleanRegion[bfunc,{(Subscript[reg, 1]),(Subscript[reg, 2]),…}]}})

({{BorderDimensions[image]}})

({{BorderDimensions[image,t]}})

({{BoundaryDiscretizeGraphics[g]}})

({{BoundaryDiscretizeGraphics[g,patt]}})

({{BoundaryDiscretizeRegion[reg]}})

({{BoundaryDiscretizeRegion[reg,{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{BoundaryMesh[mreg]}})

({{BoundaryMeshRegion[{(Subscript[p, 1]),(Subscript[p, 2]),…},{(Subscript[bcell, 1])[{(Subscript[i, 1]),…}],(Subscript[bcell, 2])[{(Subscript[j, 1]),…}],…}]}})

({{BoundaryMeshRegion[…,{…,(Subscript[w, i])[(Subscript[bcell, i])[…]],…}]}})

({{BoundaryMeshRegion[…,(Subscript[boundary, 1]),(Subscript[boundary, 2]),…]}})

({{BoundingRegion[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{BoundingRegion[{(Subscript[pt, 1]),(Subscript[pt, 2]),…},form]}})

({{BoundingRegion[mreg,…]}})

({{BoxWhiskerChart[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{BoxWhiskerChart[{(Subscript[x, 1]),(Subscript[x, 2]),…},bwspec]}})

({{BoxWhiskerChart[{(Subscript[data, 1]),(Subscript[data, 2]),…},…]}})

({{BoxWhiskerChart[{{(Subscript[data, 1]),(Subscript[data, 2]),…},…},…]}})

({{BrightnessEqualize[image]}})

({{BrightnessEqualize[image,flatfield]}})

({{BrightnessEqualize[image,flatfield,darkfield]}})

({{BrownForsytheTest[data]}})

({{BrownForsytheTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{BrownForsytheTest[dspec,(Subscript[σ, 0]^2)]}})

({{BrownForsytheTest[dspec,(Subscript[σ, 0]^2),"property"]}})

({{BSplineCurve[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{BSplineFunction[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}]}})

({{BSplineFunction[array]}})

({{BSplineSurface[array]}})

({{BubbleChart[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{BubbleChart[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i]),(Subscript[z, i])},…],…,(Subscript[w, j])[{(Subscript[x, j]),(Subscript[y, j]),(Subscript[z, j])},…],…}]}})

({{BubbleChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{BubbleChart3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1]),(Subscript[u, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2]),(Subscript[u, 2])},…}]}})

({{BubbleChart3D[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i]),(Subscript[z, i]),(Subscript[u, i])},…],…,(Subscript[w, j])[{(Subscript[x, j]),(Subscript[y, j]),(Subscript[z, j]),(Subscript[u, j])},…],…}]}})

({{BubbleChart3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{BulletGauge[value,reference,{min,max}]}})

({{BulletGauge[value,reference,{min,(Subscript[m, 1]),(Subscript[m, 2]),…,max}]}})

({{BulletGauge[{(Subscript[v, 1]),(Subscript[v, 2]),…},…]}})

({{BulletGauge[values,{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{BusinessDayQ[date]}})

({{ButterflyGraph[n]}})

({{ButterflyGraph[n,b]}})

({{Button[label,action]}})

({{ButtonBar[{(Subscript[lbl, 1]):>(Subscript[act, 1]),(Subscript[lbl, 2]):>(Subscript[act, 2]),…}]}})

({{ButtonBox[boxes]}})

({{Callout[data,expr]}})

({{Callout[data,expr,pos]}})

({{Callout[data,expr,pos,apos]}})

({{Cancel[expr]}})

({{CancelButton[]}})

({{CancelButton[action]}})

({{CancelButton[label,action]}})

({{CandlestickChart[{{(Subscript[date, 1]),{(Subscript[open, 1]),(Subscript[high, 1]),(Subscript[low, 1]),(Subscript[close, 1])}},…}]}})

({{CandlestickChart[{"name",daterange}]}})

({{CanonicalWarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{CanonicalWarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2]),warp]}})

({{CanonicalWarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2]),warp,win]}})

({{CanonicalWarpingDistance[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{CanonicalWarpingDistance[(Subscript[s, 1]),(Subscript[s, 2]),init]}})

({{CanonicalWarpingDistance[(Subscript[s, 1]),(Subscript[s, 2]),init,win]}})

({{CantorMesh[n]}})

({{CantorMesh[n,d]}})

({{Cases[{(Subscript[e, 1]),(Subscript[e, 2]),…},pattern]}})

({{Cases[{(Subscript[e, 1]),…},pattern->rhs]}})

({{Cases[expr,pattern,levelspec]}})

({{Cases[expr,pattern->rhs,levelspec]}})

({{Cases[expr,pattern,levelspec,n]}})

({{Cases[pattern]}})

({{CatenateLayer[]}})

({{CatenateLayer[n]}})

({{CayleyGraph[group]}})

({{CDFDeploy["file.cdf",expr]}})

({{CDFDeploy["file.cdf",notebook]}})

({{CDFDeploy["file.cdf",NotebookSelection[notebook]]}})

({{CDFDeploy["outfile.cdf","infile.nb"]}})

({{CDFInformation[expr]}})

({{CDFInformation[notebook]}})

({{CDFInformation[NotebookSelection[notebook]]}})

({{CDFInformation["file"]}})

({{Cell[contents]}})

({{Cell[contents,"style"]}})

({{Cell[contents,"(Subscript[style, 1])","(Subscript[style, 2])",…]}})

({{Cells[]}})

({{Cells[obj]}})

({{Cells[NotebookSelection[notebook]]}})

({{CentralFeature[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{CentralFeature[{(Subscript[x, 1])->(Subscript[v, 1]),(Subscript[x, 2])->(Subscript[v, 2]),…}]}})

({{CentralFeature[data]}})

({{Cepstrogram[data]}})

({{Cepstrogram[data,n]}})

({{Cepstrogram[data,n,d]}})

({{Cepstrogram[data,n,d,wfun]}})

({{Cepstrogram[data,n,d,wfun,m]}})

({{CepstrogramArray[data]}})

({{CepstrogramArray[data,n]}})

({{CepstrogramArray[data,n,d]}})

({{CepstrogramArray[data,n,d,wfun]}})

({{CepstrogramArray[data,n,d,wfun,m]}})

({{CepstrumArray[data]}})

({{CepstrumArray[data,type]}})

({{ChannelListen[channel]}})

({{ChannelListen[channel,func]}})

({{ChannelListen[channel,None]}})

({{ChannelListen[url]}})

({{ChannelObject[]}})

({{ChannelObject["relpath"]}})

({{ChannelObject["id"]}})

({{ChannelObject["id:path"]}})

({{ChannelObject["/abspath"]}})

({{ChannelReceiverFunction[fun]}})

({{ChannelSend[channel,msg]}})

({{ChannelSubscribers[channel]}})

({{ChannelSubscribers[{(Subscript[channel, 1]),(Subscript[channel, 2]),…}]}})

({{ChanVeseBinarize[image]}})

({{ChanVeseBinarize[image,marker]}})

({{ChanVeseBinarize[image,marker,{μ,ν,(Subscript[λ, 1]),(Subscript[λ, 2])}]}})

({{CharacterCounts["string"]}})

({{CharacterCounts["string",n]}})

({{Checkbox[x]}})

({{Checkbox[Dynamic[x]]}})

({{Checkbox[x,{(Subscript[val, 1]),(Subscript[val, 2])}]}})

({{Checkbox[x,{(Subscript[val, 1]),(Subscript[val, 2]),(Subscript[val, 3]),…}]}})

({{CheckboxBar[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{CheckboxBar[Dynamic[x],{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{CheckboxBar[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{ChoiceDialog[expr]}})

({{ChoiceDialog[expr,{(Subscript[lbl, 1])->(Subscript[val, 1]),(Subscript[lbl, 2])->(Subscript[val, 2]),…}]}})

({{ChromaticityPlot[colspace]}})

({{ChromaticityPlot[color]}})

({{ChromaticityPlot[{(Subscript[col, 1]),(Subscript[col, 2]),…}]}})

({{ChromaticityPlot[image]}})

({{ChromaticityPlot[…,refcolspace]}})

({{ChromaticityPlot3D[colspace]}})

({{ChromaticityPlot3D[color]}})

({{ChromaticityPlot3D[{(Subscript[col, 1]),(Subscript[col, 2]),…}]}})

({{ChromaticityPlot3D[image]}})

({{ChromaticityPlot3D[…,refcolspace]}})

({{CirculantGraph[n,j]}})

({{CirculantGraph[n,{(Subscript[j, 1]),(Subscript[j, 2]),…}]}})

({{ClassifierFunction[…]}})

({{ClassifierMeasurements[classifier,testset,prop]}})

({{ClassifierMeasurements[classifier,testset]}})

({{ClassifierMeasurementsObject[…]}})

({{Classify[{(Subscript[example, 1])->(Subscript[class, 1]),(Subscript[example, 2])->(Subscript[class, 2]),…}]}})

({{Classify[{(Subscript[example, 1]),(Subscript[example, 2]),…}->{(Subscript[class, 1]),(Subscript[class, 2]),…}]}})

({{Classify[\[LeftAssociation](Subscript[class, 1])->{(Subscript[example, 11]),(Subscript[example, 12]),…},(Subscript[class, 2])->{(Subscript[example, 21]),…},…\[RightAssociation]]}})

({{Classify[training,data]}})

({{Classify["name",data]}})

({{Classify[…,data,prop]}})

({{Classify[classifier,opts]}})

({{ClickPane[image,func]}})

({{ClickPane[image,{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])}},func]}})

({{ClockGauge[]}})

({{ClockGauge[time]}})

({{ClockGauge[{h,m,s}]}})

({{ClockGauge[{y,m,d,h,m,s}]}})

({{ClockGauge["string"]}})

({{ClosenessCentrality[g]}})

({{ClosenessCentrality[{v->w,…}]}})

({{CloudAccountData[]}})

({{CloudAccountData["prop"]}})

({{CloudConnect[userid,password]}})

({{CloudConnect[userid]}})

({{CloudConnect[]}})

({{CloudDeploy[expr]}})

({{CloudDeploy[expr,"uri"]}})

({{CloudDeploy[expr,CloudObject["uri"]]}})

({{CloudDisconnect[]}})

({{CloudEvaluate[expr]}})

({{CloudEvaluate[expr,h]}})

({{CloudExport[expr,"format"]}})

({{CloudExport[expr,"format","uri"]}})

({{CloudExport[expr,"format",CloudObject["uri"]]}})

({{CloudGet["uri"]}})

({{CloudGet[CloudObject["uri"]]}})

({{CloudImport["uri"]}})

({{CloudImport["uri",elements]}})

({{CloudImport[CloudObject["uri"]]}})

({{CloudLoggingData[]}})

({{CloudLoggingData[category]}})

({{CloudLoggingData[obj]}})

({{CloudLoggingData[{(Subscript[obj, 1]),…}]}})

({{CloudLoggingData[objs,period]}})

({{CloudLoggingData[objs,period,elems]}})

({{CloudObject[]}})

({{CloudObject["http://…"]}})

({{CloudObject["https://…"]}})

({{CloudObject["user:user/path"]}})

({{CloudObject["/abspath"]}})

({{CloudObject["relpath"]}})

({{CloudObject["relpath",cbase]}})

({{CloudObjects[]}})

({{CloudObjects[dir]}})

({{CloudObjects[None]}})

({{CloudObjects[dir,type]}})

({{CloudObjects[assoc]}})

({{CloudPublish[]}})

({{CloudPublish[obj]}})

({{CloudPublish[nb]}})

({{CloudPut[expr]}})

({{CloudPut[expr,"uri"]}})

({{CloudPut[expr,CloudObject["uri"]]}})

({{CloudSave[symbol]}})

({{CloudSave["form"]}})

({{CloudSave["context"]}})

({{CloudSave[{(Subscript[object, 1]),(Subscript[object, 2]),…}]}})

({{CloudSave[symspec,"uri"]}})

({{CloudSave[symspec,CloudObject["uri"]]}})

({{CloudSubmit[expr]}})

({{CloudSubmit[ScheduledTask[expr,spec]]}})

({{ClusterClassify[data]}})

({{ClusterClassify[data,n]}})

({{ClusteringComponents[array]}})

({{ClusteringComponents[array,n]}})

({{ClusteringComponents[array,n,level]}})

({{ClusteringComponents[image]}})

({{ClusteringComponents[image,n]}})

({{ClusteringTree[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{ClusteringTree[{(Subscript[e, 1])->(Subscript[v, 1]),(Subscript[e, 2])->(Subscript[v, 2]),…}]}})

({{ClusteringTree[{(Subscript[e, 1]),(Subscript[e, 2]),…}->{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{ClusteringTree[data,h]}})

({{Coefficient[expr,form]}})

({{Coefficient[expr,form,n]}})

({{CoefficientArrays[polys,vars]}})

({{CoefficientList[poly,var]}})

({{CoefficientList[poly,{(Subscript[var, 1]),(Subscript[var, 2]),…}]}})

({{CoefficientList[poly,{(Subscript[var, 1]),(Subscript[var, 2]),…},{(Subscript[dim, 1]),(Subscript[dim, 2]),…}]}})

({{CoefficientRules[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{CoefficientRules[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…},order]}})

({{ColorBalance[image]}})

({{ColorBalance[image,ref]}})

({{ColorBalance[image,ref->target]}})

({{ColorDistance[(Subscript[c, 1]),(Subscript[c, 2])]}})

({{ColorDistance[list,c]}})

({{ColorDistance[(Subscript[list, 1]),(Subscript[list, 2])]}})

({{ColorDistance[image,c]}})

({{ColorDistance[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{Colorize[m]}})

({{Colorize[image]}})

({{ColorQuantize[image,n]}})

({{ColorQuantize[image,{(Subscript[col, 1]),…,(Subscript[col, n])}]}})

({{ColorSetter[color]}})

({{ColorSetter[Dynamic[color]]}})

({{ColorSetter[]}})

({{ColorSetterBox[]}})

({{ColorSlider[color]}})

({{ColorSlider[Dynamic[color]]}})

({{ColorSlider[]}})

({{ColorToneMapping[image]}})

({{ColorToneMapping[image,c]}})

({{ColorToneMapping[image,range]}})

({{ColorToneMapping[image,{range,c}]}})

({{ColorToneMapping[image,{{(Subscript[range, 1]),(Subscript[c, 1])},{(Subscript[range, 2]),(Subscript[c, 2])},…}]}})

({{ColorToneMapping[image,spec,s]}})

({{Column[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{Column[list,alignment]}})

({{Column[list,alignment,spacing]}})

({{CommunityGraphPlot[g]}})

({{CommunityGraphPlot[g,{{(Subscript[v, (Subscript[i, 1])]),(Subscript[v, (Subscript[i, 2])]),…},…}]}})

({{CommunityGraphPlot[g,{…,(Subscript[w, j])[{(Subscript[v, (Subscript[i, 1])]),…}],…}]}})

({{CommunityGraphPlot[{(Subscript[v, (Subscript[i, 1])])->(Subscript[v, (Subscript[j, 1])]),(Subscript[v, (Subscript[i, 2])])->(Subscript[v, (Subscript[j, 2])]),…},…]}})

({{CommunityGraphPlot[m,…]}})

({{Compile[{(Subscript[x, 1]),(Subscript[x, 2]),…},expr]}})

({{Compile[{{(Subscript[x, 1]),(Subscript[t, 1])},…},expr]}})

({{Compile[{{(Subscript[x, 1]),(Subscript[t, 1]),(Subscript[n, 1])},…},expr]}})

({{Compile[vars,expr,{{(Subscript[p, 1]),(Subscript[pt, 1])},…}]}})

({{Complement[(Subscript[e, all]),(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{CompleteGraph[n]}})

({{CompleteGraph[{(Subscript[n, 1]),(Subscript[n, 2]),…,(Subscript[n, k])}]}})

({{CompleteKaryTree[n]}})

({{CompleteKaryTree[n,k]}})

({{ComponentMeasurements[{image,lmat},"prop"]}})

({{ComponentMeasurements[image,"prop"]}})

({{ComponentMeasurements[…,"prop",crit]}})

({{ComponentMeasurements[…,"prop",crit,format]}})

({{CompositeQ[expr]}})

({{Compress[expr]}})

({{ConformAudio[{(Subscript[audio, 1]),(Subscript[audio, 2]),…}]}})

({{ConformAudio[{(Subscript[audio, 1]),(Subscript[audio, 2]),…},spec]}})

({{ConformImages[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ConformImages[{(Subscript[image, 1]),(Subscript[image, 2]),…},spec]}})

({{ConformImages[{(Subscript[image, 1]),(Subscript[image, 2]),…},spec,fitting]}})

({{ConjugateTranspose[m]}})

({{ConnectedGraphComponents[g]}})

({{ConnectedGraphComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{ConnectedGraphComponents[g,patt]}})

({{ConnectedGraphComponents[{v->w,…},…]}})

({{ConnectedMeshComponents[mr]}})

({{ConnectSystemModelComponents[{"c1"∈"comp1",…},{"c1.a"->"c2.b",…}]}})

({{ConoverTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ConoverTest[dspec,(Subscript[σ, 0]^2)]}})

({{ConoverTest[dspec,(Subscript[σ, 0]^2),"property"]}})

({{ConstantArrayLayer[]}})

({{ConstantArrayLayer[opts]}})

({{ConstantImage[val,size]}})

({{ConstantImage[val,size,"type"]}})

({{ConstantPlusLayer[]}})

({{ConstantPlusLayer[opts]}})

({{ConstantTimesLayer[]}})

({{ConstantTimesLayer[opts]}})

({{ContainsAll[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{ContainsAll[(Subscript[e, 2])]}})

({{ContainsAny[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{ContainsAny[(Subscript[e, 2])]}})

({{ContainsExactly[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{ContainsExactly[(Subscript[e, 2])]}})

({{ContainsNone[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{ContainsNone[(Subscript[e, 2])]}})

({{ContainsOnly[(Subscript[e, 1]),(Subscript[e, 2])]}})

({{ContainsOnly[(Subscript[e, 2])]}})

({{ContinuedFractionK[f,g,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ContinuedFractionK[g,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ContinuousTask[expr]}})

({{ContinuousTask[expr,end]}})

({{ContinuousTask[expr,tspan]}})

({{ContinuousWaveletData[{{(Subscript[oct, 1]),(Subscript[voc, 1])}->(Subscript[coef, 1]),…},wave]}})

({{ContinuousWaveletTransform[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{ContinuousWaveletTransform[data,wave]}})

({{ContinuousWaveletTransform[data,wave,{noct,nvoc}]}})

({{ContinuousWaveletTransform[sound,…]}})

({{ContourDetect[image]}})

({{ContourDetect[image,delta]}})

({{ContourDetect[array,…]}})

({{ContourGraphics[array]}})

({{ContrastiveLossLayer[]}})

({{ContrastiveLossLayer[margin]}})

({{ControllabilityGramian[ssm]}})

({{ControllableDecomposition[sys]}})

({{ControllableDecomposition[sys,{(Subscript[z, 1]),…}]}})

({{ControllableModelQ[sys]}})

({{ControllableModelQ[{sys,sub}]}})

({{ControllerState["c"]}})

({{ControllerState[{"(Subscript[c, 1])","(Subscript[c, 2])",…}]}})

({{ControllerState[id,"c"]}})

({{ControllerState[id,{"(Subscript[c, 1])","(Subscript[c, 2])",…}]}})

({{ConvexHullMesh[{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{ConvolutionLayer[n,s]}})

({{ConvolutionLayer[n,{s}]}})

({{ConvolutionLayer[n,{h,w}]}})

({{ConvolutionLayer[n,kernel,opts]}})

({{Convolve[f,g,x,y]}})

({{Convolve[f,g,{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{CopyFile[(Subscript[file, 1]),(Subscript[file, 2])]}})

({{CornerFilter[image]}})

({{CornerFilter[image,r]}})

({{CorrelationTest[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{CorrelationTest[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},(Subscript[ρ, 0])]}})

({{CorrelationTest[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},{{(Subscript[u, 1]),(Subscript[v, 1])},{(Subscript[u, 2]),(Subscript[v, 2])},…}]}})

({{CorrelationTest[…,"property"]}})

({{Count[list,pattern]}})

({{Count[expr,pattern,levelspec]}})

({{Count[pattern]}})

({{CoxModel[…]}})

({{CoxModelFit[{(Subscript[e, 1]),…,(Subscript[e, n])}]}})

({{CoxModelFit[{{{(Subscript[ξ, 11]),…,(Subscript[ξ, 1p])},…,{(Subscript[ξ, n 1]),…,(Subscript[ξ, np])}},{(Subscript[e, 1]),…,(Subscript[e, n])}},{(Subscript[f, 1]),…,(Subscript[f, m])},{(Subscript[x, 1]),…,(Subscript[x, p])}]}})

({{CramerVonMisesTest[data]}})

({{CramerVonMisesTest[data,dist]}})

({{CramerVonMisesTest[data,dist,"property"]}})

({{CreateArchive[source]}})

({{CreateArchive[source,path]}})

({{CreateChannel[]}})

({{CreateChannel["path"]}})

({{CreateChannel[object]}})

({{CreateCloudExpression[value]}})

({{CreateCloudExpression[value,"name"]}})

({{CreateDataSystemModel[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{CreateDataSystemModel[{{(Subscript[t, 1]),(Subscript[v, 1])},…}]}})

({{CreateDataSystemModel[obj]}})

({{CreateDataSystemModel[fun,tmin,tmax]}})

({{CreateDialog[expr]}})

({{CreateDialog[expr,obj]}})

({{CreateDirectory["dir"]}})

({{CreateDirectory[]}})

({{CreateDocument[]}})

({{CreateDocument[expr]}})

({{CreateDocument[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{CreateDocument[expr,obj]}})

({{CreateFile["file"]}})

({{CreateFile[]}})

({{CreateNotebook[]}})

({{CreateNotebook["type"]}})

({{CreateNotebook["type",obj]}})

({{CreatePalette[expr]}})

({{CreatePalette[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{CreatePalette[expr,obj]}})

({{CreateScheduledTask[expr]}})

({{CreateScheduledTask[expr,time]}})

({{CreateScheduledTask[expr,{time}]}})

({{CreateScheduledTask[expr,{time,count}]}})

({{CreateScheduledTask[expr,timespec,start]}})

({{CreateSearchIndex[dir]}})

({{CreateSearchIndex[{(Subscript[source, 1]),(Subscript[source, 2]),…}]}})

({{CreateSearchIndex[sources,"name"]}})

({{CreateSystemModel[sys]}})

({{CreateSystemModel[eqns,t]}})

({{CreateSystemModel[…,tspec]}})

({{CreateSystemModel[…,spec]}})

({{CreateWindow[]}})

({{CreateWindow[expr]}})

({{CreateWindow[expr,obj]}})

({{CrossEntropyLossLayer["Index"]}})

({{CrossEntropyLossLayer["Probabilities"]}})

({{CrossEntropyLossLayer["Binary"]}})

({{CrossingDetect[image]}})

({{CrossingDetect[image,delta]}})

({{CrossingDetect[array,…]}})

({{CTCLossLayer[]}})

({{CurrentDate[gran]}})

({{CurrentDate[date,gran]}})

({{CurrentDate[]}})

({{CurrentImage[]}})

({{CurrentImage[n]}})

({{CurrentNotebookImage[nb]}})

({{CurrentNotebookImage[]}})

({{CurrentScreenImage[]}})

({{CurrentScreenImage[n]}})

({{CurrentScreenImage[{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])}}]}})

({{CycleGraph[n]}})

({{CylindricalDecomposition[ineqs,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{CylindricalDecomposition[ineqs,{(Subscript[x, 1]),(Subscript[x, 2]),…},op]}})

({{DamerauLevenshteinDistance[u,v]}})

({{DateDifference[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DateDifference[(Subscript[date, 1]),(Subscript[date, 2]),"unit"]}})

({{DateDifference[(Subscript[date, 1]),(Subscript[date, 2]),{"(Subscript[unit, 1])","(Subscript[unit, 2])",…}]}})

({{DateHistogram[{(Subscript[date, 1]),(Subscript[date, 2]),…}]}})

({{DateHistogram[{(Subscript[date, 1]),(Subscript[date, 2]),…},bspec]}})

({{DateHistogram[{(Subscript[date, 1]),(Subscript[date, 2]),…},bspec,hspec]}})

({{DateHistogram[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{DateList[]}})

({{DateList[time]}})

({{DateList[date]}})

({{DateList[{y,m,d,h,m,s}]}})

({{DateList["string"]}})

({{DateList[{"string",{"(Subscript[e, 1])","(Subscript[e, 2])",…}}]}})

({{DateListLogPlot[{{(Subscript[date, 1]),(Subscript[v, 1])},{(Subscript[date, 2]),(Subscript[v, 2])},…}]}})

({{DateListLogPlot[{(Subscript[v, 1]),(Subscript[v, 2]),…},datespec]}})

({{DateListLogPlot[tseries]}})

({{DateListLogPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{DateListLogPlot[{…,w[(Subscript[data, i])],…]}})

({{DateListPlot[{{(Subscript[date, 1]),(Subscript[v, 1])},{(Subscript[date, 2]),(Subscript[v, 2])},…}]}})

({{DateListPlot[{(Subscript[v, 1]),(Subscript[v, 2]),…},datespec]}})

({{DateListPlot[tseries]}})

({{DateListPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{DateListStepPlot[{{(Subscript[date, 1]),(Subscript[v, 1])},{(Subscript[date, 2]),(Subscript[v, 2])},…}]}})

({{DateListStepPlot[{(Subscript[v, 1]),(Subscript[v, 2]),…},datespec]}})

({{DateListStepPlot[tseries]}})

({{DateListStepPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{DateListStepPlot[…,step]}})

({{DateListStepPlot[{…,w[(Subscript[data, i])],…}]}})

({{DateObject[]}})

({{DateObject[{y,m,d,h,m,s}]}})

({{DateObject["string"]}})

({{DateObject[{"string",{"(Subscript[e, 1])","(Subscript[e, 2])", …}}]}})

({{DateObject[rdate,gran]}})

({{DatePlus[date,n]}})

({{DatePlus[date,{n,step}]}})

({{DatePlus[date,{{(Subscript[n, 1]),(Subscript[step, 1])},{(Subscript[n, 2]),(Subscript[step, 2])},…}]}})

({{DatePlus[n]}})

({{DatePlus[offset]}})

({{DateRange[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DateRange[(Subscript[date, 1]),(Subscript[date, 2]),increment]}})

({{DateString[]}})

({{DateString["elem"]}})

({{DateString[{"(Subscript[elem, 1])","(Subscript[elem, 2])",…}]}})

({{DateString[{y,m,d,h,m,s}]}})

({{DateString[time]}})

({{DateString[date]}})

({{DateString[spec,elems]}})

({{DayCount[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DayCount[(Subscript[date, 1]),(Subscript[date, 2]),daytype]}})

({{DaylightQ[]}})

({{DaylightQ[datespec]}})

({{DaylightQ[locationspec]}})

({{DaylightQ[locationspec,datespec]}})

({{DaylightQ[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{DaylightQ[locationspec,datespec,inclusionspec]}})

({{DayMatchQ[date,daytype]}})

({{DayName[]}})

({{DayName[date]}})

({{DayPlus[date,n]}})

({{DayPlus[date,n,daytype]}})

({{DayRange[(Subscript[date, 1]),(Subscript[date, 2])]}})

({{DayRange[(Subscript[date, 1]),(Subscript[date, 2]),daytype]}})

({{DayRound[date,daytype]}})

({{DayRound[date,daytype,rounding]}})

({{DeBruijnGraph[m,n]}})

({{DeBruijnGraph[m,n,type]}})

({{DecimalForm[expr]}})

({{DecimalForm[expr,n]}})

({{DecimalForm[expr,{n,f}]}})

({{Decompose[poly,x]}})

({{DeconvolutionLayer[n,sz]}})

({{DeconvolutionLayer[n,{h,w}]}})

({{DeconvolutionLayer[n,{h,w},opts]}})

({{DecryptFile["password",file]}})

({{DecryptFile["password",source,target]}})

({{DecryptFile[keyspec,source,…]}})

({{DefaultButton[]}})

({{DefaultButton[action]}})

({{DefaultButton[label,action]}})

({{DefaultValues[f]}})

({{DefineInputStreamMethod["name",{"(Subscript[fname, 1])"->(Subscript[function, 1]),"(Subscript[fname, 2])"->(Subscript[function, 2]),… }]}})

({{DegreeGraphDistribution[dlist]}})

({{DEigensystem[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n]}})

({{DEigensystem[eqns,u,t,{x,y,…}∈Ω,n]}})

({{DEigenvalues[ℒ[u[x,y,…],u,{x,y,…}∈Ω,n]}})

({{DEigenvalues[eqns,u,t,{x,y,…}∈Ω,n]}})

({{DelaunayMesh[{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{Delayed[expr]}})

({{Delayed[expr,fmt]}})

({{Delayed[expr,{fmt,rform}]}})

({{DeleteBorderComponents[image]}})

({{DeleteBorderComponents[m]}})

({{DeleteCases[expr,pattern]}})

({{DeleteCases[expr,pattern,levelspec]}})

({{DeleteCases[expr,pattern,levelspec,n]}})

({{DeleteCases[pattern]}})

({{DeleteChannel[channel]}})

({{DeleteChannel[{(Subscript[channel, 1]),(Subscript[channel, 2]),…}]}})

({{DeleteChannel[]}})

({{DeleteDirectory["dir"]}})

({{DeletePermissionsKey[key]}})

({{DeletePermissionsKey[{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{DeleteSmallComponents[image]}})

({{DeleteSmallComponents[m]}})

({{DeleteSmallComponents[…,n]}})

({{Dendrogram[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{Dendrogram[{(Subscript[e, 1])->(Subscript[v, 1]),(Subscript[e, 2])->(Subscript[v, 2]),…}]}})

({{Dendrogram[{(Subscript[e, 1]),(Subscript[e, 2]),…}->{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{Dendrogram[data,orientation]}})

({{Dendrogram[tree]}})

({{Denominator[expr]}})

({{DensityGraphics[array]}})

({{DensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{DensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},bspec]}})

({{DensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},bspec,hspec]}})

({{DensityPlot3D[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{DensityPlot3D[f,{x,y,z}∈reg]}})

({{Depth[expr]}})

({{DerivativeFilter[data,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{DerivativeFilter[data,{(Subscript[n, 1]),(Subscript[n, 2]),…},σ]}})

({{DerivativeFilter[data,{(Subscript[der, 1]),(Subscript[der, 2]),…},…]}})

({{DesignMatrix[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Det[m]}})

({{Devices[]}})

({{Devices[form]}})

({{Devices[{(Subscript[form, 1]),(Subscript[form, 2]),…}]}})

({{DiagonalizableMatrixQ[m]}})

({{Dialog[]}})

({{Dialog[expr]}})

({{DialogInput[expr]}})

({{DialogInput[{x=(Subscript[x, 0]),y=(Subscript[y, 0]),…},expr]}})

({{DialogNotebook[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{DictionaryLookup[patt]}})

({{DictionaryLookup[patt,n]}})

({{DictionaryLookup[{"lang",patt}]}})

({{DictionaryWordQ["word"]}})

({{DifferenceDelta[f,i]}})

({{DifferenceDelta[f,{i,n}]}})

({{DifferenceDelta[f,{i,n,h}]}})

({{DifferenceDelta[f,i,j,…]}})

({{DifferenceQuotient[f,{x,n,h}]}})

({{DifferenceQuotient[f,{(Subscript[x, 1]),(Subscript[n, 1]),(Subscript[h, 1])},{(Subscript[x, 2]),(Subscript[n, 2]),(Subscript[h, 2])},…]}})

({{DifferenceRootReduce[expr,n]}})

({{DifferentialRootReduce[expr,x]}})

({{DifferentialRootReduce[expr,{x,(Subscript[x, 0])}]}})

({{DifferentiatorFilter[data,(Subscript[ω, c])]}})

({{DifferentiatorFilter[data,(Subscript[ω, c]),n]}})

({{DifferentiatorFilter[data,(Subscript[ω, c]),n,wfun]}})

({{Dilation[image,ker]}})

({{Dilation[image,r]}})

({{Dilation[data,…]}})

({{DimensionalCombinations[{(Subscript[pq, 1]),(Subscript[pq, 2]),…}]}})

({{DimensionalCombinations[{(Subscript[pq, 1]),(Subscript[pq, 2]),…},dim]}})

({{DimensionalMeshComponents[mr]}})

({{DimensionReduce[{(Subscript[example, 1]),(Subscript[example, 2]),…}]}})

({{DimensionReduce[examples,n]}})

({{DimensionReducerFunction[…]}})

({{DimensionReduction[{(Subscript[example, 1]),(Subscript[example, 2]),…}]}})

({{DimensionReduction[examples,n]}})

({{DimensionReduction[examples,n,props]}})

({{Dimensions[expr]}})

({{Dimensions[expr,n]}})

({{DirectedGraph[g]}})

({{DirectedGraph[g,conv]}})

({{DirectedGraph[{v->w,…},…]}})

({{DirectoryName["name"]}})

({{DirichletTransform[expr,n,s]}})

({{DiscreteConvolve[f,g,n,m]}})

({{DiscreteConvolve[f,g,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[m, 1]),(Subscript[m, 2]),…}]}})

({{DiscreteHadamardTransform[list]}})

({{DiscreteLQEstimatorGains[ssm,{w,v},τ]}})

({{DiscreteLQEstimatorGains[{ssm,sensors},{w,v},τ]}})

({{DiscreteLQEstimatorGains[{ssm,sensors,dinputs},{w,v},τ]}})

({{DiscreteLQRegulatorGains[ssm,{q,r},τ]}})

({{DiscreteLQRegulatorGains[ssm,{q,r,p},τ]}})

({{DiscreteLQRegulatorGains[{ssm,finputs},{…},τ]}})

({{DiscreteRatio[f,i]}})

({{DiscreteRatio[f,{i,n}]}})

({{DiscreteRatio[f,{i,n,h}]}})

({{DiscreteRatio[f,i,j,…]}})

({{DiscreteRiccatiSolve[{a,b},{q,r}]}})

({{DiscreteRiccatiSolve[{a,b},{q,r,p}]}})

({{DiscreteShift[f,i]}})

({{DiscreteShift[f,{i,n}]}})

({{DiscreteShift[f,{i,n,h}]}})

({{DiscreteShift[f,i,j,…]}})

({{DiscreteWaveletData[{(Subscript[wind, 1])->(Subscript[coef, 1]),…},wave,wtrans]}})

({{DiscreteWaveletData[{(Subscript[wind, 1])->(Subscript[coef, 1]),…},wave,wtrans,{(Subscript[d, 1]),…}]}})

({{DiscreteWaveletPacketTransform[data]}})

({{DiscreteWaveletPacketTransform[data,wave]}})

({{DiscreteWaveletPacketTransform[data,wave,r]}})

({{DiscretizeGraphics[g]}})

({{DiscretizeGraphics[g,patt]}})

({{DiscretizeRegion[reg]}})

({{DiscretizeRegion[reg,{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{Discriminant[poly,var]}})

({{Discriminant[poly,var,Modulus->p]}})

({{DiskMatrix[r]}})

({{DiskMatrix[r,w]}})

({{DiskMatrix[{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{Display[channel,graphics]}})

({{Display[channel,graphics,"format"]}})

({{Display[channel,expr,"format"]}})

({{DisplayString[graphics]}})

({{DisplayString[graphics,"format"]}})

({{DisplayString[expr,"format"]}})

({{DistanceMatrix[{(Subscript[u, 1]),(Subscript[u, 2]),…}]}})

({{DistanceMatrix[{(Subscript[u, 1]),(Subscript[u, 2]),…},{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{DistanceTransform[image]}})

({{DistanceTransform[image,t]}})

({{DistributeDefinitions[(Subscript[s, 1]),(Subscript[s, 2]),…]}})

({{DistributeDefinitions["context`"]}})

({{DistributionChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{DistributionChart[{…,(Subscript[w, i])[(Subscript[data, i]),…],…,(Subscript[w, j])[(Subscript[data, j]),…],…}]}})

({{DistributionChart[{{(Subscript[data, 1]),(Subscript[data, 2]),…},…}]}})

({{DistributionFitTest[data]}})

({{DistributionFitTest[data,dist]}})

({{DistributionFitTest[data,dist,"property"]}})

({{DivideSides[rel,x]}})

({{DivideSides[(Subscript[rel, 1]),(Subscript[rel, 2])]}})

({{DivideSides[rel]}})

({{Divisors[n]}})

({{DivisorSigma[k,n]}})

({{DocumentGenerator[template,timespec]}})

({{DocumentGenerator[template,driver,timespec]}})

({{DocumentNotebook[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{DominantColors[image]}})

({{DominantColors[image,n]}})

({{DominantColors[image,n,prop]}})

({{DominantColors[image,n,prop,format]}})

({{DominantColors[{(Subscript[image, 1]),(Subscript[image, 2]),…},…]}})

({{DotLayer[]}})

({{DotPlusLayer[n]}})

({{DownValues[f]}})

({{DropoutLayer[]}})

({{DropoutLayer[p]}})

({{DSolve[eqn,u,x]}})

({{DSolve[eqn,u,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{DSolve[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},{(Subscript[u, 1]),(Subscript[u, 2]),…},…]}})

({{DSolve[eqn,u,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{DSolve[eqn,u,{(Subscript[x, 1]),(Subscript[x, 2]),…}∈Ω]}})

({{DSolveValue[eqn,expr,x]}})

({{DSolveValue[eqn,expr,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{DSolveValue[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},expr,…]}})

({{DSolveValue[eqn,expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{DSolveValue[eqn,expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}∈Ω]}})

({{Dt[f,x]}})

({{Dt[f]}})

({{Dt[f,{x,n}]}})

({{Dt[f,(Subscript[x, 1]),(Subscript[x, 2]),…]}})

({{DumpSave["file.mx",symbol]}})

({{DumpSave["file.mx","context`"]}})

({{DumpSave["file.mx",{(Subscript[object, 1]),(Subscript[object, 2]),…}]}})

({{DumpSave["package`",objects]}})

({{Dynamic[expr]}})

({{Dynamic[expr]}})

({{Dynamic[expr,None]}})

({{Dynamic[expr,f]}})

({{Dynamic[expr,{f,(Subscript[f, end])}]}})

({{Dynamic[expr,{(Subscript[f, start]),f,(Subscript[f, end])}]}})

({{DynamicBox[expr]}})

({{DynamicGeoGraphics[primitives,options]}})

({{DynamicImage[image]}})

({{DynamicImage[file]}})

({{DynamicImage[url]}})

({{DynamicModule[{x,y,…},expr]}})

({{DynamicModule[{x=(Subscript[x, 0]),y=(Subscript[y, 0]),…},expr]}})

({{DynamicWrapper[e,expr]}})

({{EarthquakeData[loc]}})

({{EarthquakeData[loc,mag]}})

({{EarthquakeData[loc,mag,{start,end}]}})

({{EarthquakeData[loc,mag,{start,end},property]}})

({{EarthquakeData[entity,property]}})

({{EdgeConnectivity[g]}})

({{EdgeConnectivity[g,s,t]}})

({{EdgeConnectivity[{v->w,…},…]}})

({{EdgeDetect[image]}})

({{EdgeDetect[image,r]}})

({{EdgeDetect[image,r,t]}})

({{EditDistance[u,v]}})

({{EffectiveInterest[r,q]}})

({{Eigensystem[m]}})

({{Eigensystem[{m,a}]}})

({{Eigensystem[m,k]}})

({{Eigensystem[{m,a},k]}})

({{Eigenvalues[m]}})

({{Eigenvalues[{m,a}]}})

({{Eigenvalues[m,k]}})

({{Eigenvalues[{m,a},k]}})

({{EigenvectorCentrality[g]}})

({{EigenvectorCentrality[g,"In"]}})

({{EigenvectorCentrality[g,"Out"]}})

({{EigenvectorCentrality[{v->w,…},…]}})

({{Eigenvectors[m]}})

({{Eigenvectors[{m,a}]}})

({{Eigenvectors[m,k]}})

({{Eigenvectors[{m,a},k]}})

({{ElementwiseLayer[f]}})

({{ElementwiseLayer["name"]}})

({{Eliminate[eqns,vars]}})

({{EmbedCode[obj]}})

({{EmbedCode[obj,"dest"]}})

({{EmbedCode[obj,"dest",dir]}})

({{EmbedCode[obj,"dest",loc]}})

({{EmbeddingLayer[size,n]}})

({{EmbeddingLayer[size]}})

({{Encode["source","dest"]}})

({{Encode["source","dest","key"]}})

({{EncryptFile["password",file]}})

({{EncryptFile["password",source,target]}})

({{EncryptFile[keyspec,source,…]}})

({{EngineeringForm[expr]}})

({{EngineeringForm[expr,n]}})

({{EntityPrefetch["type"]}})

({{EntityPrefetch[EntityProperty["type","prop"]]}})

({{EntityProperty[type,pname]}})

({{EntityProperty[type,pname,{(Subscript[qual, 1])->(Subscript[val, 1]),(Subscript[qual, 2])->(Subscript[val, 2]),…}]}})

({{EntityPropertyClass[type,pcname]}})

({{EntityStore["type"]}})

({{EntityStore["type"->data]}})

({{EntityStore[{(Subscript[tspec, 1]),(Subscript[tspec, 2]),…}]}})

({{Entropy[list]}})

({{Entropy[k,list]}})

({{EquirippleFilterKernel[{{{(Subscript[ω, L1]),(Subscript[ω, R1])},{(Subscript[ω, L2]),(Subscript[ω, R2])},…},{(Subscript[a, 1]),(Subscript[a, 2]),…}},n]}})

({{EquirippleFilterKernel[{{{(Subscript[ω, L1]),(Subscript[ω, R1])},{(Subscript[ω, L2]),(Subscript[ω, R2])},…},{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[w, 1]),…}},n]}})

({{Erosion[image,ker]}})

({{Erosion[image,r]}})

({{Erosion[data,…]}})

({{EstimatedBackground[data]}})

({{EstimatedBackground[data,σ]}})

({{EstimatedDistribution[data,dist]}})

({{EstimatedDistribution[data,dist,{{p,(Subscript[p, 0])},{q,(Subscript[q, 0])},…}]}})

({{EstimatedDistribution[data,dist,idist]}})

({{EstimatedProcess[data,proc]}})

({{EstimatedProcess[data,proc,{{p,(Subscript[p, 0])},{q,(Subscript[q, 0])},…}]}})

({{EstimatedProcess[data,proc,iproc]}})

({{EstimatorGains[ssm,{(Subscript[p, 1]),(Subscript[p, 2]),…,(Subscript[p, n])}]}})

({{EstimatorGains[{ssm,{(Subscript[out, 1]),…}},…]}})

({{EstimatorRegulator[ssm,{l,κ}]}})

({{EstimatorRegulator[{ssm,sensors},{l,κ}]}})

({{EstimatorRegulator[{ssm,sensors,finputs},{l,κ}]}})

({{EstimatorRegulator[{ssm,sensors,finputs,einputs},{l,κ}]}})

({{EventHandler[expr,{"(Subscript[event, 1])":>(Subscript[action, 1]),"(Subscript[event, 2])":>(Subscript[action, 2]),…}]}})

({{EventSeries[{{(Subscript[t, 1]),(Subscript[v, 1])},{(Subscript[t, 2]),(Subscript[v, 2])}…}]}})

({{EventSeries[{(Subscript[v, 1]),(Subscript[v, 2]),…},tspec]}})

({{Expand[expr]}})

({{Expand[expr,patt]}})

({{ExpandAll[expr]}})

({{ExpandAll[expr,patt]}})

({{ExpandDenominator[expr]}})

({{ExpandNumerator[expr]}})

({{Expectation[expr,x\[Distributed]dist]}})

({{Expectation[expr,x\[Distributed]data]}})

({{Expectation[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}\[Distributed]dist]}})

({{Expectation[expr,{(Subscript[x, 1])\[Distributed](Subscript[dist, 1]),(Subscript[x, 2])\[Distributed](Subscript[dist, 2]),…}]}})

({{Expectation[expr\[Conditioned]pred,…]}})

({{ExpectedValue[f,list]}})

({{ExpectedValue[f,list,x]}})

({{ExpectedValue[f,dist]}})

({{ExpectedValue[f,dist,x]}})

({{Exponent[expr,form]}})

({{Exponent[expr,form,h]}})

({{ExponentialGeneratingFunction[expr,n,x]}})

({{ExponentialGeneratingFunction[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{ExpressionCell[expr]}})

({{ExpressionCell[expr,"style"]}})

({{ExpressionCell[expr,"(Subscript[style, 1])","(Subscript[style, 2])",…]}})

({{ExtractArchive[file]}})

({{ExtractArchive[file,dir]}})

({{ExtractArchive[file,dir,pattern]}})

({{FacialFeatures[image]}})

({{FacialFeatures[image,features]}})

({{Factor[poly]}})

({{Factor[poly,Modulus->p]}})

({{Factor[poly,Extension->{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{FactorInteger[n]}})

({{FactorInteger[n,k]}})

({{FactorList[poly]}})

({{FactorSquareFree[poly]}})

({{FactorSquareFreeList[poly]}})

({{FeatureDistance[(Subscript[example, 1]),(Subscript[example, 2]),extractor]}})

({{FeatureDistance[extractor]}})

({{FeatureExtract[{(Subscript[example, 1]),(Subscript[example, 2]),…}]}})

({{FeatureExtract[examples,extractor]}})

({{FeatureExtract[examples,{(Subscript[extractor, 1]),(Subscript[extractor, 2]),…}]}})

({{FeatureExtract[examples,spec->ext]}})

({{FeatureExtract[examples,{(Subscript[spec, 1])->(Subscript[ext, 1]),(Subscript[spec, 2])->(Subscript[ext, 2]),…}]}})

({{FeatureExtraction[{(Subscript[example, 1]),(Subscript[example, 2]),…}]}})

({{FeatureExtraction[examples,extractor]}})

({{FeatureExtraction[examples,{(Subscript[extractor, 1]),(Subscript[extractor, 2]),…}]}})

({{FeatureExtraction[examples,spec->ext]}})

({{FeatureExtraction[examples,{(Subscript[spec, 1])->(Subscript[ext, 1]),(Subscript[spec, 2])->(Subscript[ext, 2]),…}]}})

({{FeatureExtraction[examples,extractor,props]}})

({{FeatureExtractorFunction[…]}})

({{FeatureNearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},x]}})

({{FeatureNearest[{(Subscript[elem, 1])->(Subscript[v, 1]),(Subscript[elem, 2])->(Subscript[v, 2]),…},x]}})

({{FeatureNearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…}->{(Subscript[v, 1]),(Subscript[v, 2]),…},x]}})

({{FeatureNearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…}->prop,x]}})

({{FeatureNearest[data,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{FeatureNearest[data,x,n]}})

({{FeatureNearest[data]}})

({{FeatureSpacePlot[{(Subscript[example, 1]),(Subscript[example, 2]),…}]}})

({{FeedbackLinearize[asys]}})

({{FeedbackLinearize[asys,{z,v}]}})

({{FeedbackLinearize[asys,{z,v},"prop"]}})

({{FetalGrowthData[age]}})

({{FetalGrowthData[age,property]}})

({{FetalGrowthData[age,index]}})

({{FetalGrowthData[age,property,index]}})

({{FileBaseName["file"]}})

({{FileExtension["file"]}})

({{FileNameDepth["name"]}})

({{FileNameDrop["name",n]}})

({{FileNameDrop["name",-n]}})

({{FileNameDrop["name",{m,n}]}})

({{FileNameDrop["name"]}})

({{FileNameJoin[{"(Subscript[name, 1])","(Subscript[name, 2])",…}]}})

({{FileNames[]}})

({{FileNames[form]}})

({{FileNames[{(Subscript[form, 1]),(Subscript[form, 2]),…}]}})

({{FileNames[forms,{(Subscript[dir, 1]),(Subscript[dir, 2]),…}]}})

({{FileNames[forms,dirs,n]}})

({{FileNameSetter[name]}})

({{FileNameSetter[Dynamic[name]]}})

({{FileNameSetter[name,"Save"]}})

({{FileNameSetter[name,"spec",{"(Subscript[type, 1])"->{"(Subscript[patt, 11])","(Subscript[patt, 12])",…},"(Subscript[type, 2])"->{…},…}]}})

({{FileNameSplit["name"]}})

({{FileNameTake["name"]}})

({{FileNameTake["name",n]}})

({{FileNameTake["name",-n]}})

({{FileNameTake["name",{m,n}]}})

({{FileSystemMap[f,root]}})

({{FileSystemMap[f,root,n]}})

({{FileSystemMap[f,root,{m,n}]}})

({{FileSystemMap[f,root,lev,r]}})

({{FileSystemScan[f,root]}})

({{FileSystemScan[f,root,n]}})

({{FileTemplate["file"]}})

({{FileTemplate[src]}})

({{FileTemplate[form,args]}})

({{FileTemplateApply[template]}})

({{FileTemplateApply[template,args]}})

({{FileTemplateApply[template,output]}})

({{FileTemplateApply[template,args,output]}})

({{FilledCurve[{(Subscript[segment, 1]),(Subscript[segment, 2]),…}]}})

({{FilledCurve[{(Subscript[component, 1]),(Subscript[component, 2]),…}]}})

({{FillingTransform[image]}})

({{FillingTransform[image,marker]}})

({{FillingTransform[image,h]}})

({{FinancialBond[params,ambientparams]}})

({{FinancialBond[params,ambientparams,prop]}})

({{FinancialDerivative[instrument,params,ambientparams]}})

({{FinancialDerivative[instrument,params,ambientparams,prop]}})

({{Find[stream,"text"]}})

({{Find[stream,{"(Subscript[text, 1])","(Subscript[text, 2])",…}]}})

({{FindArgMax[f,x]}})

({{FindArgMax[f,{x,(Subscript[x, 0])}]}})

({{FindArgMax[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindArgMax[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindArgMax[{f,cons},{x,y,…}]}})

({{FindArgMin[f,x]}})

({{FindArgMin[f,{x,(Subscript[x, 0])}]}})

({{FindArgMin[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindArgMin[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindArgMin[{f,cons},{x,y,…}]}})

({{FindChannels[]}})

({{FindChannels[None]}})

({{FindChannels[All]}})

({{FindChannels[form]}})

({{FindChannels["user:form"]}})

({{FindChannels["/abspath"]}})

({{FindChannels["https:// …"]}})

({{FindChannels[Anonymous]}})

({{FindChannels[Full]}})

({{FindClusters[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{FindClusters[{(Subscript[e, 1])->(Subscript[v, 1]),(Subscript[e, 2])->(Subscript[v, 2]),…}]}})

({{FindClusters[{(Subscript[e, 1]),(Subscript[e, 2]),…}->{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{FindClusters[\[LeftAssociation](Subscript[label, 1])->(Subscript[e, 1]),(Subscript[label, 2])->(Subscript[e, 2]),…\[RightAssociation]]}})

({{FindClusters[data,n]}})

({{FindDevices[]}})

({{FindDevices[form]}})

({{FindDevices[{(Subscript[form, 1]),(Subscript[form, 2]),…}]}})

({{FindDevices[forms,n]}})

({{FindDistribution[data]}})

({{FindDistribution[data,n]}})

({{FindDistribution[data,n,prop]}})

({{FindDistribution[data,n,{(Subscript[prop, 1]),(Subscript[prop, 2]),…}]}})

({{FindDistributionParameters[data,dist]}})

({{FindDistributionParameters[data,dist,{{p,(Subscript[p, 0])},{q,(Subscript[q, 0])},…}]}})

({{FindDivisions[{(Subscript[x, min]),(Subscript[x, max])},n]}})

({{FindDivisions[{(Subscript[x, min]),(Subscript[x, max]),dx},n]}})

({{FindDivisions[{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FindDivisions[{(Subscript[x, min]),(Subscript[x, max]),{(Subscript[dx, 1]),(Subscript[dx, 2]),…}},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FindEdgeCut[g]}})

({{FindEdgeCut[g,s,t]}})

({{FindEdgeCut[{v->w,…},…]}})

({{FindFit[data,expr,pars,vars]}})

({{FindFit[data,{expr,cons},pars,vars]}})

({{FindFormula[data]}})

({{FindFormula[data,x]}})

({{FindFormula[data,x,n]}})

({{FindFormula[data,x,n,prop]}})

({{FindFormula[data,x,n,{(Subscript[prop, 1]),(Subscript[prop, 2]),…}]}})

({{FindFundamentalCycles[g]}})

({{FindGeneratingFunction[{(Subscript[a, 0]),(Subscript[a, 1]),…},x]}})

({{FindGeneratingFunction[{{(Subscript[n, 0]),(Subscript[a, 0])},{(Subscript[n, 1]),(Subscript[a, 1])},…},x]}})

({{FindGeometricTransform[(Subscript[pts, 1]),(Subscript[pts, 2])]}})

({{FindGeometricTransform[ref,{(Subscript[pts, 1]),(Subscript[pts, 2]),…}]}})

({{FindGeometricTransform[{(Subscript[pts, 1]),(Subscript[pts, 2]),…}]}})

({{FindGraphCommunities[g]}})

({{FindGraphCommunities[{v->w,…}]}})

({{FindGraphIsomorphism[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{FindGraphIsomorphism[(Subscript[g, 1]),(Subscript[g, 2]),n]}})

({{FindGraphIsomorphism[{v->w,…},…]}})

({{FindHamiltonianCycle[g]}})

({{FindHamiltonianCycle[g,k]}})

({{FindHamiltonianCycle[{v->w,…},…]}})

({{FindHamiltonianPath[g]}})

({{FindHamiltonianPath[g,s,t]}})

({{FindIndependentEdgeSet[g]}})

({{FindIndependentEdgeSet[{v->w,…}]}})

({{FindInstance[expr,vars]}})

({{FindInstance[expr,vars,dom]}})

({{FindInstance[expr,vars,dom,n]}})

({{FindIntegerNullVector[{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])}]}})

({{FindIntegerNullVector[{(Subscript[x, 1]),(Subscript[x, 2]),…,(Subscript[x, n])},d]}})

({{FindList["file","text"]}})

({{FindList["file",{"(Subscript[text, 1])","(Subscript[text, 2])",…}]}})

({{FindList[{"(Subscript[file, 1])",…},…]}})

({{FindList[files,text,n]}})

({{FindMaximumFlow[g,s,t]}})

({{FindMaximumFlow[m,s,t]}})

({{FindMaximumFlow[data,{(Subscript[s, 1]),…},{(Subscript[t, 1]),…}]}})

({{FindMaximumFlow[data,source,target,"property"]}})

({{FindMaximumFlow[{v->w,…},…]}})

({{FindMaxValue[f,x]}})

({{FindMaxValue[f,{x,(Subscript[x, 0])}]}})

({{FindMaxValue[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMaxValue[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMaxValue[{f,cons},{x,y,…}]}})

({{FindMeshDefects[mreg]}})

({{FindMeshDefects[mreg,{(Subscript[def, 1]),…}]}})

({{FindMeshDefects[mreg,defects,format]}})

({{FindMinimumCostFlow[g,{(Subscript[sd, 1]),(Subscript[sd, 2]),…}]}})

({{FindMinimumCostFlow[g,s,t]}})

({{FindMinimumCostFlow[g,s,t,d]}})

({{FindMinimumCostFlow[m,…]}})

({{FindMinimumCostFlow[data,…,"property"]}})

({{FindMinimumCostFlow[{v->w,…},…]}})

({{FindMinimumCut[g]}})

({{FindMinimumCut[{v->w,…}]}})

({{FindMinValue[f,x]}})

({{FindMinValue[f,{x,(Subscript[x, 0])}]}})

({{FindMinValue[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMinValue[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMinValue[{f,cons},{x,y,…}]}})

({{FindPeaks[data]}})

({{FindPeaks[data,σ]}})

({{FindPeaks[data,σ,s]}})

({{FindPeaks[data,σ,s,t]}})

({{FindPeaks[data,σ,{s,(Subscript[σ, s])},{t,(Subscript[σ, t])}]}})

({{FindProcessParameters[data,proc]}})

({{FindProcessParameters[data,proc,{{p,(Subscript[p, 0])},{q,(Subscript[q, 0])},…}]}})

({{FindRepeat[list]}})

({{FindRepeat[list,n]}})

({{FindRepeat[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FindRepeat["string"]}})

({{FindRepeat["string",n]}})

({{FindSequenceFunction[{(Subscript[a, 1]),(Subscript[a, 2]),(Subscript[a, 3]),…}]}})

({{FindSequenceFunction[{{(Subscript[n, 1]),(Subscript[a, 1])},{(Subscript[n, 2]),(Subscript[a, 2])},…}]}})

({{FindSequenceFunction[\[LeftAssociation](Subscript[n, 1])->(Subscript[a, 1]),(Subscript[n, 2])->(Subscript[a, 2]),…\[RightAssociation]]}})

({{FindSequenceFunction[{(Subscript[n, 1])->(Subscript[a, 1]),(Subscript[n, 2])->(Subscript[a, 2]),…}]}})

({{FindSequenceFunction[list,n]}})

({{FindShortestPath[g,s,t]}})

({{FindShortestPath[g,s,All]}})

({{FindShortestPath[g,All,t]}})

({{FindShortestPath[g,All,All]}})

({{FindShortestPath[{v->w,…},…]}})

({{FindShortestTour[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{FindShortestTour[graph]}})

({{FindShortestTour[{(Subscript[v, 1]),(Subscript[v, 2]),…},j,k]}})

({{FindShortestTour[graph,s,t]}})

({{FindShortestTour[{v->w,…},…]}})

({{FindSpanningTree[g]}})

({{FindSpanningTree[{g,v},…]}})

({{FindSpanningTree[{v->w,…},…]}})

({{FindThreshold[image]}})

({{FindTransientRepeat[list,n]}})

({{FindTransientRepeat[string,n]}})

({{FirstCase[{(Subscript[e, 1]),(Subscript[e, 2]),…},pattern]}})

({{FirstCase[{(Subscript[e, 1]),…},pattern->rhs]}})

({{FirstCase[expr,pattern,default]}})

({{FirstCase[expr,pattern,default,levelspec]}})

({{FirstCase[pattern]}})

({{FirstPosition[expr,pattern]}})

({{FirstPosition[expr,pattern,default]}})

({{FirstPosition[expr,pattern,default,levelspec]}})

({{FirstPosition[pattern]}})

({{FisherRatioTest[data]}})

({{FisherRatioTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{FisherRatioTest[dspec,(Subscript[σ, 0]^2)]}})

({{FisherRatioTest[dspec,(Subscript[σ, 0]^2),"property"]}})

({{FixedPoint[f,expr]}})

({{FixedPointList[f,expr]}})

({{FlattenLayer[]}})

({{FlattenLayer[n]}})

({{FlipView[{(Subscript[expr, 1]),(Subscript[expr, 2])}]}})

({{FlipView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{FlipView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},i]}})

({{FormatValues[f]}})

({{FormBox[boxes,form]}})

({{FormFunction[formspec,func]}})

({{FormFunction[{"(Subscript[name, 1])"->(Subscript[type, 1]),…},func]}})

({{FormFunction[{{"(Subscript[name, 1])",(Subscript[label, 1])}->(Subscript[type, 1]),…},func]}})

({{FormFunction[{(Subscript[namespec, 1])->(Subscript[type, 1])->(Subscript[default, 1]),…},func]}})

({{FormFunction[formspec,func,fmt]}})

({{FormFunction[{(Subscript[formspec, 1]),(Subscript[formspec, 2]),…},func,…]}})

({{FormObject[{"(Subscript[name, 1])"->(Subscript[type, 1]),"(Subscript[name, 2])"->(Subscript[type, 2]),…}]}})

({{FormObject[{{"(Subscript[name, 1])",(Subscript[label, 1])}->(Subscript[type, 1]),…}]}})

({{FormObject[{"(Subscript[name, 1])"->(Subscript[assoc, 1]),…,(Subscript[obj, j]),…}]}})

({{FormPage[formspec,func]}})

({{FormPage[{"(Subscript[name, 1])"->(Subscript[type, 1]),…},func]}})

({{FormPage[{{"(Subscript[name, 1])",(Subscript[label, 1])}->(Subscript[type, 1]),…},func]}})

({{FormPage[{(Subscript[namespec, 1])->(Subscript[type, 1])->(Subscript[default, 1]),…},func]}})

({{FormPage[formspec,func,form]}})

({{FormPage[formspec,func,initform->resform]}})

({{FormulaLookup["query"]}})

({{FormulaLookup["query",n]}})

({{Fourier[list]}})

({{Fourier[list,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{FourierCoefficient[expr,t,n]}})

({{FourierCoefficient[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierCosCoefficient[expr,t,n]}})

({{FourierCosCoefficient[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierCosSeries[expr,t,n]}})

({{FourierCosSeries[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierDCTMatrix[n]}})

({{FourierDCTMatrix[n,m]}})

({{FourierDSTMatrix[n]}})

({{FourierDSTMatrix[n,m]}})

({{FourierMatrix[n]}})

({{FourierSequenceTransform[expr,n,ω]}})

({{FourierSequenceTransform[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[ω, 1]),(Subscript[ω, 2]),…}]}})

({{FourierSeries[expr,t,n]}})

({{FourierSeries[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierSinCoefficient[expr,t,n]}})

({{FourierSinCoefficient[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierSinSeries[expr,t,n]}})

({{FourierSinSeries[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FourierTrigSeries[expr,t,n]}})

({{FourierTrigSeries[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{FractionBox[x,y]}})

({{FrameBox[box]}})

({{Framed[expr]}})

({{FreeQ[expr,form]}})

({{FreeQ[expr,form,levelspec]}})

({{FreeQ[form]}})

({{FrequencySamplingFilterKernel[{(Subscript[a, 1]),…,(Subscript[a, k])}]}})

({{FrequencySamplingFilterKernel[{(Subscript[a, 1]),…,(Subscript[a, k])},m]}})

({{FromAbsoluteTime[time]}})

({{FromJulianDate[jd]}})

({{FromJulianDate["type",jd]}})

({{FromUnixTime[time]}})

({{FullForm[expr]}})

({{FullInformationOutputRegulator[sys,rspec]}})

({{FullInformationOutputRegulator[{sys,{(Subscript[out, 1]),…},{(Subscript[in, 1]),…}},…]}})

({{FullSimplify[expr]}})

({{FullSimplify[expr,assum]}})

({{FunctionDomain[f,x]}})

({{FunctionDomain[f,x,dom]}})

({{FunctionDomain[funs,vars,dom]}})

({{FunctionDomain[{funs,cons},vars,dom]}})

({{FunctionExpand[expr]}})

({{FunctionExpand[expr,assum]}})

({{FunctionRange[f,x,y]}})

({{FunctionRange[f,x,y,dom]}})

({{FunctionRange[funs,xvars,yvars,dom]}})

({{FunctionRange[{funs,cons},xvars,yvars,dom]}})

({{GaborFilter[data,r,k]}})

({{GaborFilter[data,r,k,ϕ]}})

({{GaborMatrix[r,k]}})

({{GaborMatrix[r,k,ϕ]}})

({{GaborMatrix[{r,σ},…]}})

({{GaborMatrix[{{(Subscript[r, 1]),(Subscript[r, 2]),…}},…]}})

({{GainMargins[lsys]}})

({{GainPhaseMargins[lsys]}})

({{GalleryView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{GalleryView[{(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{GatedRecurrentLayer[n]}})

({{GatedRecurrentLayer[n,opts]}})

({{GaussianFilter[data,r]}})

({{GaussianFilter[data,r,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{GaussianFilter[data,{{(Subscript[r, 1]),(Subscript[r, 2]),…},…}]}})

({{GaussianMatrix[r]}})

({{GaussianMatrix[{r,σ}]}})

({{GaussianMatrix[r,{(Subscript[n, 1]),(Subscript[n, 2])}]}})

({{GaussianMatrix[r,{{(Subscript[n, 11]),(Subscript[n, 12])},{(Subscript[n, 21]),(Subscript[n, 22])},…}]}})

({{GaussianMatrix[{{(Subscript[r, 1]),(Subscript[r, 2]),…},σ},…]}})

({{GeneralizedLinearModelFit[{(Subscript[y, 1]),(Subscript[y, 2]),…},{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{GeneralizedLinearModelFit[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{GeneralizedLinearModelFit[{m,v}]}})

({{GenerateAsymmetricKeyPair[]}})

({{GenerateAsymmetricKeyPair[opts]}})

({{GenerateSymmetricKey[]}})

({{GenerateSymmetricKey["password"]}})

({{GenerateSymmetricKey[opts]}})

({{GeneratingFunction[expr,n,x]}})

({{GeneratingFunction[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{GenericCylindricalDecomposition[ineqs,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{GeoArea[g]}})

({{GeoBoundingBox[g]}})

({{GeoBoundingBox[g,δ]}})

({{GeoBoundingBox[g,Scaled[s]]}})

({{GeoBounds[g]}})

({{GeoBounds[g,δ]}})

({{GeoBounds[g,Scaled[s]]}})

({{GeoBubbleChart[{(Subscript[reg, 1])->(Subscript[val, 1]),(Subscript[reg, 2])->(Subscript[val, 2]),…}]}})

({{GeoBubbleChart[regions->values]}})

({{GeoBubbleChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{GeoBubbleChart[{…,w[(Subscript[data, i])],…}]}})

({{GeodesicDilation[marker,mask]}})

({{GeodesicErosion[marker,mask]}})

({{GeoDistance[{(Subscript[lat, 1]),(Subscript[lon, 1])},{(Subscript[lat, 2]),(Subscript[lon, 2])}]}})

({{GeoDistance[(Subscript[loc, 1]),(Subscript[loc, 2])]}})

({{GeoDistance[{(Subscript[loc, 1]),…,(Subscript[loc, n])}]}})

({{GeoDistanceList[{(Subscript[loc, 1]),(Subscript[loc, 2]),…,(Subscript[loc, n])}]}})

({{GeoElevationData[]}})

({{GeoElevationData[loc]}})

({{GeoElevationData[{(Subscript[loc, 1]),(Subscript[loc, 2])}]}})

({{GeoElevationData[GeoPosition[{{(Subscript[lat, 1]),(Subscript[lon, 1])},{(Subscript[lat, 2]),(Subscript[lon, 2])},…}]]}})

({{GeoElevationData[loc,etype]}})

({{GeoElevationData[loc,etype,format]}})

({{GeoEntities[reg,enttype]}})

({{GeoGraphics[primitives,options]}})

({{GeogravityModelData[]}})

({{GeogravityModelData[locationspec]}})

({{GeogravityModelData[locationspec,component]}})

({{GeoHistogram[locs]}})

({{GeoHistogram[locs,bspec]}})

({{GeoHistogram[locs,bspec,hspec]}})

({{GeoIdentify[enttype]}})

({{GeoIdentify[enttype,loc]}})

({{GeoIdentify[]}})

({{GeoImage[reg]}})

({{GeoImage[reg,mapstyle]}})

({{GeoLength[g]}})

({{GeoListPlot[{(Subscript[loc, 1]),(Subscript[loc, 2]),…}]}})

({{GeomagneticModelData[]}})

({{GeomagneticModelData[locationspec]}})

({{GeomagneticModelData[datespec]}})

({{GeomagneticModelData[locationspec,datespec]}})

({{GeomagneticModelData[locationspec,datespec,component]}})

({{GeoMarker[]}})

({{GeoMarker[loc]}})

({{GeoMarker[{(Subscript[loc, 1]),(Subscript[loc, 2]),…}]}})

({{GeoMarker[loc,marker]}})

({{GeoMarker[{(Subscript[loc, 1]),(Subscript[loc, 2]),…},marker]}})

({{GeometricTransformation[g,tfun]}})

({{GeometricTransformation[g,m]}})

({{GeometricTransformation[g,{m,v}]}})

({{GeometricTransformation[g,{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{GeoNearest[enttype,loc]}})

({{GeoNearest[{(Subscript[reg, 1]),(Subscript[reg, 2]),…,(Subscript[reg, n])},loc]}})

({{GeoNearest[{(Subscript[reg, 1])->(Subscript[val, 1]),(Subscript[reg, 2])->(Subscript[val, 2]),…,(Subscript[reg, n])->(Subscript[val, n])},loc]}})

({{GeoNearest[{(Subscript[reg, 1]),(Subscript[reg, 2]),…,(Subscript[reg, n])}->{(Subscript[val, 1]),(Subscript[val, 2]),…,(Subscript[val, n])},loc]}})

({{GeoNearest[{(Subscript[reg, 1]),(Subscript[reg, 2]),…,(Subscript[reg, n])}->Automatic,loc]}})

({{GeoNearest[spec,loc,n]}})

({{GeoNearest[spec,loc,{n,r}]}})

({{GeoPath[{(Subscript[loc, 1]),(Subscript[loc, 2])},pathtype]}})

({{GeoPath[{(Subscript[loc, 1]),(Subscript[loc, 2]),…},pathtype]}})

({{GeoPath[{(Subscript[loc, 1]),d,α},pathtype]}})

({{GeoPath[{{(Subscript[loc, 11]),(Subscript[loc, 12]),…},{(Subscript[loc, 21]),…},…},pathtype]}})

({{GeoRegionValuePlot[{(Subscript[reg, 1])->(Subscript[val, 1]),(Subscript[reg, 2])->(Subscript[val, 2]),…}]}})

({{GeoRegionValuePlot[reg->val]}})

({{GeoRegionValuePlot[entityclass->val]}})

({{GeoStyling[mapstyle]}})

({{GeoStyling[mapstyle,directive]}})

({{GeoWithinQ[reg,loc]}})

({{GeoWithinQ[reg]}})

({{Get[stream]}})

({{GoodmanKruskalGammaTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{GoodmanKruskalGammaTest[…,"property"]}})

({{GradientFilter[data,r]}})

({{GradientFilter[data,{r,σ}]}})

({{GradientFilter[data,{{(Subscript[r, 1]),(Subscript[r, 2]),…},…}]}})

({{GradientOrientationFilter[data,r]}})

({{GradientOrientationFilter[data,{r,σ}]}})

({{GrammarApply[grammar,input]}})

({{GrammarRules[rules]}})

({{GrammarRules[rules,defs]}})

({{Graph[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{Graph[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{Graph[{…,(Subscript[w, i])[(Subscript[v, i]),…],…},{…,(Subscript[w, j])[(Subscript[e, j]),…],…}]}})

({{Graph3D[g]}})

({{Graph3D[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{Graph3D[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{GraphAssortativity[g]}})

({{GraphAssortativity[g,"prop"]}})

({{GraphAssortativity[g,{{(Subscript[v, i1]),(Subscript[v, i2]),…},…}]}})

({{GraphAssortativity[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}->{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{GraphAssortativity[{v->w,…},…]}})

({{GraphComplement[g]}})

({{GraphComplement[{v->w,…},…]}})

({{GraphDensity[g]}})

({{GraphDensity[{v->w,…}]}})

({{GraphDiameter[g]}})

({{GraphDiameter[{v->w,…}]}})

({{GraphDifference[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{GraphDifference[{v->w,…},…]}})

({{GraphDisjointUnion[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{GraphDisjointUnion[(Subscript[g, 1]),(Subscript[g, 2]),…]}})

({{GraphDisjointUnion[{v->w,…},…]}})

({{GraphDistance[g,s,t]}})

({{GraphDistance[g,s]}})

({{GraphDistance[{v->w,…},…]}})

({{GraphDistanceMatrix[g]}})

({{GraphDistanceMatrix[g,d]}})

({{GraphDistanceMatrix[{v->w,…},…]}})

({{Graphics[primitives,options]}})

({{Graphics3D[primitives,options]}})

({{GraphicsArray[{(Subscript[g, 1]),(Subscript[g, 2]),…}]}})

({{GraphicsArray[{{(Subscript[g, 11]),(Subscript[g, 12]),…},…}]}})

({{GraphicsColumn[{(Subscript[g, 1]),(Subscript[g, 2]),…}]}})

({{GraphicsColumn[list,alignment]}})

({{GraphicsColumn[list,alignment,spacing]}})

({{GraphicsComplex[{(Subscript[pt, 1]),(Subscript[pt, 2]),…},data]}})

({{GraphicsGrid[{{(Subscript[g, 11]),(Subscript[g, 12]),…},…}]}})

({{GraphicsGroup[{(Subscript[g, 1]),(Subscript[g, 2]),…}]}})

({{GraphicsRow[{(Subscript[g, 1]),(Subscript[g, 2]),…}]}})

({{GraphicsRow[list,spacing]}})

({{GraphIntersection[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{GraphIntersection[(Subscript[g, 1]),(Subscript[g, 2]),…]}})

({{GraphIntersection[{v->w,…},…]}})

({{GraphPeriphery[g]}})

({{GraphPeriphery[{v->w,…}]}})

({{GraphPlot[g]}})

({{GraphPlot[{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[v, i2])->(Subscript[v, j2]),…}]}})

({{GraphPlot[{{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[lbl, 1])},…}]}})

({{GraphPlot[m]}})

({{GraphPlot3D[g]}})

({{GraphPlot3D[{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[v, i2])->(Subscript[v, j2]),…}]}})

({{GraphPlot3D[{{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[lbl, 1])},…}]}})

({{GraphPlot3D[m]}})

({{GraphPower[g,n]}})

({{GraphPower[{v->w,…},…]}})

({{GraphPropertyDistribution[expr,x\[Distributed]gdist]}})

({{GraphPropertyDistribution[expr,{(Subscript[x, 1])\[Distributed](Subscript[gdist, 1]),(Subscript[x, 2])\[Distributed](Subscript[gdist, 2]),…}]}})

({{GraphReciprocity[g]}})

({{GraphReciprocity[{v->w,…}]}})

({{GraphUnion[(Subscript[g, 1]),(Subscript[g, 2])]}})

({{GraphUnion[(Subscript[g, 1]),(Subscript[g, 2]),…]}})

({{GraphUnion[{v->w,…},…]}})

({{GreenFunction[{ℒ[u[x]],ℬ[u[x]]},u,{x,(Subscript[x, min]),(Subscript[x, max])},y]}})

({{GreenFunction[{ℒ[u[(Subscript[x, 1]),(Subscript[x, 2]),…]],ℬ[u[(Subscript[x, 1]),(Subscript[x, 2]),…]]},u,{(Subscript[x, 1]),(Subscript[x, 2]),…}∈Ω,{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{GreenFunction[{ℒ[u[x,t]],ℬ[u[x,t]]},u,{x,(Subscript[x, min]),(Subscript[x, max])},t,{y,τ}]}})

({{GreenFunction[{ℒ[u[(Subscript[x, 1]),…,t]],ℬ[u[(Subscript[x, 1]),…,t]]},u,{(Subscript[x, 1]),…}∈Ω,t,{(Subscript[y, 1]),…,τ}]}})

({{Grid[{{(Subscript[expr, 11]),(Subscript[expr, 12]),…},{(Subscript[expr, 21]),(Subscript[expr, 22]),…},…}]}})

({{GridBox[{{(Subscript[box, 11]),(Subscript[box, 12]),…},{(Subscript[box, 21]),(Subscript[box, 22]),…},…}]}})

({{GridGraph[{m,n}]}})

({{GridGraph[{(Subscript[n, 1]),(Subscript[n, 2]),…,(Subscript[n, k])}]}})

({{GroebnerBasis[{(Subscript[poly, 1]),(Subscript[poly, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{GroebnerBasis[{(Subscript[poly, 1]),(Subscript[poly, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{GroupElementPosition[group,g]}})

({{GroupElementPosition[group,{(Subscript[g, 1]),…,(Subscript[g, n])}]}})

({{GroupElements[group]}})

({{GroupElements[group,{(Subscript[r, 1]),…,(Subscript[r, k])}]}})

({{GroupElementToWord[group,g]}})

({{GroupStabilizerChain[group]}})

({{GrowCutComponents[image,{(Subscript[marker, 1]),(Subscript[marker, 2]),…}]}})

({{GuidedFilter[image,guide,r,ϵ]}})

({{GuidedFilter[image,r,ϵ]}})

({{HadamardMatrix[n]}})

({{HammingDistance[u,v]}})

({{HankelTransform[expr,r,s]}})

({{HankelTransform[expr,r,s,ν]}})

({{HararyGraph[k,n]}})

({{HermiteDecomposition[m]}})

({{HermitianMatrixQ[m]}})

({{HessenbergDecomposition[m]}})

({{Hexahedron[{(Subscript[p, 1]),(Subscript[p, 2]),…,(Subscript[p, 8])}]}})

({{Hexahedron[{{(Subscript[p, 1,1]),(Subscript[p, 1,2]),…,(Subscript[p, 1,8])},{(Subscript[p, 2,1]),…},…}]}})

({{Highlighted[expr]}})

({{HighlightGraph[g,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{HighlightGraph[g,{…,(Subscript[w, j])[(Subscript[a, j])],…}]}})

({{HighlightGraph[{v->w,…},…]}})

({{HighlightImage[image,roi]}})

({{HighlightImage[image,{(Subscript[roi, 1]),(Subscript[roi, 2]),…}]}})

({{HighlightImage[image,{…,w[(Subscript[roi, i])],…}]}})

({{HighlightImage[image,fg,bgstyle]}})

({{HighlightMesh[mr,{(Subscript[cellspec, 1]),(Subscript[cellspec, 2]),…}]}})

({{HighlightMesh[mr,{…,(Subscript[w, j])[(Subscript[cellspec, j])],…}]}})

({{HighpassFilter[data,(Subscript[ω, c])]}})

({{HighpassFilter[data,(Subscript[ω, c]),n]}})

({{HighpassFilter[data,(Subscript[ω, c]),n,wfun]}})

({{HilbertCurve[n]}})

({{HilbertCurve[n,d]}})

({{HilbertFilter[data,(Subscript[ω, c])]}})

({{HilbertFilter[data,(Subscript[ω, c]),n]}})

({{HilbertFilter[data,(Subscript[ω, c]),n,wfun]}})

({{HilbertMatrix[n]}})

({{HilbertMatrix[{m,n}]}})

({{Histogram[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Histogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},bspec]}})

({{Histogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},bspec,hspec]}})

({{Histogram[{(Subscript[data, 1]),(Subscript[data, 2]),…},…]}})

({{Histogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{Histogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},bspec]}})

({{Histogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},bspec,hspec]}})

({{Histogram3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{HistogramList[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{HistogramList[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…}]}})

({{HistogramList[…,bspec]}})

({{HistogramList[…,bspec,hspec]}})

({{HitMissTransform[image,ker]}})

({{HitMissTransform[image,{(Subscript[ker, 1]),(Subscript[ker, 2]),…}]}})

({{HitMissTransform[image,{(Subscript[ker, 1]),(Subscript[ker, 2]),…},t]}})

({{HITSCentrality[g]}})

({{HITSCentrality[{v->w,…}]}})

({{HoeffdingDTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{HoeffdingDTest[…,"property"]}})

({{HorizontalGauge[value]}})

({{HorizontalGauge[value,{min,max}]}})

({{HorizontalGauge[Dynamic[value],…]}})

({{HorizontalGauge[{(Subscript[value, 1]),(Subscript[value, 2]),…},…]}})

({{HTTPRequest[url]}})

({{HTTPRequest[assoc]}})

({{HTTPRequest[url,assoc]}})

({{HTTPResponse[body]}})

({{HTTPResponse[body,metadata]}})

({{HumanGrowthData[spec]}})

({{HumanGrowthData[spec,property]}})

({{HumanGrowthData[spec,index]}})

({{HumanGrowthData[spec,property,index]}})

({{HumanGrowthData[spec,property,quantity]}})

({{HypercubeGraph[n]}})

({{Hyperlink[uri]}})

({{Hyperlink[label,uri]}})

({{IconData[property,quantity]}})

({{IdentityMatrix[n]}})

({{Image[data]}})

({{Image[graphics]}})

({{Image[obj,options]}})

({{Image3D[data]}})

({{Image3D[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{Image3D[obj,"type"]}})

({{ImageAccumulate[image]}})

({{ImageAlign[ref,image]}})

({{ImageAlign[ref,{(Subscript[image, 1]),…,(Subscript[image, n])}]}})

({{ImageAlign[{(Subscript[image, 1]),…,(Subscript[image, n])}]}})

({{ImageApply[f,image]}})

({{ImageApply[f,{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageApplyIndexed[f,image]}})

({{ImageApplyIndexed[f,{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageAugmentationLayer[{h,w}]}})

({{ImageCapture[]}})

({{ImageCollage[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageCollage[{(Subscript[w, 1])->(Subscript[image, 1]),(Subscript[w, 2])->(Subscript[image, 2]),…}]}})

({{ImageCollage[{(Subscript[w, 1]),(Subscript[w, 2]),…}->{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageCollage[{{(Subscript[image, 1]),(Subscript[w, 1])},{(Subscript[image, 2]),(Subscript[w, 2])},…}]}})

({{ImageCollage[…,fitting]}})

({{ImageCollage[…,fitting,size]}})

({{ImageConvolve[image,ker]}})

({{ImageCooccurrence[image,n]}})

({{ImageCooccurrence[image,n,ker]}})

({{ImageCorners[image]}})

({{ImageCorners[image,r]}})

({{ImageCorners[image,r,t]}})

({{ImageCorners[image,r,t,d]}})

({{ImageCorrelate[image,ker]}})

({{ImageCorrelate[image,ker,f]}})

({{ImageCorrespondingPoints[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageCrop[image]}})

({{ImageCrop[image,size]}})

({{ImageCrop[image,size,spec]}})

({{ImageData[image]}})

({{ImageData[image,"type"]}})

({{ImageDeconvolve[image,ker]}})

({{ImageDisplacements[{(Subscript[image, 1]),(Subscript[image, 2]),…,(Subscript[image, n])}]}})

({{ImageDisplacements[{(Subscript[image, 1]),(Subscript[image, 2]),…,(Subscript[image, n])},flow]}})

({{ImageDistance[(Subscript[image, 1]),(Subscript[image, 2])]}})

({{ImageDistance[(Subscript[image, 1]),(Subscript[image, 2]),pos]}})

({{ImageDistance[(Subscript[image, 1]),(Subscript[image, 2]),(Subscript[pos, 1]),(Subscript[pos, 2])]}})

({{ImageEffect[image,"effect"]}})

({{ImageEffect[image,{"effect",params}]}})

({{ImageExposureCombine[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageExposureCombine[{(Subscript[image, 1]),(Subscript[image, 2]),…},mode]}})

({{ImageFeatureTrack[{(Subscript[image, 1]),(Subscript[image, 2]),…,(Subscript[image, n])}]}})

({{ImageFeatureTrack[{(Subscript[image, 1]),(Subscript[image, 2]),…,(Subscript[image, n])},pts]}})

({{ImageFileApply[f,"inputfile","outputfile"]}})

({{ImageFileFilter[f,"inputfile",r,"outputfile"]}})

({{ImageFileScan[f,"inputfile"]}})

({{ImageFilter[f,image,r]}})

({{ImageFocusCombine[{(Subscript[image, 1]),(Subscript[image, 2]),…}]}})

({{ImageForwardTransformation[image,function]}})

({{ImageForwardTransformation[image,function,size]}})

({{ImageGraphics[image]}})

({{ImageGraphics[image,n]}})

({{ImageGraphics[image,colors]}})

({{ImageHistogram[image]}})

({{ImageHistogram[image,bspec]}})

({{ImageHistogram[image,bspec,range]}})

({{ImageIdentify[image]}})

({{ImageIdentify[image,category]}})

({{ImageIdentify[image,category,n]}})

({{ImageIdentify[image,category,n,"prop"]}})

({{ImageInstanceQ[image,obj]}})

({{ImageInstanceQ[image,(Subscript[obj, 1])|(Subscript[obj, 2])|…]}})

({{ImageInstanceQ[image,obj,category]}})

({{ImageKeypoints[image]}})

({{ImageKeypoints[image,prop]}})

({{ImageLevels[image]}})

({{ImageLevels[image,bspec]}})

({{ImageLevels[image,bspec,range]}})

({{ImageLines[image]}})

({{ImageLines[image,t]}})

({{ImageLines[image,t,d]}})

({{ImageMeasurements[image,"prop"]}})

({{ImageMeasurements[image,"prop",format]}})

({{ImageMeasurements[{(Subscript[image, 1]), (Subscript[image, 2]), …},…]}})

({{ImageMesh[image]}})

({{ImagePartition[image,s]}})

({{ImagePartition[image,{w,h}]}})

({{ImagePartition[image,{w,h},{dw,dh}]}})

({{ImagePeriodogram[image]}})

({{ImagePeriodogram[image,n]}})

({{ImagePeriodogram[image,n,d]}})

({{ImagePeriodogram[image,n,d,wfun]}})

({{ImagePeriodogram[image,n,d,wfun,m]}})

({{ImagePerspectiveTransformation[image,m]}})

({{ImagePerspectiveTransformation[image,tf]}})

({{ImagePerspectiveTransformation[image,…,size]}})

({{ImageResize[image,width]}})

({{ImageResize[image,{s}]}})

({{ImageResize[image,{width,height}]}})

({{ImageResize[image,{width,depth,height}]}})

({{ImageRestyle[image,sample]}})

({{ImageRestyle[image,w->sample]}})

({{ImageRestyle[image,{(Subscript[sample, 1]),…}]}})

({{ImageRestyle[image,{(Subscript[w, 1])->(Subscript[sample, 1]),…}]}})

({{ImageRotate[image]}})

({{ImageRotate[image,θ]}})

({{ImageRotate[image,{θ,w}]}})

({{ImageRotate[image,…,size]}})

({{ImageSaliencyFilter[image]}})

({{ImageScan[f,image]}})

({{ImageTransformation[image,f]}})

({{ImageTransformation[image,f,size]}})

({{ImageTrim[image,roi]}})

({{ImageTrim[image,roi,r]}})

({{ImageTrim[image,{(Subscript[roi, 1]),(Subscript[roi, 2]),…},…]}})

({{ImageValue[image,pos]}})

({{ImageValue[image,pos,"type"]}})

({{Inactivate[expr]}})

({{Inactivate[expr,patt]}})

({{IncidenceGraph[m]}})

({{IncidenceGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},m]}})

({{IndefiniteMatrixQ[m]}})

({{IndependenceTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{IndependenceTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{IndependenceTest[…,"property"]}})

({{InflationAdjust[quantity,targetdate]}})

({{InflationAdjust[quantity]}})

({{InflationAdjust[quantity,targetunit]}})

({{InflationAdjust[timeseries,targetdate]}})

({{Information[symbol]}})

({{InitializationObjects[]}})

({{InitializationObjects["patt"]}})

({{InitializationObjects["patt",loc]}})

({{InitializationObjects["patt",{(Subscript[loc, 1]),…}]}})

({{InitializationValue[sym]}})

({{InitializationValue["context`name"]}})

({{InitializationValue[sym,{(Subscript[loc, 1]),…}]}})

({{Initialize[sym]}})

({{Initialize[sym,{(Subscript[loc, 1]),…}]}})

({{Initialize["patt"]}})

({{Inpaint[image,region]}})

({{Input[]}})

({{Input[prompt]}})

({{Input[prompt,init]}})

({{InputField[]}})

({{InputField[x]}})

({{InputField[Dynamic[x]]}})

({{InputField[x,String]}})

({{InputField[x,Number]}})

({{InputField[x,type]}})

({{InputForm[expr]}})

({{InputString[]}})

({{InputString[prompt]}})

({{InputString[prompt,init]}})

({{Inset[obj]}})

({{Inset[obj,pos]}})

({{Inset[obj,pos,opos]}})

({{Inset[obj,pos,opos,size]}})

({{Inset[obj,pos,opos,size,dirs]}})

({{Install["name"]}})

({{InstallService["url"]}})

({{InstallService["url", "context`"]}})

({{InstanceNormalizationLayer[]}})

({{IntegerName[n]}})

({{IntegerName[n,"type"]}})

({{InteractiveTradingChart[{{(Subscript[date, 1]),{(Subscript[open, 1]),(Subscript[high, 1]),(Subscript[low, 1]),(Subscript[close, 1]),(Subscript[volume, 1])}},…}]}})

({{InteractiveTradingChart[{"name",daterange}]}})

({{InteractiveTradingChart[{…},{(Subscript[ind, 1]),(Subscript[ind, 2]),…}]}})

({{InternallyBalancedDecomposition[ssm]}})

({{InterpolatingPolynomial[{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{InterpolatingPolynomial[{{(Subscript[x, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[f, 2])},…},x]}})

({{InterpolatingPolynomial[{{{(Subscript[x, 1]),(Subscript[y, 1]),…},(Subscript[f, 1])},{{(Subscript[x, 2]),(Subscript[y, 2]),…},(Subscript[f, 2])},…},{x,y,…}]}})

({{InterpolatingPolynomial[{{{(Subscript[x, 1]),…},(Subscript[f, 1]),(Subscript[df, 1]),…},…},{x,…}]}})

({{Interpolation[{(Subscript[f, 1]),(Subscript[f, 2]),…}]}})

({{Interpolation[{{(Subscript[x, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[f, 2])},…}]}})

({{Interpolation[{{{(Subscript[x, 1]),(Subscript[y, 1]),…},(Subscript[f, 1])},{{(Subscript[x, 2]),(Subscript[y, 2]),…},(Subscript[f, 2])},…}]}})

({{Interpolation[{{{(Subscript[x, 1]),…},(Subscript[f, 1]),(Subscript[df, 1]),…},…}]}})

({{Interpolation[data,x]}})

({{Interpretation[e,expr]}})

({{Interpretation[{x=(Subscript[x, 0]),y=(Subscript[y, 0]),…},e,expr]}})

({{InterpretationBox[boxes,expr]}})

({{Interpreter[form]}})

({{Interpreter[form,test]}})

({{Interpreter[form,test,fail]}})

({{Intersection[(Subscript[list, 1]),(Subscript[list, 2]),…]}})

({{IntervalSlider[{xmin,xmax}]}})

({{IntervalSlider[Dynamic[int]]}})

({{IntervalSlider[int,{min,max}]}})

({{IntervalSlider[int,{min,max,dx}]}})

({{Inverse[m]}})

({{InverseContinuousWaveletTransform[cwd]}})

({{InverseContinuousWaveletTransform[cwd,wave]}})

({{InverseContinuousWaveletTransform[cwd,wave,octvoc]}})

({{InverseDistanceTransform[image]}})

({{InverseFourier[list]}})

({{InverseFourier[list,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{InverseFourierCosTransform[expr,ω,t]}})

({{InverseFourierCosTransform[expr,{(Subscript[ω, 1]),(Subscript[ω, 2]),…},{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{InverseFourierSequenceTransform[expr,ω,n]}})

({{InverseFourierSequenceTransform[expr,{(Subscript[ω, 1]),(Subscript[ω, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{InverseFourierSinTransform[expr,ω,t]}})

({{InverseFourierSinTransform[expr,{(Subscript[ω, 1]),(Subscript[ω, 2]),…},{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{InverseFourierTransform[expr,ω,t]}})

({{InverseFourierTransform[expr,{(Subscript[ω, 1]),(Subscript[ω, 2]),…},{(Subscript[t, 1]),(Subscript[t, 2]),…}]}})

({{InverseHankelTransform[expr,s,r]}})

({{InverseHankelTransform[expr,s,r,ν]}})

({{InverseMellinTransform[expr,s,x]}})

({{InverseRadon[image]}})

({{InverseRadon[image,{w,h}]}})

({{InverseRadonTransform[expr,{p,ϕ},{x,y}]}})

({{InverseTransformedRegion[reg,f,n]}})

({{InverseWaveletTransform[dwd]}})

({{InverseWaveletTransform[dwd,wave]}})

({{InverseWaveletTransform[dwd,wave,wind]}})

({{InverseZTransform[expr,z,n]}})

({{InverseZTransform[expr,{(Subscript[z, 1]),(Subscript[z, 2]),…},{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{IrreduciblePolynomialQ[poly]}})

({{IrreduciblePolynomialQ[poly,Modulus->p]}})

({{IrreduciblePolynomialQ[poly,Extension->{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{IrreduciblePolynomialQ[poly,Extension->All]}})

({{Item[expr,options]}})

({{ItoProcess[{a,b},x,t]}})

({{ItoProcess[{a,b,c},x,t]}})

({{ItoProcess[…,{x,(Subscript[x, 0])},{t,(Subscript[t, 0])}]}})

({{ItoProcess[…,…,…,Σ]}})

({{ItoProcess[proc]}})

({{ItoProcess[sdeqns,expr,x,t,w\[Distributed]dproc]}})

({{JarqueBeraALMTest[data]}})

({{JarqueBeraALMTest[data,"property"]}})

({{JoinAcross[{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},key]}})

({{JoinAcross[{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},{(Subscript[key, 1]),(Subscript[key, 2]),…}]}})

({{JoinAcross[{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},(Subscript[key, a])->(Subscript[key, b])]}})

({{JoinAcross[{(Subscript[a, 1]),(Subscript[a, 2]),…},{(Subscript[b, 1]),(Subscript[b, 2]),…},{(Subscript[key, (Subscript[a, 1])])->(Subscript[key, (Subscript[b, 1])]),…}]}})

({{JoinAcross[alist,blist,spec,"jspec"]}})

({{JoinedCurve[{(Subscript[segment, 1]),(Subscript[segment, 2]),…}]}})

({{JoinedCurve[{(Subscript[component, 1]),(Subscript[component, 2]),…}]}})

({{JuliaSetBoettcher[c,z]}})

({{JuliaSetIterationCount[f,z,p]}})

({{JuliaSetIterationCount[c,p]}})

({{JuliaSetIterationCount[f,z,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{JuliaSetIterationCount[c,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{JuliaSetPlot[f,z]}})

({{JuliaSetPlot[c]}})

({{JuliaSetPoints[f,z]}})

({{JuliaSetPoints[c]}})

({{KagiChart[{{(Subscript[date, 1]),(Subscript[p, 1])},{(Subscript[date, 2]),(Subscript[p, 2])},…}]}})

({{KagiChart[{"name",daterange}]}})

({{KagiChart[{…},rt]}})

({{KalmanEstimator[ssm,{w,v}]}})

({{KalmanEstimator[ssm,{w,v,h}]}})

({{KalmanEstimator[{ssm,sensors},{…}]}})

({{KalmanEstimator[{ssm,sensors,dinputs},{…}]}})

({{KarhunenLoeveDecomposition[{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{KarhunenLoeveDecomposition[{(Subscript[b, 1]),(Subscript[b, 2]),…},m]}})

({{KaryTree[n]}})

({{KaryTree[n,k]}})

({{KatzCentrality[g,α]}})

({{KatzCentrality[g,α,β]}})

({{KatzCentrality[{v->w,…},…]}})

({{KendallTauTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{KendallTauTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{KendallTauTest[…,"property"]}})

({{KernelMixtureDistribution[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{KernelMixtureDistribution[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…}]}})

({{KernelMixtureDistribution[…,bw]}})

({{KernelMixtureDistribution[…,bw,ker]}})

({{KeyComplement[{(Subscript[assoc, all]),(Subscript[assoc, 1]),(Subscript[assoc, 2]),…}]}})

({{KirchhoffGraph[kmat]}})

({{KirchhoffGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},kmat]}})

({{KnightTourGraph[m,n]}})

({{KochCurve[n]}})

({{KochCurve[n,{(Subscript[θ, 1]),(Subscript[θ, 2]),…}]}})

({{KochCurve[n,{{(Subscript[r, 1]),(Subscript[θ, 1])},{(Subscript[r, 2]),(Subscript[θ, 2])},…}]}})

({{KolmogorovSmirnovTest[data]}})

({{KolmogorovSmirnovTest[data,dist]}})

({{KolmogorovSmirnovTest[data,dist,"property"]}})

({{KroneckerModelDecomposition[ssm]}})

({{KuiperTest[data]}})

({{KuiperTest[data,dist]}})

({{KuiperTest[data,dist,"property"]}})

({{Labeled[expr,lbl]}})

({{Labeled[expr,lbl,pos]}})

({{Labeled[expr,{(Subscript[lbl, 1]),(Subscript[lbl, 2]),…},{(Subscript[pos, 1]),…}]}})

({{Labeled[expr,{(Subscript[lbl, 1]),(Subscript[lbl, 2]),(Subscript[lbl, 3]),(Subscript[lbl, 4])},All]}})

({{LaplaceTransform[expr,t,s]}})

({{LaplaceTransform[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{LaplacianFilter[data,r]}})

({{LaplacianFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{LaplacianGaussianFilter[data,r]}})

({{LayeredGraphPlot[g]}})

({{LayeredGraphPlot[{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[v, i2])->(Subscript[v, j2]),…}]}})

({{LayeredGraphPlot[{{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[lbl, 1])},…}]}})

({{LayeredGraphPlot[g,pos]}})

({{LayeredGraphPlot[m]}})

({{LeapYearQ[date]}})

({{LeastSquares[m,b]}})

({{LeastSquaresFilterKernel[{{(Subscript[ω, 1]),…,(Subscript[ω, k-1])},{(Subscript[a, 1]),…,(Subscript[a, k])}},n]}})

({{LeastSquaresFilterKernel[{"type",spec},n]}})

({{LerchPhi[z,s,a]}})

({{LetterCounts["string"]}})

({{LetterCounts["string",n]}})

({{LetterCounts["string",n,{"(Subscript[c, 1])","(Subscript[c, 2])",…}]}})

({{Level[expr,levelspec]}})

({{Level[expr,levelspec,f]}})

({{LeveneTest[data]}})

({{LeveneTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{LeveneTest[dspec,(Subscript[σ, 0]^2)]}})

({{LeveneTest[dspec,(Subscript[σ, 0]^2),"property"]}})

({{LibraryFunctionLoad[lib,fun,argtype,rettype]}})

({{LiftingFilterData[…]}})

({{LiftingWaveletTransform[data]}})

({{LiftingWaveletTransform[data,wave]}})

({{LiftingWaveletTransform[data,wave,r]}})

({{Line[{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{Line[{{(Subscript[p, 11]),(Subscript[p, 12]),…},{(Subscript[p, 21]),…},…}]}})

({{LinearGradientImage[gcol]}})

({{LinearGradientImage[{(Subscript[pos, 1]),(Subscript[pos, 2])}->gcol]}})

({{LinearGradientImage[…,size]}})

({{LinearLayer[n]}})

({{LinearLayer[{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{LinearLayer[]}})

({{LinearLayer[n,opts]}})

({{LinearModelFit[{(Subscript[y, 1]),(Subscript[y, 2]),…},{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{LinearModelFit[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{LinearModelFit[{m,v}]}})

({{LinearProgramming[c,m,b]}})

({{LinearProgramming[c,m,{{(Subscript[b, 1]),(Subscript[s, 1])},{(Subscript[b, 2]),(Subscript[s, 2])},…}]}})

({{LinearProgramming[c,m,b,l]}})

({{LinearProgramming[c,m,b,{(Subscript[l, 1]),(Subscript[l, 2]),…}]}})

({{LinearProgramming[c,m,b,{{(Subscript[l, 1]),(Subscript[u, 1])},{(Subscript[l, 2]),(Subscript[u, 2])},…}]}})

({{LinearProgramming[c,m,b,lu,dom]}})

({{LinearProgramming[c,m,b,lu,{(Subscript[dom, 1]),(Subscript[dom, 2]),…}]}})

({{LinearSolve[m,b]}})

({{LinearSolve[m]}})

({{LineBreakChart[{{(Subscript[date, 1]),(Subscript[p, 1])},{(Subscript[date, 2]),(Subscript[p, 2])},…}]}})

({{LineBreakChart[{"name",daterange}]}})

({{LineBreakChart[{…},n]}})

({{LineGraph[g]}})

({{LineGraph[{v->w,…}]}})

({{LineLegend[{(Subscript[col, 1]),…},{(Subscript[lbl, 1]),…}]}})

({{LineLegend[{(Subscript[col, 1]),…},Automatic]}})

({{LineLegend[{(Subscript[lbl, 1]),…}]}})

({{LinkConnect["name"]}})

({{LinkCreate["name"]}})

({{LinkCreate[]}})

({{LinkLaunch["prog"]}})

({{LinkRankCentrality[g,α]}})

({{LinkRankCentrality[g,α,β]}})

({{LinkRankCentrality[{v->w,…},…]}})

({{LiouvilleLambda[n]}})

({{ListAnimate[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{ListAnimate[list,fps]}})

({{ListContourPlot[array]}})

({{ListContourPlot[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[f, 2])},…}]}})

({{ListContourPlot3D[array]}})

({{ListContourPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2]),(Subscript[f, 2])},…}]}})

({{ListCurvePathPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListDeconvolve[ker,list]}})

({{ListDensityPlot[array]}})

({{ListDensityPlot[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[f, 2])},…}]}})

({{ListDensityPlot3D[array]}})

({{ListDensityPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2]),(Subscript[f, 2])},…}]}})

({{ListFourierSequenceTransform[list,ω]}})

({{ListFourierSequenceTransform[list,ω,k]}})

({{ListFourierSequenceTransform[list,{(Subscript[ω, 1]),(Subscript[ω, 2]),…},{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{ListInterpolation[array]}})

({{ListInterpolation[array,{{(Subscript[x, min]),(Subscript[x, max])},{(Subscript[y, min]),(Subscript[y, max])},…}]}})

({{ListLinePlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListLinePlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListLinePlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListLinePlot[{…,w[(Subscript[data, i]),…],…}]}})

({{ListLogLinearPlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListLogLinearPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListLogLinearPlot[{(Subscript[list, 1]),(Subscript[list, 2]),…}]}})

({{ListLogLinearPlot[{…,w[(Subscript[data, i]),…],…}]}})

({{ListLogLogPlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListLogLogPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListLogLogPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListLogPlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListLogPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListLogPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListPicker[list,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{ListPicker[Dynamic[list],{(Subscript[val, 1]),…}]}})

({{ListPicker[list,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{ListPlay[{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{ListPlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListPlot[{…,w[(Subscript[data, i]),…],…}]}})

({{ListPlot3D[array]}})

({{ListPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{ListPlot3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListPointPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{ListPointPlot3D[array]}})

({{ListPointPlot3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListPolarPlot[{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{ListPolarPlot[{{(Subscript[θ, 1]),(Subscript[r, 1])},{(Subscript[θ, 2]),(Subscript[r, 2])},…}]}})

({{ListPolarPlot[{(Subscript[list, 1]),(Subscript[list, 2]),…}]}})

({{ListSliceContourPlot3D[array,surf]}})

({{ListSliceContourPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2]),(Subscript[f, 2])},…},surf]}})

({{ListSliceContourPlot3D[…,{(Subscript[surf, 1]),(Subscript[surf, 2]),…}]}})

({{ListSliceDensityPlot3D[array,surf]}})

({{ListSliceDensityPlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1]),(Subscript[f, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2]),(Subscript[f, 2])},…},surf]}})

({{ListSliceDensityPlot3D[…,{(Subscript[surf, 1]),(Subscript[surf, 2]),…}]}})

({{ListSliceVectorPlot3D[array,surf]}})

({{ListSliceVectorPlot3D[…,{(Subscript[surf, 1]),(Subscript[surf, 2]),…}]}})

({{ListStepPlot[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{ListStepPlot[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{ListStepPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListStepPlot[data,step]}})

({{ListStepPlot[{…,w[(Subscript[data, i]),…],…}]}})

({{ListStreamDensityPlot[array]}})

({{ListStreamDensityPlot[{{{(Subscript[x, 1]),(Subscript[y, 1])},{{(Subscript[vx, 1]),(Subscript[vy, 1])},(Subscript[s, 1])}},…}]}})

({{ListStreamDensityPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListStreamPlot[array]}})

({{ListStreamPlot[{{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[vx, 1]),(Subscript[vy, 1])}},…}]}})

({{ListStreamPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListSurfacePlot3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{ListVectorDensityPlot[array]}})

({{ListVectorDensityPlot[{{{(Subscript[x, 1]),(Subscript[y, 1])},{{(Subscript[vx, 1]),(Subscript[vy, 1])},(Subscript[s, 1])}},…}]}})

({{ListVectorDensityPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListVectorPlot[array]}})

({{ListVectorPlot[{{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[vx, 1]),(Subscript[vy, 1])}},…}]}})

({{ListVectorPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{ListVectorPlot3D[array]}})

({{ListVectorPlot3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{LocalAdaptiveBinarize[image,r]}})

({{LocalAdaptiveBinarize[image,r,{α,β,γ}]}})

({{LocalResponseNormalizationLayer[]}})

({{LocalSubmit[expr]}})

({{LocalSubmit[ScheduledTask[expr, spec]]}})

({{LocationEquivalenceTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{LocationEquivalenceTest[{(Subscript[data, 1]),…},"property"]}})

({{LocationTest[data]}})

({{LocationTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{LocationTest[dspec,(Subscript[μ, 0])]}})

({{LocationTest[dspec,(Subscript[μ, 0]),"property"]}})

({{Locator[{x,y}]}})

({{Locator[Dynamic[pos]]}})

({{Locator[{x,y},obj]}})

({{Locator[{x,y},None]}})

({{LocatorPane[{x,y},back]}})

({{LocatorPane[Dynamic[pt],back]}})

({{LocatorPane[{(Subscript[pt, 1]),(Subscript[pt, 2]),…},back]}})

({{LocatorPane[Dynamic[{(Subscript[pt, 1]),(Subscript[pt, 2]),…}],back]}})

({{LocatorPane[pts,back,{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])}}]}})

({{LocatorPane[pts,back,{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])},{dx,dy}}]}})

({{LogicalExpand[expr]}})

({{LogitModelFit[{(Subscript[y, 1]),(Subscript[y, 2]),…},{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{LogitModelFit[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},{(Subscript[f, 1]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{LogitModelFit[{m,v}]}})

({{LogRankTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{LogRankTest[{(Subscript[data, 1]),(Subscript[data, 2]),…},wspec]}})

({{LogRankTest[{(Subscript[data, 1]),…},wspec,"property"]}})

({{LongestCommonSequence[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{LongestCommonSequencePositions[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{LongestCommonSubsequence[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{LongestCommonSubsequencePositions[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{LongestOrderedSequence[list]}})

({{LongestOrderedSequence[list,p]}})

({{LongShortTermMemoryLayer[n]}})

({{LongShortTermMemoryLayer[n,opts]}})

({{LowpassFilter[data,(Subscript[ω, c])]}})

({{LowpassFilter[data,(Subscript[ω, c]),n]}})

({{LowpassFilter[data,(Subscript[ω, c]),n,wfun]}})

({{LQEstimatorGains[ssm,{w,v}]}})

({{LQEstimatorGains[ssm,{w,v,h}]}})

({{LQEstimatorGains[{ssm,sensors},{…}]}})

({{LQEstimatorGains[{ssm,sensors,dinputs},{…}]}})

({{LQGRegulator[{ssm,sensors,finputs},{w,v,h},{q,r,p}]}})

({{LQGRegulator[{ssm,sensors,finputs,einputs},{…},{…}]}})

({{LQOutputRegulatorGains[ssm,{q,r}]}})

({{LQOutputRegulatorGains[ssm,{q,r,p}]}})

({{LQOutputRegulatorGains[{ssm,sensors},{…}]}})

({{LQOutputRegulatorGains[{ssm,sensors,finputs},{…}]}})

({{LQRegulatorGains[ssm,{q,r}]}})

({{LQRegulatorGains[ssm,{q,r,p}]}})

({{LQRegulatorGains[{ssm,finputs},{…}]}})

({{LUDecomposition[m]}})

({{LunarEclipse[]}})

({{LunarEclipse[datespec]}})

({{LunarEclipse[propertyspec]}})

({{LunarEclipse[datespec,propertyspec]}})

({{MailReceiverFunction[fun]}})

({{MainSolve[eqns]}})

({{MainSolve[eqns, vars, elim, rest]}})

({{MandelbrotSetBoettcher[z]}})

({{MandelbrotSetDistance[c]}})

({{MandelbrotSetDistance[c,"Interior"]}})

({{MandelbrotSetIterationCount[c]}})

({{MandelbrotSetMemberQ[z]}})

({{MandelbrotSetPlot[{(Subscript[z, min]),(Subscript[z, max])}]}})

({{MandelbrotSetPlot[]}})

({{Manipulator[x]}})

({{Manipulator[Dynamic[x]]}})

({{Manipulator[x,{(Subscript[x, min]),(Subscript[x, max])}]}})

({{Manipulator[x,{(Subscript[x, min]),(Subscript[x, max]),dx}]}})

({{MannWhitneyTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{MannWhitneyTest[dspec,(Subscript[μ, 0])]}})

({{MannWhitneyTest[dspec,(Subscript[μ, 0]),"property"]}})

({{Map[f,expr]}})

({{Map[f,expr,levelspec]}})

({{Map[f]}})

({{MapAll[f,expr]}})

({{MapIndexed[f,expr]}})

({{MapIndexed[f,expr,levelspec]}})

({{MapIndexed[f]}})

({{MardiaCombinedTest[data]}})

({{MardiaCombinedTest[data,"property"]}})

({{MardiaKurtosisTest[data]}})

({{MardiaKurtosisTest[data,"property"]}})

({{MardiaSkewnessTest[data]}})

({{MardiaSkewnessTest[data,"property"]}})

({{MatrixExp[m]}})

({{MatrixExp[m,v]}})

({{MatrixForm[list]}})

({{MatrixFunction[f,m]}})

({{MatrixLog[m]}})

({{MatrixPlot[m]}})

({{MatrixPower[m,n]}})

({{MatrixPower[m,n,v]}})

({{MatrixRank[m]}})

({{MaxDetect[image]}})

({{MaxDetect[image,h]}})

({{MaxDetect[data,…]}})

({{Maximize[f,x]}})

({{Maximize[f,{x,y,…}]}})

({{Maximize[{f,cons},{x,y,…}]}})

({{Maximize[…,x∈reg]}})

({{Maximize[…,…,dom]}})

({{MaxValue[f,x]}})

({{MaxValue[f,{x,y,…}]}})

({{MaxValue[{f,cons},{x,y,…}]}})

({{MaxValue[…,x∈reg]}})

({{MaxValue[…,…,dom]}})

({{MeanAbsoluteLossLayer[]}})

({{MeanGraphDistance[g]}})

({{MeanGraphDistance[{v->w,…}]}})

({{MeanShift[list,d]}})

({{MeanShift[list,d,{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{MeanShift[image,…]}})

({{MeanShiftFilter[data,r,d]}})

({{MeanShiftFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…},d]}})

({{MeanSquaredLossLayer[]}})

({{MeijerGReduce[expr,x]}})

({{MellinConvolve[f,g,x,y]}})

({{MellinConvolve[f,g,{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{MellinTransform[expr,x,s]}})

({{MellinTransform[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{MemberQ[list,form]}})

({{MemberQ[list,form,levelspec]}})

({{MemberQ[form]}})

({{MengerMesh[n]}})

({{MengerMesh[n,d]}})

({{MenuView[{(Subscript[lbl, 1])->(Subscript[expr, 1]),(Subscript[lbl, 2])->(Subscript[expr, 2]),…}]}})

({{MenuView[{(Subscript[lbl, 1])->(Subscript[expr, 1]),(Subscript[lbl, 2])->(Subscript[expr, 2]),…},i]}})

({{MenuView[{{(Subscript[v, 1]),(Subscript[lbl, 1])->(Subscript[expr, 1])},{(Subscript[v, 2]),(Subscript[lbl, 2])->(Subscript[expr, 2])},…},v]}})

({{MenuView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{MeshRegion[{(Subscript[p, 1]),(Subscript[p, 2]),…},{(Subscript[mcell, 1])[{(Subscript[i, 1]),…}],(Subscript[mcell, 2])[{(Subscript[j, 1]),…}],…}]}})

({{MeshRegion[…,{…,(Subscript[w, i])[(Subscript[mcell, i])[…]],…}]}})

({{MessageDialog[expr]}})

({{MessageDialog[expr,{(Subscript[lbl, 1]):>(Subscript[act, 1]),(Subscript[lbl, 2]):>(Subscript[act, 2]),…}]}})

({{Messages[symbol]}})

({{MinDetect[image]}})

({{MinDetect[image,h]}})

({{MinDetect[data,…]}})

({{MinimalPolynomial[s,x]}})

({{MinimalStateSpaceModel[sys]}})

({{MinimalStateSpaceModel[sys,{(Subscript[z, 1]),…}]}})

({{Minimize[f,x]}})

({{Minimize[f,{x,y,…}]}})

({{Minimize[{f,cons},{x,y,…}]}})

({{Minimize[…,x∈reg]}})

({{Minimize[…,…,dom]}})

({{MinValue[f,x]}})

({{MinValue[f,{x,y,…}]}})

({{MinValue[{f,cons},{x,y,…}]}})

({{MinValue[…,x∈reg]}})

({{MinValue[…,…,dom]}})

({{MomentOfInertia[reg,pt,v]}})

({{MomentOfInertia[reg]}})

({{MomentOfInertia[reg,pt]}})

({{MonomialList[poly]}})

({{MonomialList[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{MonomialList[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…},order]}})

({{MoonPosition[]}})

({{MoonPosition[datespec]}})

({{MoonPosition[locationspec]}})

({{MoonPosition[locationspec,datespec]}})

({{MoonPosition[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{MoonPosition[locationspec,datespec,func]}})

({{MorphologicalBinarize[image,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{MorphologicalBinarize[image,t]}})

({{MorphologicalBinarize[image]}})

({{MorphologicalBranchPoints[image]}})

({{MorphologicalComponents[image]}})

({{MorphologicalComponents[image,t]}})

({{MorphologicalEulerNumber[image]}})

({{MorphologicalEulerNumber[image,t]}})

({{MorphologicalGraph[image]}})

({{MorphologicalPerimeter[image]}})

({{MorphologicalPerimeter[image,t]}})

({{MorphologicalTransform[image,f]}})

({{MorphologicalTransform[image,rule]}})

({{MorphologicalTransform[image,"name"]}})

({{MorphologicalTransform[image,transformation,n]}})

({{MortalityData[spec]}})

({{MortalityData[spec,property]}})

({{Mouseover[expr,over]}})

({{Multicolumn[list,cols]}})

({{Multicolumn[list,{rows,Automatic}]}})

({{Multicolumn[list,{rows,cols}]}})

({{Multicolumn[list]}})

({{MultiplySides[rel,x]}})

({{MultiplySides[(Subscript[rel, 1]),(Subscript[rel, 2])]}})

({{Names["string"]}})

({{Names[patt]}})

({{NArgMax[f,x]}})

({{NArgMax[f,{x,y,…}]}})

({{NArgMax[{f,cons},{x,y,…}]}})

({{NArgMax[…,x∈reg]}})

({{NArgMin[f,x]}})

({{NArgMin[f,{x,y,…}]}})

({{NArgMin[{f,cons},{x,y,…}]}})

({{NArgMin[…,x∈reg]}})

({{NDEigensystem[ℒ[u[x,y,…],u,{x,y,…}∈Ω,n]}})

({{NDEigensystem[eqns,{u,…},t,{x,y,…}∈Ω,n]}})

({{NDEigenvalues[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n]}})

({{NDEigenvalues[eqns,{u,…},t,{x,y,…}∈Ω,n]}})

({{Nearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},x]}})

({{Nearest[{(Subscript[elem, 1])->(Subscript[v, 1]),(Subscript[elem, 2])->(Subscript[v, 2]),…},x]}})

({{Nearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…}->{(Subscript[v, 1]),(Subscript[v, 2]),…},x]}})

({{Nearest[{(Subscript[elem, 1]),(Subscript[elem, 2]),…}->prop,x]}})

({{Nearest[data,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Nearest[data,x,n]}})

({{Nearest[data,x,{n,r}]}})

({{Nearest[data]}})

({{NearestNeighborGraph[{(Subscript[elem, 1]),(Subscript[elem, 2]),…}]}})

({{NearestNeighborGraph[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},k]}})

({{NearestNeighborGraph[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},{k,r}]}})

({{NearestNeighborGraph[{(Subscript[elem, 1]),(Subscript[elem, 2]),…},{All,r}]}})

({{NearestTo[x]}})

({{NearestTo[x,n]}})

({{NearestTo[x,{n,r}]}})

({{NeedlemanWunschSimilarity[u,v]}})

({{NegativeSemidefiniteMatrixQ[m]}})

({{NeighborhoodGraph[g,v]}})

({{NeighborhoodGraph[g,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{NeighborhoodGraph[g,patt]}})

({{NeighborhoodGraph[g,…,d]}})

({{NeighborhoodGraph[{v->w,…},…]}})

({{NestGraph[f,expr,n]}})

({{NestGraph[f,{(Subscript[expr, 1]),(Subscript[expr, 2]),…},n]}})

({{NestGraph[f,graph,n]}})

({{NetFoldOperator[net]}})

({{NetInitialize[net]}})

({{NetInitialize[net,All]}})

({{NetMapOperator[net]}})

({{NetNestOperator[net,n]}})

({{NetPairEmbeddingOperator[net]}})

({{NetPairEmbeddingOperator[net,"DistanceFunction"->f]}})

({{NetReplace[net,patt->layer]}})

({{NetReplace[net,{(Subscript[rule, 1]),(Subscript[rule, 2]),…}]}})

({{NetTrain[net,{(Subscript[input, 1]),(Subscript[input, 2]),…}->{(Subscript[output, 1]),…}]}})

({{NetTrain[net,{(Subscript[input, 1])->(Subscript[output, 1]),(Subscript[input, 2])->(Subscript[output, 2]),…}]}})

({{NetTrain[net,\[LeftAssociation](Subscript[port, 1])->{(Subscript[data, 11]),(Subscript[data, 12]),…},(Subscript[port, 2])->{…},…\[RightAssociation]]}})

({{NetTrain[net,{\[LeftAssociation](Subscript[port, 1])->…,(Subscript[port, 2])->…,…\[RightAssociation],\[LeftAssociation](Subscript[port, 1])->…,…\[RightAssociation],…}]}})

({{NetTrain[net,f]}})

({{NetTrain[net,data,loss]}})

({{NetTrain[net,data,prop]}})

({{NExpectation[expr,x\[Distributed]dist]}})

({{NExpectation[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}\[Distributed]dist]}})

({{NExpectation[expr,{(Subscript[x, 1])\[Distributed](Subscript[dist, 1]),(Subscript[x, 2])\[Distributed](Subscript[dist, 2]),…}]}})

({{NExpectation[expr\[Conditioned]pred,…]}})

({{NextCell[]}})

({{NextCell[cellobj]}})

({{NextDate[gran]}})

({{NextDate[date,gran]}})

({{NMaximize[f,x]}})

({{NMaximize[f,{x,y,…}]}})

({{NMaximize[{f,cons},{x,y,…}]}})

({{NMaximize[…,x∈reg]}})

({{NMaxValue[f,x]}})

({{NMaxValue[f,{x,y,…}]}})

({{NMaxValue[{f,cons},{x,y,…}]}})

({{NMaxValue[…,x∈reg]}})

({{NMinimize[f,x]}})

({{NMinimize[f,{x,y,…}]}})

({{NMinimize[{f,cons},{x,y,…}]}})

({{NMinimize[…,x∈reg]}})

({{NMinValue[f,x]}})

({{NMinValue[f,{x,y,…}]}})

({{NMinValue[{f,cons},{x,y,…}]}})

({{NMinValue[…,x∈reg]}})

({{NondimensionalizationTransform[eq,ovars,fvars]}})

({{NondimensionalizationTransform[eq,ovars,fvars,prop]}})

({{NonlinearModelFit[{(Subscript[y, 1]),(Subscript[y, 2]),…},form,{(Subscript[β, 1]),…},x]}})

({{NonlinearModelFit[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},form,{(Subscript[β, 1]),…},{(Subscript[x, 1]),…}]}})

({{NonlinearModelFit[data,{form,cons},{(Subscript[β, 1]),…},{(Subscript[x, 1]),…}]}})

({{NonlinearStateSpaceModel[{f,g},x,u]}})

({{NonlinearStateSpaceModel[sys]}})

({{NonlinearStateSpaceModel[eqns,{{(Subscript[x, 1]),(Subscript[x, 10])},…},{{(Subscript[u, 1]),(Subscript[u, 10])},…},{(Subscript[g, 1]),…},t]}})

({{NonlocalMeansFilter[image,r]}})

({{NonlocalMeansFilter[image,r,ns]}})

({{NonlocalMeansFilter[image,r,ns,w]}})

({{Norm[expr]}})

({{Norm[expr,p]}})

({{NormalMatrixQ[m]}})

({{Notebook[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{NotebookApply[notebook,data]}})

({{NotebookApply[cell,data]}})

({{NotebookApply[notebook,data,sel]}})

({{NotebookClose[notebook]}})

({{NotebookClose[]}})

({{NotebookDelete[notebook]}})

({{NotebookDelete[obj]}})

({{NotebookDelete[{(Subscript[obj, 1]),(Subscript[obj, 2]),…}]}})

({{NotebookDelete[]}})

({{NotebookEvaluate[notebook]}})

({{NotebookFind[obj,data]}})

({{NotebookFind[obj,data,Previous]}})

({{NotebookFind[obj,data,All]}})

({{NotebookFind[obj,data,dir,elems]}})

({{NotebookGet[obj]}})

({{NotebookGet[]}})

({{NotebookImport[notebook,style]}})

({{NotebookImport[notebook,style->form]}})

({{NotebookPrint[expr]}})

({{NotebookPrint[notebook]}})

({{NotebookPrint[notebook,"file.ext"]}})

({{NotebookPrint[]}})

({{NotebookPut[expr]}})

({{NotebookPut[]}})

({{NotebookPut[expr,obj]}})

({{NotebookRead[notebook]}})

({{NotebookRead[obj]}})

({{NotebookRead[{(Subscript[obj, 1]),(Subscript[obj, 2]),…}]}})

({{Notebooks[]}})

({{NotebookSave[notebook]}})

({{NotebookSave[notebook,"file"]}})

({{NotebookSave[]}})

({{NotebookWrite[notebook,data]}})

({{NotebookWrite[obj,data]}})

({{NotebookWrite[obj,data,sel]}})

({{NProbability[pred,x\[Distributed]dist]}})

({{NProbability[pred,{(Subscript[x, 1]),(Subscript[x, 2]),…}\[Distributed]dist]}})

({{NProbability[pred,{(Subscript[x, 1])\[Distributed](Subscript[dist, 1]),(Subscript[x, 2])\[Distributed](Subscript[dist, 2]),…}]}})

({{NProbability[(Subscript[pred, 1])\[Conditioned](Subscript[pred, 2]),…]}})

({{NullSpace[m]}})

({{NumberForm[expr,n]}})

({{NumberForm[expr,{n,f}]}})

({{NumberForm[expr]}})

({{NumberLinePlot[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{NumberLinePlot[pred,x]}})

({{NumberLinePlot[pred,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{NumberLinePlot[{(Subscript[spec, 1]),(Subscript[spec, 2]),…},…]}})

({{Numerator[expr]}})

({{NValues[f]}})

({{ObservabilityGramian[ssm]}})

({{ObservableDecomposition[sys]}})

({{ObservableDecomposition[sys,{(Subscript[z, 1]),…}]}})

({{ObservableModelQ[sys]}})

({{ObservableModelQ[{sys,sub}]}})

({{Once[expr]}})

({{Once[expr,loc]}})

({{OpenAppend["file"]}})

({{Opener[x]}})

({{Opener[Dynamic[x]]}})

({{OpenerView[{(Subscript[expr, 1]),(Subscript[expr, 2])}]}})

({{OpenerView[{(Subscript[expr, 1]),(Subscript[expr, 2])},state]}})

({{OpenRead["file"]}})

({{OpenTemporary[]}})

({{OpenWrite["file"]}})

({{OpenWrite[]}})

({{Orthogonalize[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{Orthogonalize[{(Subscript[e, 1]),(Subscript[e, 2]),…},f]}})

({{OrthogonalMatrixQ[m]}})

({{OutputControllableModelQ[ssm]}})

({{Overlay[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{Overlay[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},{i,j,…}]}})

({{Overlay[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},{i,j,…},s]}})

({{OverscriptBox[x,y]}})

({{OwnValues[x]}})

({{PaddedForm[expr,n]}})

({{PaddedForm[expr,{n,f}]}})

({{PaddingLayer[{{(Subscript[m, 1]),(Subscript[n, 1])},{(Subscript[m, 2]),(Subscript[n, 2])},…}]}})

({{PageRankCentrality[g,α]}})

({{PageRankCentrality[g,α,β]}})

({{PageRankCentrality[{v->w,…},…]}})

({{PairedBarChart[{(Subscript[y, 1]),(Subscript[y, 2]),…},{(Subscript[z, 1]),(Subscript[z, 2]),…}]}})

({{PairedBarChart[{…,(Subscript[w, i])[(Subscript[y, i]),…],…},{…,(Subscript[w, j])[(Subscript[z, j]),…],…}]}})

({{PairedBarChart[{(Subscript[data, 11]),…},{(Subscript[data, 21]),…}]}})

({{PairedHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{PairedHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}, bspec]}})

({{PairedHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…},bspec,hspec]}})

({{PairedHistogram[{(Subscript[data, 11]),…},{(Subscript[data, 21]),…},…]}})

({{PairedSmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{PairedSmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…},espec]}})

({{PairedSmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},{(Subscript[y, 1]),(Subscript[y, 2]),…},espec,dfun]}})

({{PairedSmoothHistogram[{(Subscript[data, 11]),…},{(Subscript[data, 21]),…},…]}})

({{PairedTTest[data]}})

({{PairedTTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{PairedTTest[dspec,(Subscript[μ, 0])]}})

({{PairedTTest[dspec,(Subscript[μ, 0]),"property"]}})

({{PairedZTest[data]}})

({{PairedZTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{PairedZTest[dspec,σ]}})

({{PairedZTest[dspec,σ,(Subscript[μ, 0])]}})

({{PairedZTest[dspec,σ,(Subscript[μ, 0]),"property"]}})

({{PaletteNotebook[{(Subscript[cell, 1]),(Subscript[cell, 2]),…}]}})

({{PalindromeQ[list]}})

({{PalindromeQ[n]}})

({{PalindromeQ[string]}})

({{Pane[expr]}})

({{Pane[expr,w]}})

({{Pane[expr,{w,h}]}})

({{Panel[expr]}})

({{Panel[expr,title]}})

({{Panel[expr,title,pos]}})

({{Panel[expr,{(Subscript[title, 1]),(Subscript[title, 2]),…},{(Subscript[pos, 1]),…}]}})

({{Panel[]}})

({{PaneSelector[{(Subscript[v, 1])->(Subscript[expr, 1]),(Subscript[v, 2])->(Subscript[expr, 2]),…},v]}})

({{ParallelArray[f,n]}})

({{ParallelArray[f,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{ParallelArray[f,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[r, 1]),(Subscript[r, 2]),…}]}})

({{ParallelArray[f,dims,origin,h]}})

({{ParallelCombine[f,h[(Subscript[e, 1]),(Subscript[e, 2]),…],comb]}})

({{ParallelCombine[f,h[(Subscript[e, 1]),(Subscript[e, 2]), …]]}})

({{ParallelCombine[f,h[(Subscript[e, 1]),(Subscript[e, 2]),…],h]}})

({{ParallelCombine[f,h[(Subscript[e, 1]),(Subscript[e, 2]),…],Join]}})

({{ParallelEvaluate[expr]}})

({{ParallelEvaluate[expr,kernel]}})

({{ParallelEvaluate[expr,{(Subscript[ker, 1]),(Subscript[ker, 2]),…}]}})

({{Parallelize[expr]}})

({{ParallelMap[f,expr]}})

({{ParallelMap[f,expr,levelspec]}})

({{ParallelSubmit[expr]}})

({{ParallelSubmit[{(Subscript[var, 1]),(Subscript[var, 2]), …},expr]}})

({{ParallelTry[f,{(Subscript[arg, 1]),(Subscript[arg, 2]),…}]}})

({{ParallelTry[f,{(Subscript[arg, 1]),(Subscript[arg, 2]),…},k]}})

({{ParameterMixtureDistribution[dist[θ],θ\[Distributed]wdist]}})

({{ParameterMixtureDistribution[dist[(Subscript[θ, 1]),(Subscript[θ, 2]),…],{(Subscript[θ, 1])\[Distributed](Subscript[wdist, 1]),(Subscript[θ, 2])\[Distributed](Subscript[wdist, 2]),…}]}})

({{ParametricNDSolve[eqns,u,{x,(Subscript[x, min]),(Subscript[x, max])},pars]}})

({{ParametricNDSolve[eqns,u,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},pars]}})

({{ParametricNDSolve[eqns,u,{x,y}∈Ω, pars]}})

({{ParametricNDSolve[eqns,u,{t,(Subscript[t, min]),(Subscript[t, max])},{x,y}∈Ω, pars]}})

({{ParametricNDSolve[eqns,{(Subscript[u, 1]),(Subscript[u, 2]),…},…]}})

({{ParametricNDSolveValue[eqns,expr,{x,(Subscript[x, min]),(Subscript[x, max])},pars]}})

({{ParametricNDSolveValue[eqns,expr,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{ParametricNDSolveValue[eqns,expr,{x,y}∈Ω,pars]}})

({{ParametricNDSolveValue[eqns,expr,{t,(Subscript[t, min]),(Subscript[t, max])},{x,y}∈Ω,pars]}})

({{PartLayer[i]}})

({{PartLayer[m;;n]}})

({{Paste[expr]}})

({{Paste[notebook,expr]}})

({{Paste[]}})

({{PasteButton[expr]}})

({{PasteButton[label,expr]}})

({{PathGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{PathGraph[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{PathGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{PathGraph[{…,(Subscript[w, i])[(Subscript[v, i]),…],…},{…,(Subscript[w, j])[(Subscript[e, j]),…],…}]}})

({{PathGraph[{(Subscript[v, i])->(Subscript[v, j]),…}]}})

({{PeakDetect[data]}})

({{PeakDetect[data,σ]}})

({{PeakDetect[data,σ,s]}})

({{PeakDetect[data,σ,s,t]}})

({{PeakDetect[data,σ,{s,(Subscript[σ, s])},{t,(Subscript[σ, t])}]}})

({{PeanoCurve[n]}})

({{PearsonChiSquareTest[data]}})

({{PearsonChiSquareTest[data,dist]}})

({{PearsonChiSquareTest[data,dist,"property"]}})

({{PearsonCorrelationTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{PearsonCorrelationTest[…,"property"]}})

({{Perimeter[reg]}})

({{Perimeter[{(Subscript[x, 1]),(Subscript[x, 2])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{Perimeter[{(Subscript[x, 1]),(Subscript[x, 2])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])},chart]}})

({{Periodogram[list]}})

({{Periodogram[list,n]}})

({{Periodogram[list,n,d]}})

({{Periodogram[list,n,d,wfun]}})

({{Periodogram[list,n,d,wfun,m]}})

({{Periodogram[{(Subscript[list, 1]),(Subscript[list, 2]),…},n,d,wfun,m]}})

({{Periodogram[audio,…]}})

({{Periodogram[{(Subscript[audio, 1]),(Subscript[audio, 2]),…},…]}})

({{PeriodogramArray[list]}})

({{PeriodogramArray[list,n]}})

({{PeriodogramArray[list,n,d]}})

({{PeriodogramArray[list,n,d,wfun]}})

({{PeriodogramArray[list,n,d,wfun,m]}})

({{PeriodogramArray[image,…]}})

({{PeriodogramArray[sound,…]}})

({{Permanent[m]}})

({{PermissionsKeys[]}})

({{PersistentValue["name"]}})

({{PersistentValue["name",loc]}})

({{PersistentValue["name",{(Subscript[loc, 1]),…}]}})

({{PetersenGraph[n,k]}})

({{PhaseMargins[lsys]}})

({{PIDTune[lsys]}})

({{PIDTune[lsys,"carch"]}})

({{PIDTune[lsys,{"carch","trule"}]}})

({{PIDTune[lsys,…,"prop"]}})

({{PiecewiseExpand[expr]}})

({{PiecewiseExpand[expr,assum]}})

({{PiecewiseExpand[expr,assum,dom]}})

({{PieChart[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{PieChart[{…,(Subscript[w, i])[(Subscript[y, i]),…],…,(Subscript[w, j])[(Subscript[y, j]),…],…}]}})

({{PieChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{PieChart3D[{(Subscript[y, 1]),(Subscript[y, 2]),…}]}})

({{PieChart3D[{…,(Subscript[w, i])[(Subscript[y, i]),…],…,(Subscript[w, j])[(Subscript[y, j]),…],…}]}})

({{PieChart3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{PillaiTraceTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{PillaiTraceTest[…,"property"]}})

({{PingTime[host]}})

({{PingTime[host,n]}})

({{PixelValue[image,ppos]}})

({{PixelValue[image,ppos,"type"]}})

({{PlanarGraph[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{PlanarGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{PlanarGraph[{…,(Subscript[w, i])[(Subscript[v, i])],…},{…,(Subscript[w, j])[(Subscript[e, j])],…}]}})

({{PlanarGraph[{(Subscript[v, i])->(Subscript[v, j]),…}]}})

({{Point[p]}})

({{Point[{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{PointFigureChart[{{(Subscript[date, 1]),(Subscript[p, 1])},{(Subscript[date, 2]),(Subscript[p, 2])},…}]}})

({{PointFigureChart[{"name",daterange}]}})

({{PointFigureChart[{…},s,n]}})

({{PointLegend[{(Subscript[col, 1]),…},{(Subscript[lbl, 1]),…}]}})

({{PointLegend[{(Subscript[col, 1]),…},Automatic]}})

({{PointLegend[{(Subscript[lbl, 1]),…}]}})

({{Polygon[{(Subscript[p, 1]),…,(Subscript[p, n])}]}})

({{Polygon[{{(Subscript[p, 11]),…},{(Subscript[p, 21]),…},…}]}})

({{PolynomialExtendedGCD[(Subscript[poly, 1]),(Subscript[poly, 2]),x]}})

({{PolynomialExtendedGCD[(Subscript[poly, 1]),(Subscript[poly, 2]),x,Modulus->p]}})

({{PolynomialGCD[(Subscript[poly, 1]),(Subscript[poly, 2]),…]}})

({{PolynomialGCD[(Subscript[poly, 1]),(Subscript[poly, 2]),…,Modulus->p]}})

({{PolynomialLCM[(Subscript[poly, 1]),(Subscript[poly, 2]),…]}})

({{PolynomialLCM[(Subscript[poly, 1]),(Subscript[poly, 2]),…,Modulus->p]}})

({{PolynomialMod[poly,m]}})

({{PolynomialMod[poly,{(Subscript[m, 1]),(Subscript[m, 2]),…}]}})

({{PolynomialQuotient[p,q,x]}})

({{PolynomialQuotientRemainder[p,q,x]}})

({{PolynomialReduce[poly,{(Subscript[poly, 1]),(Subscript[poly, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{PolynomialRemainder[p,q,x]}})

({{PoolingLayer[sz]}})

({{PoolingLayer[{w}]}})

({{PoolingLayer[{h,w}]}})

({{PoolingLayer[kernel,stride]}})

({{PoolingLayer[kernel,opts]}})

({{PopupMenu[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{PopupMenu[Dynamic[x],{(Subscript[val, 1]),…}]}})

({{PopupMenu[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{PopupMenu[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),…},dlbl]}})

({{PopupMenu[x,{…},dlbl,base]}})

({{PopupView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{PopupView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},i]}})

({{PopupView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},i,base]}})

({{PopupWindow[expr,contents]}})

({{Position[expr,pattern]}})

({{Position[expr,pattern,levelspec]}})

({{Position[expr,pattern,levelspec,n]}})

({{Position[pattern]}})

({{PositiveSemidefiniteMatrixQ[m]}})

({{PossibleZeroQ[expr]}})

({{PowerExpand[expr]}})

({{PowerExpand[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{PowerSpectralDensity[data,ω]}})

({{PowerSpectralDensity[data,ω,sspec]}})

({{PowerSpectralDensity[tproc,ω]}})

({{Predict[{(Subscript[in, 1])->(Subscript[out, 1]),(Subscript[in, 2])->(Subscript[out, 2]),…}]}})

({{Predict[{(Subscript[in, 1]),(Subscript[in, 2]),…}->{(Subscript[out, 1]),(Subscript[out, 2]),…}]}})

({{Predict[training,input]}})

({{Predict["name",input]}})

({{Predict[predictor,opts]}})

({{PredictorFunction[…]}})

({{PredictorMeasurements[predictor,testset,prop]}})

({{PredictorMeasurements[predictor,testset]}})

({{PredictorMeasurementsObject[…]}})

({{PreviousCell[]}})

({{PreviousCell[cellobj]}})

({{PreviousDate[gran]}})

({{PreviousDate[date,gran]}})

({{PriceGraphDistribution[n,k,a]}})

({{PrimeNu[n]}})

({{PrimeOmega[n]}})

({{PrimePowerQ[expr]}})

({{PrimeQ[expr]}})

({{PrincipalComponents[matrix]}})

({{Printout3D[model]}})

({{Printout3D[model,service]}})

({{Printout3D[model,"file.ext"]}})

({{Prism[{(Subscript[p, 1]),…,(Subscript[p, 6])}]}})

({{Probability[pred,x\[Distributed]dist]}})

({{Probability[pred,x\[Distributed]data]}})

({{Probability[pred,{(Subscript[x, 1]),(Subscript[x, 2]),…}\[Distributed]dist]}})

({{Probability[pred,{(Subscript[x, 1])\[Distributed](Subscript[dist, 1]),(Subscript[x, 2])\[Distributed](Subscript[dist, 2]),…}]}})

({{Probability[(Subscript[pred, 1])\[Conditioned](Subscript[pred, 2]),…]}})

({{ProbabilityDistribution[pdf,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{ProbabilityDistribution[pdf,{x,(Subscript[x, min]),(Subscript[x, max]),dx}]}})

({{ProbabilityDistribution[pdf,{x,…},{y,…},…]}})

({{ProbabilityDistribution[{"CDF", cdf},…]}})

({{ProbabilityDistribution[{"SF",sf},…]}})

({{ProbabilityDistribution[{"HF",hf},…]}})

({{ProbabilityPlot[list]}})

({{ProbabilityPlot[dist]}})

({{ProbabilityPlot[data,rdata]}})

({{ProbabilityPlot[data,rdist]}})

({{ProbabilityPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…},ref]}})

({{ProbabilityScalePlot[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{ProbabilityScalePlot[{(Subscript[x, 1]),(Subscript[x, 2]),…},"dist"]}})

({{ProbabilityScalePlot[{(Subscript[data, 1]),(Subscript[data, 2]),…},"dist"]}})

({{ProbitModelFit[{(Subscript[y, 1]),(Subscript[y, 2]),…},{(Subscript[f, 1]),(Subscript[f, 2]),…},x]}})

({{ProbitModelFit[{{(Subscript[x, 11]),(Subscript[x, 12]),…,(Subscript[y, 1])},{(Subscript[x, 21]),(Subscript[x, 22]),…,(Subscript[y, 2])},…},{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{ProbitModelFit[{m,v}]}})

({{ProgressIndicator[x]}})

({{ProgressIndicator[Dynamic[x]]}})

({{ProgressIndicator[x,{(Subscript[x, min]),(Subscript[x, max])}]}})

({{ProgressIndicator[x,Indeterminate]}})

({{PropertyValue[{obj,item},name]}})

({{PropertyValue[{obj,itemspec},name]}})

({{PropertyValue[…,{(Subscript[name, 1]),(Subscript[name, 2]),…}]}})

({{Pruning[image]}})

({{Pruning[image,n]}})

({{Pruning[image,{n}]}})

({{Pruning[image,n,t]}})

({{PseudoInverse[m]}})

({{PsychrometricPropertyData[spec]}})

({{PsychrometricPropertyData[spec,property]}})

({{Pyramid[{(Subscript[p, 1]),…,(Subscript[p, 5])}]}})

({{QnDispersion[list]}})

({{QnDispersion[list,c]}})

({{QRDecomposition[m]}})

({{QuantilePlot[list]}})

({{QuantilePlot[dist]}})

({{QuantilePlot[data,rdata]}})

({{QuantilePlot[data,rdist]}})

({{QuantilePlot[{(Subscript[data, 1]),(Subscript[data, 2]),…},ref]}})

({{Quantity[magnitude,unit]}})

({{Quantity[unit]}})

({{Query[(Subscript[operator, 1]),(Subscript[operator, 2]),…]}})

({{RadialGradientImage[gcol]}})

({{RadialGradientImage[{(Subscript[pos, 1]),(Subscript[pos, 2])}->gcol]}})

({{RadialGradientImage[…,size]}})

({{RadicalBox[x,n]}})

({{RadioButton[x,val]}})

({{RadioButton[x,val]}})

({{RadioButton[Dynamic[x],val]}})

({{RadioButtonBar[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{RadioButtonBar[Dynamic[x],{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{RadioButtonBar[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{Radon[image]}})

({{Radon[image,{w,h}]}})

({{Radon[image,{w,h},{(Subscript[θ, 1]),(Subscript[θ, 2])}]}})

({{RadonTransform[expr,{x,y},{p,ϕ}]}})

({{RandomColor[]}})

({{RandomColor[n]}})

({{RandomColor[model]}})

({{RandomColor[model,n]}})

({{RandomColor[model,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomComplex[]}})

({{RandomComplex[{(Subscript[z, min]),(Subscript[z, max])}]}})

({{RandomComplex[(Subscript[z, max])]}})

({{RandomComplex[range,n]}})

({{RandomComplex[range,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomFunction[proc,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{RandomFunction[proc,{(Subscript[t, min]),(Subscript[t, max]),dt}]}})

({{RandomFunction[proc,…, n]}})

({{RandomGraph[{n,m}]}})

({{RandomGraph[{n,m},k]}})

({{RandomGraph[gdist,…]}})

({{RandomImage[max]}})

({{RandomImage[{min,max}]}})

({{RandomImage[dist]}})

({{RandomImage[…,size]}})

({{RandomPoint[reg]}})

({{RandomPoint[reg,n]}})

({{RandomPoint[reg,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomPoint[reg,…,{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{RandomReal[]}})

({{RandomReal[{(Subscript[x, min]),(Subscript[x, max])}]}})

({{RandomReal[(Subscript[x, max])]}})

({{RandomReal[range,n]}})

({{RandomReal[range,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomVariate[dist]}})

({{RandomVariate[dist,n]}})

({{RandomVariate[dist,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RandomWord[]}})

({{RandomWord[type]}})

({{RandomWord[type,n]}})

({{Raster[{{(Subscript[a, 11]),(Subscript[a, 12]),…},…}]}})

({{Raster[{{{(Subscript[r, 11]),(Subscript[g, 11]),(Subscript[b, 11])},…},…}]}})

({{Raster[{{{(Subscript[r, 11]),(Subscript[g, 11]),(Subscript[b, 11]),(Subscript[α, 11])},…},…}]}})

({{Raster[{{{(Subscript[a, 11]),(Subscript[α, 11])},…},…}]}})

({{Raster3D[{{{(Subscript[a, 11]),(Subscript[a, 12]),…},…},…}]}})

({{Raster3D[{{{{(Subscript[r, 11]),(Subscript[g, 11]),(Subscript[b, 11])},…},…},…}]}})

({{Raster3D[{{{{(Subscript[r, 11]),(Subscript[g, 11]),(Subscript[b, 11]),(Subscript[α, 11])},…},…},…}]}})

({{Raster3D[array,{{(Subscript[x, min]),(Subscript[y, min]),(Subscript[z, min])},{(Subscript[x, max]),(Subscript[y, max]),(Subscript[z, max])}}]}})

({{Raster3D[array,coordinates,{(Subscript[a, min]),(Subscript[a, max])}]}})

({{Rasterize[expr]}})

({{Rasterize[expr,elem]}})

({{Rasterize[expr,{(Subscript[elem, 1]),(Subscript[elem, 2]),…}]}})

({{Read[stream]}})

({{Read[stream,type]}})

({{Read[stream,{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{ReadByteArray[src]}})

({{ReadByteArray[src,n]}})

({{ReadByteArray[src,term]}})

({{ReadLine["file"]}})

({{ReadLine[stream]}})

({{ReadLine[proc]}})

({{ReadList["file"]}})

({{ReadList["file",type]}})

({{ReadList["file",{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{ReadList["file",types,n]}})

({{ReadString["file"]}})

({{ReadString[stream]}})

({{ReadString[proc]}})

({{ReadString[src,term]}})

({{Rectangle[{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])}]}})

({{Rectangle[{(Subscript[x, min]),(Subscript[y, min])}]}})

({{RectangleChart[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{RectangleChart[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i])},…],…,(Subscript[w, j])[{(Subscript[x, i]),(Subscript[y, j])},…],…}]}})

({{RectangleChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{RectangleChart3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{RectangleChart3D[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i]),(Subscript[z, i])},…],…,(Subscript[w, j])[{(Subscript[x, i]),(Subscript[y, j]),(Subscript[z, j])},…],…}]}})

({{RectangleChart3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{RecurrenceFilter[{α,β},x]}})

({{RecurrenceFilter[tf,x]}})

({{RecurrenceFilter[…,x,{(Subscript[y, 0]),(Subscript[y, 1]),…}]}})

({{RecurrenceFilter[…,image]}})

({{RecurrenceFilter[…,sound]}})

({{RecurrenceTable[eqns,expr,{n,(Subscript[n, max])}]}})

({{RecurrenceTable[eqns,expr,nspec]}})

({{RecurrenceTable[eqns,expr,{(Subscript[n, 1]),…},{(Subscript[n, 2]),…},…]}})

({{Refine[expr,assum]}})

({{Refine[expr]}})

({{Refresh[expr,opts]}})

({{Refresh[expr,None]}})

({{Region[reg]}})

({{Region[reg,options]}})

({{RegionBinarize[image,marker,d]}})

({{RegionBinarize[image,marker,d,{(Subscript[t, 1]),(Subscript[t, 2])}]}})

({{RegionCentroid[reg]}})

({{RegionDifference[(Subscript[reg, 1]),(Subscript[reg, 2])]}})

({{RegionDimension[reg]}})

({{RegionDisjoint[(Subscript[reg, 1]),(Subscript[reg, 2])]}})

({{RegionDisjoint[(Subscript[reg, 1]),(Subscript[reg, 2]),(Subscript[reg, 3]),…]}})

({{RegionEqual[(Subscript[reg, 1]),(Subscript[reg, 2])]}})

({{RegionEqual[(Subscript[reg, 1]),(Subscript[reg, 2]),(Subscript[reg, 3]),…]}})

({{RegionImage[reg]}})

({{RegionImage[reg,{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{RegionIntersection[(Subscript[reg, 1]),(Subscript[reg, 2]),…]}})

({{RegionMeasure[reg]}})

({{RegionMeasure[reg,d]}})

({{RegionMeasure[{(Subscript[x, 1]),…,(Subscript[x, n])},{{(Subscript[t, 1]),(Subscript[a, 1]),(Subscript[b, 1])},…,{(Subscript[t, k]),(Subscript[a, k]),(Subscript[b, k])}}]}})

({{RegionMeasure[{(Subscript[x, 1]),…,(Subscript[x, n])},{{(Subscript[t, 1]),(Subscript[a, 1]),(Subscript[b, 1])},…,{(Subscript[t, k]),(Subscript[a, k]),(Subscript[b, k])}},chart]}})

({{RegionMoment[reg,{(Subscript[i, 1]),(Subscript[i, 2]),…,(Subscript[i, n])}]}})

({{RegionSymmetricDifference[(Subscript[reg, 1]),(Subscript[reg, 2]),…]}})

({{RegionUnion[(Subscript[reg, 1]),(Subscript[reg, 2]),…]}})

({{RegionWithin[(Subscript[reg, 1]),(Subscript[reg, 2])]}})

({{RelationGraph[f,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{RelationGraph[f,{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[w, 1]),(Subscript[w, 2]),…}]}})

({{ReliefImage[array]}})

({{ReliefPlot[array]}})

({{RemoteConnect["host"]}})

({{RemoteConnect[IPAddress["address"]]}})

({{RemoteConnect["host",username]}})

({{RemoteConnect["host",username,password]}})

({{RemoteRun["host","command"]}})

({{RemoteRun[IPAddress["address"],"command"]}})

({{RemoteRun[obj,"command"]}})

({{RemoteRunProcess["host","command"]}})

({{RemoteRunProcess[IPAddress["address"],"command"]}})

({{RemoteRunProcess[obj,"command"]}})

({{RemoteRunProcess["host",{"command",(Subscript[arg, 1]),(Subscript[arg, 2]),…}]}})

({{RemoteRunProcess["host", command,"prop"]}})

({{RemoteRunProcess["host", command,prop,input]}})

({{RemoveDiacritics[string]}})

({{RenameFile[(Subscript[file, 1]),(Subscript[file, 2])]}})

({{RenkoChart[{{(Subscript[date, 1]),(Subscript[p, 1])},{(Subscript[date, 2]),(Subscript[p, 2])},…}]}})

({{RenkoChart[{"name",daterange}]}})

({{RenkoChart[{…},s]}})

({{RepairMesh[mreg]}})

({{RepairMesh[mreg,{(Subscript[def, 1]),…}]}})

({{Replace[expr,rules]}})

({{Replace[expr,rules,levelspec]}})

({{Replace[rules]}})

({{ReplaceImageValue[image,pos->val]}})

({{ReplaceImageValue[image,pos->val,"type"]}})

({{ReplacePart[expr,i->new]}})

({{ReplacePart[expr,{(Subscript[i, 1])->(Subscript[new, 1]),(Subscript[i, 2])->(Subscript[new, 2]),…}]}})

({{ReplacePart[expr,{i,j,…}->new]}})

({{ReplacePart[expr,{{(Subscript[i, 1]),(Subscript[j, 1]),…}->(Subscript[new, 1]),…}]}})

({{ReplacePart[expr,{{(Subscript[i, 1]),(Subscript[j, 1]),…},…}->new]}})

({{ReplacePart[i->new]}})

({{ReplicateLayer[n]}})

({{ReplicateLayer[{(Subscript[n, 1]),(Subscript[n, 2]),…,(Subscript[n, m])}]}})

({{ReplicateLayer[dims,m]}})

({{ResetScheduledTask[obj,timespec,offset]}})

({{ReshapeLayer[dims]}})

({{Residue[expr,{z,(Subscript[z, 0])}]}})

({{ResizeLayer[{n}]}})

({{ResizeLayer[{h,w}]}})

({{Resolve[expr]}})

({{Resolve[expr,dom]}})

({{ResourceData[resource]}})

({{ResourceData[resource,elem]}})

({{ResourceObject["name"]}})

({{ResourceObject["uuid"]}})

({{ResourceObject[assoc]}})

({{ResourceRegister[resource]}})

({{ResourceRegister[resource, loc]}})

({{ResourceRegister[resource, {(Subscript[loc, 1]),…}]}})

({{ResourceSearch[keywords]}})

({{ResourceSearch[keywords,n]}})

({{ResourceSubmit[resource]}})

({{ResourceSubmit[new,old]}})

({{ResourceUpdate[resource]}})

({{ResourceUpdate["name"]}})

({{Resultant[(Subscript[poly, 1]),(Subscript[poly, 2]),var]}})

({{Resultant[(Subscript[poly, 1]),(Subscript[poly, 2]),var,Modulus->p]}})

({{ReverseGraph[g]}})

({{ReverseGraph[{v->w,…}]}})

({{RiccatiSolve[{a,b},{q,r}]}})

({{RiccatiSolve[{a,b},{q,r,p}]}})

({{RidgeFilter[data]}})

({{RidgeFilter[data,σ]}})

({{RightCosetRepresentative[group,g]}})

({{Root[f,k]}})

({{Root[{(Subscript[f, 1]),(Subscript[f, 2]),…},{(Subscript[k, 1]),(Subscript[k, 2]),…}]}})

({{Root[{f,(Subscript[x, 0])}]}})

({{Root[{f,(Subscript[x, 0]),n}]}})

({{RootApproximant[x]}})

({{RootApproximant[x,n]}})

({{RootReduce[expr]}})

({{Roots[lhs==rhs,var]}})

({{Rotate[g,θ]}})

({{Rotate[g,θ,{x,y}]}})

({{Rotate[g,{u,v}]}})

({{Rotate[g,θ,w]}})

({{Rotate[g,θ,w,p]}})

({{Rotate[g,θ,{u,v}]}})

({{Row[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{Row[list,s]}})

({{RowReduce[m]}})

({{RSolve[eqn,a[n],n]}})

({{RSolve[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},{(Subscript[a, 1])[n],(Subscript[a, 2])[n],…},n]}})

({{RSolve[eqn,a[(Subscript[n, 1]),(Subscript[n, 2]),…],{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RSolveValue[eqn,expr,n]}})

({{RSolveValue[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},expr,…]}})

({{RSolveValue[eqn,expr,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{RulePlot[sys]}})

({{RulePlot[sys,init,t]}})

({{RulePlot[sys,evol]}})

({{RunScheduledTask[expr]}})

({{RunScheduledTask[expr,time]}})

({{RunScheduledTask[expr,{time}]}})

({{RunScheduledTask[expr,{time,count}]}})

({{RunScheduledTask[expr,timespec,start]}})

({{RunScheduledTask[CloudObject[...]]}})

({{SatisfiabilityInstances[bf]}})

({{SatisfiabilityInstances[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{SatisfiabilityInstances[b,…,m]}})

({{SatisfiableQ[bf]}})

({{SatisfiableQ[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{SavitzkyGolayMatrix[r,k]}})

({{SavitzkyGolayMatrix[{(Subscript[r, 1]),(Subscript[r, 2])},{(Subscript[k, 1]),(Subscript[k, 2])}]}})

({{SavitzkyGolayMatrix[r,k,n]}})

({{SavitzkyGolayMatrix[{(Subscript[r, 1]),(Subscript[r, 2])… },{(Subscript[k, 1]),(Subscript[k, 2]),…},…]}})

({{Scan[f,expr]}})

({{Scan[f,expr,levelspec]}})

({{Scan[f]}})

({{ScheduledTask[expr,timespec]}})

({{ScheduledTasks[]}})

({{SchurDecomposition[m]}})

({{SchurDecomposition[{m,a}]}})

({{ScientificForm[expr]}})

({{ScientificForm[expr,n]}})

({{SearchAdjustment[query,w]}})

({{SearchAdjustment[query,…,opts]}})

({{SectorChart[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 1]),(Subscript[y, 2])},…}]}})

({{SectorChart[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i])},…],…,(Subscript[w, j])[{(Subscript[x, j]),(Subscript[y, j])},…],…}]}})

({{SectorChart[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{SectorChart3D[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{SectorChart3D[{…,(Subscript[w, i])[{(Subscript[x, i]),(Subscript[y, i]),(Subscript[z, i])},…],…,(Subscript[w, j])[{(Subscript[x, j]),(Subscript[y, j]),(Subscript[z, j])},…],…}]}})

({{SectorChart3D[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{SeedRandom[n]}})

({{SeedRandom[]}})

({{SelectComponents[{image,lmat},crit]}})

({{SelectComponents[image,crit]}})

({{SelectComponents[…,"prop",n]}})

({{SelectComponents[…,"prop",n,p]}})

({{SelectedCells[notebook]}})

({{SelectedCells[]}})

({{SelectionAnimate[notebook]}})

({{SelectionAnimate[notebook,t]}})

({{SelectionMove[obj,dir,unit]}})

({{SelectionMove[obj,dir,unit,n]}})

({{SemanticImport[file]}})

({{SemanticImport[file,type]}})

({{SemanticImport[file,{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{SemanticImport[file,typespec,form]}})

({{SemanticImportString["string"]}})

({{SemanticImportString["string",type]}})

({{SemanticImportString["string",{(Subscript[type, 1]),(Subscript[type, 2]),…}]}})

({{SemanticImportString["string",\[LeftAssociation](Subscript[col, 1])->(Subscript[type, 1]),(Subscript[col, 2])->(Subscript[type, 2]),…\[RightAssociation]]}})

({{SemanticImportString["string",typespec,form]}})

({{SemanticInterpretation["string"]}})

({{SemanticInterpretation["string",pattern]}})

({{SemanticInterpretation["string",pattern,head]}})

({{SendMail[body]}})

({{SendMail[{"subject"}]}})

({{SendMail[{"subject",body}]}})

({{SendMail[{"subject",body,att}]}})

({{SendMail["to",content]}})

({{SendMail[{"(Subscript[to, 1])","(Subscript[to, 2])",…},content]}})

({{SendMail[{{"(Subscript[to, 1])",…},{"(Subscript[cc, 1])",…}},content]}})

({{SendMail[{{"(Subscript[to, 1])",…},{"(Subscript[cc, 1])",…},{"(Subscript[bcc, 1])",…}},content]}})

({{SendMail[assoc]}})

({{SequenceAlignment[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{SequenceAttentionLayer[]}})

({{SequenceAttentionLayer[net]}})

({{SequenceCases[list,patt]}})

({{SequenceCases[list,patt->rhs]}})

({{SequenceCases[list,patt,n]}})

({{SequenceCount[list,sub]}})

({{SequenceCount[list,patt]}})

({{SequenceLastLayer[]}})

({{SequenceMostLayer[]}})

({{SequencePosition[list,sublist]}})

({{SequencePosition[list,patt]}})

({{SequencePosition[list,patt,n]}})

({{SequencePredict[{(Subscript[seq, 1]),(Subscript[seq, 2]),…}]}})

({{SequencePredict[training,seq]}})

({{SequencePredict[training,{(Subscript[seq, 1]),(Subscript[seq, 2]),…}]}})

({{SequencePredict["name",seq]}})

({{SequencePredict[…,seq,prop]}})

({{SequencePredictorFunction[…]}})

({{SequenceRestLayer[]}})

({{SequenceReverseLayer[]}})

({{SeriesCoefficient[series,n]}})

({{SeriesCoefficient[f,{x,(Subscript[x, 0]),n}]}})

({{SeriesCoefficient[f,{x,(Subscript[x, 0]),(Subscript[n, x])},{y,(Subscript[y, 0]),(Subscript[n, y])},…]}})

({{ServiceConnect["service"]}})

({{ServiceConnect["service",id]}})

({{ServiceConnect["service",id,defaults]}})

({{SessionSubmit[expr]}})

({{SessionSubmit[ScheduledTask[expr,spec]]}})

({{Setter[x,val]}})

({{Setter[Dynamic[x],val]}})

({{Setter[x,val,label]}})

({{Setter[x,{(Subscript[val, 1]),(Subscript[val, 2]),…},label]}})

({{SetterBar[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{SetterBar[Dynamic[x],{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{SetterBar[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{ShapiroWilkTest[data]}})

({{ShapiroWilkTest[data,"property"]}})

({{ShenCastanMatrix[r]}})

({{ShenCastanMatrix[{r,σ}]}})

({{ShenCastanMatrix[r,{(Subscript[n, 1]),(Subscript[n, 2])}]}})

({{ShenCastanMatrix[r,{{(Subscript[n, 11]),(Subscript[n, 12])},{(Subscript[n, 21]),(Subscript[n, 22])},…}]}})

({{ShenCastanMatrix[{{(Subscript[r, 1]),(Subscript[r, 2]),…},σ},…]}})

({{ShiftRegisterSequence[n]}})

({{ShiftRegisterSequence[{n,{(Subscript[tap, 1]),(Subscript[tap, 2]),…}}]}})

({{ShiftRegisterSequence[poly]}})

({{ShiftRegisterSequence[{n,{(Subscript[tap, 1]),(Subscript[tap, 2]),…},f}]}})

({{ShiftRegisterSequence[spec,s]}})

({{ShiftRegisterSequence[spec,init,s]}})

({{SiegelTukeyTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{SiegelTukeyTest[dspec,(Subscript[σ, 0]^2)]}})

({{SiegelTukeyTest[dspec,(Subscript[σ, 0]^2),"property"]}})

({{SierpinskiCurve[n]}})

({{SierpinskiMesh[n]}})

({{SierpinskiMesh[n,d]}})

({{SignedRankTest[data]}})

({{SignedRankTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{SignedRankTest[dspec,(Subscript[μ, 0])]}})

({{SignedRankTest[dspec,(Subscript[μ, 0]),"property"]}})

({{SignTest[data]}})

({{SignTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{SignTest[dspec,(Subscript[μ, 0])]}})

({{SignTest[dspec,(Subscript[μ, 0]),"property"]}})

({{SimpleGraph[g]}})

({{SimpleGraph[{v->w,…}]}})

({{Simplex[{(Subscript[p, 1]),…,(Subscript[p, k])}]}})

({{Simplify[expr]}})

({{Simplify[expr,assum]}})

({{SingularValueDecomposition[m]}})

({{SingularValueDecomposition[{m,a}]}})

({{SingularValueDecomposition[m,k]}})

({{SingularValueDecomposition[m,UpTo[k]]}})

({{SingularValueDecomposition[{m,a},k]}})

({{SingularValueList[m]}})

({{SingularValueList[{m,a}]}})

({{SingularValueList[m,k]}})

({{SingularValueList[{m,a},k]}})

({{SingularValues[m]}})

({{SkeletonTransform[image]}})

({{SkeletonTransform[image,t]}})

({{Skip[stream,type]}})

({{Skip[stream,type,n]}})

({{SliceContourPlot3D[f,surf,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{SliceContourPlot3D[f,surf,{x,y,z}∈reg]}})

({{SliceContourPlot3D[f,{(Subscript[surf, 1]),(Subscript[surf, 2]),…},…]}})

({{SliceDensityPlot3D[f,surf,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{SliceDensityPlot3D[f,surf,{x,y,z}∈reg]}})

({{SliceDensityPlot3D[f,{(Subscript[surf, 1]),(Subscript[surf, 2]),…},…]}})

({{SliceVectorPlot3D[{(Subscript[v, x]),(Subscript[v, y]),(Subscript[v, z])},surf,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{SliceVectorPlot3D[{(Subscript[v, x]),(Subscript[v, y]),(Subscript[v, z])},surf,{x,y,z}∈reg]}})

({{SliceVectorPlot3D[{(Subscript[v, x]),(Subscript[v, y]),(Subscript[v, z])},{(Subscript[surf, 1]),(Subscript[surf, 2]),…},…]}})

({{Slider[x]}})

({{Slider[Dynamic[x]]}})

({{Slider[x,{(Subscript[x, min]),(Subscript[x, max])}]}})

({{Slider[x,{(Subscript[x, min]),(Subscript[x, max]),dx}]}})

({{Slider[x,{{(Subscript[e, 1]),(Subscript[e, 2]),…}}]}})

({{Slider[x,{{{(Subscript[e, 1]),(Subscript[w, 1])},{(Subscript[e, 2]),(Subscript[w, 2])},…}}]}})

({{Slider2D[{x,y}]}})

({{Slider2D[Dynamic[pt]]}})

({{Slider2D[pt,{min,max}]}})

({{Slider2D[pt,{min,max,d}]}})

({{Slider2D[pt,{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])}}]}})

({{Slider2D[pt,{{(Subscript[x, min]),(Subscript[y, min])},{(Subscript[x, max]),(Subscript[y, max])},{dx,dy}}]}})

({{SlideView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{SlideView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},i]}})

({{SmithDelayCompensator[sys,con]}})

({{SmithWatermanSimilarity[u,v]}})

({{SmoothDensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{SmoothDensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},espec]}})

({{SmoothDensityHistogram[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},espec,dfun]}})

({{SmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{SmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},espec]}})

({{SmoothHistogram[{(Subscript[x, 1]),(Subscript[x, 2]),…},espec,dfun]}})

({{SmoothHistogram[{(Subscript[data, 1]),(Subscript[data, 2]),…},…]}})

({{SmoothHistogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…}]}})

({{SmoothHistogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},espec]}})

({{SmoothHistogram3D[{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[x, 2]),(Subscript[y, 2])},…},espec,dfun]}})

({{SmoothHistogram3D[{(Subscript[data, 1]),(Subscript[data, 2]),…},…]}})

({{SmoothKernelDistribution[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{SmoothKernelDistribution[{{(Subscript[x, 1]),(Subscript[y, 1]),…},{(Subscript[x, 2]),(Subscript[y, 2]),…},…}]}})

({{SmoothKernelDistribution[…,bw]}})

({{SmoothKernelDistribution[…,bw,ker]}})

({{SnDispersion[list]}})

({{SnDispersion[list,c]}})

({{Snippet[doc]}})

({{Snippet[doc,n]}})

({{Snippet[doc,-n]}})

({{Snippet[doc,(Subscript[n, 1]);;(Subscript[n, 2])]}})

({{Snippet[doc,(Subscript[n, 1]);;(Subscript[n, 2]);;(Subscript[n, 3])]}})

({{Snippet[ContentObject[…],SearchResultObject[…]]}})

({{SocketListen[socket,fun]}})

({{SocketListen[port,fun]}})

({{SocketListen[address,fun]}})

({{SocketListen[spec,opts]}})

({{SocketListen[spec]}})

({{SocketReadMessage[socket]}})

({{SoftmaxLayer[]}})

({{SolarEclipse[]}})

({{SolarEclipse[datespec]}})

({{SolarEclipse[propertyspec]}})

({{SolarEclipse[datespec,propertyspec]}})

({{Sound[primitives]}})

({{Sound[primitives,t]}})

({{Sound[primitives,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{SoundNote[pitch]}})

({{SoundNote[pitch,t]}})

({{SoundNote[pitch,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{SoundNote[pitch,tspec,"style"]}})

({{SoundNote[pitch,tspec,"style",opts]}})

({{SpatialGraphDistribution[n,r]}})

({{SpatialGraphDistribution[n,r,d]}})

({{SpatialGraphDistribution[n,r,dist]}})

({{SpatialMedian[{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{SpatialMedian[data]}})

({{SpatialTransformationLayer[{h,w}]}})

({{Speak[expr]}})

({{SpearmanRankTest[(Subscript[v, 1]),(Subscript[v, 2])]}})

({{SpearmanRankTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{SpearmanRankTest[…,"property"]}})

({{Spectrogram[list]}})

({{Spectrogram[list,n]}})

({{Spectrogram[list,n,d]}})

({{Spectrogram[list,n,d,wfun]}})

({{Spectrogram[list,n,d,wfun,m]}})

({{Spectrogram[audio,…]}})

({{SpectrogramArray[list]}})

({{SpectrogramArray[list,n]}})

({{SpectrogramArray[list,n,d]}})

({{SpectrogramArray[list,n,d,wfun]}})

({{SpectrogramArray[list,n,d,wfun,m]}})

({{SpectrogramArray[audio,…]}})

({{SpeechSynthesize[expr]}})

({{SpeechSynthesize[expr,voice]}})

({{SpellingCorrectionList["word"]}})

({{SpokenString[expr]}})

({{SqrtBox[x]}})

({{SquareFreeQ[expr]}})

({{SquareFreeQ[expr,vars]}})

({{StackedDateListPlot[{{(Subscript[date, 1]),(Subscript[v, 1])},{(Subscript[date, 2]),(Subscript[v, 2])},…}]}})

({{StackedDateListPlot[{(Subscript[v, 1]),(Subscript[v, 2]),…},datespec]}})

({{StackedDateListPlot[tseries]}})

({{StackedDateListPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{StackedDateListPlot[{…,w[(Subscript[data, i])],…]}})

({{StackedListPlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{StackedListPlot[{…,w[(Subscript[data, i])],…}]}})

({{StandardAtmosphereData[altitude,property]}})

({{StandardAtmosphereData[layer,property]}})

({{StandardAtmosphereData["SymbolicApproximation",property]}})

({{StarGraph[n]}})

({{StateFeedbackGains[ssm,{(Subscript[p, 1]),(Subscript[p, 2]),…,(Subscript[p, n])}]}})

({{StateFeedbackGains[{ssm,{(Subscript[in, 1]),…}},…]}})

({{StateOutputEstimator[ssm,l]}})

({{StateOutputEstimator[{ssm,sensors},l]}})

({{StateOutputEstimator[{ssm,sensors,dinputs},l]}})

({{StateSpaceModel[{a,b,c,d}]}})

({{StateSpaceModel[{a,b,c,d,e}]}})

({{StateSpaceModel[sys]}})

({{StateSpaceModel[eqns,{{(Subscript[x, 1]),(Subscript[x, 10])},…},{{(Subscript[u, 1]),(Subscript[u, 10])},…},{(Subscript[g, 1]),…},τ]}})

({{StateSpaceTransform[sys,{p,q}]}})

({{StateSpaceTransform[sys,{{(Subscript[x, 1])->(Subscript[p, 1])[z],…},{(Subscript[z, 1])->(Subscript[q, 1])[x],…}}]}})

({{StateTransformationLinearize[asys]}})

({{StateTransformationLinearize[asys,{z,lform}]}})

({{StateTransformationLinearize[asys,…,"prop"]}})

({{StationaryWaveletPacketTransform[data]}})

({{StationaryWaveletPacketTransform[data,wave]}})

({{StationaryWaveletPacketTransform[data,wave,r]}})

({{StationaryWaveletTransform[data]}})

({{StationaryWaveletTransform[data,wave]}})

({{StationaryWaveletTransform[data,wave,r]}})

({{StatusCentrality[g]}})

({{StatusCentrality[{v->w,…}]}})

({{StratonovichProcess[{a,b},x,t]}})

({{StratonovichProcess[{a,b,c},x,t]}})

({{StratonovichProcess[…,…,{x,(Subscript[x, 0])},{t,(Subscript[t, 0])}]}})

({{StratonovichProcess[…,…,…,Σ]}})

({{StratonovichProcess[proc]}})

({{StratonovichProcess[sdeqns,expr,x,t,w\[Distributed]dproc]}})

({{StringCases["string",patt]}})

({{StringCases["string",lhs->rhs]}})

({{StringCases["string",p,n]}})

({{StringCases["string",{(Subscript[p, 1]),(Subscript[p, 2]),…}]}})

({{StringCases[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringCases[patt]}})

({{StringContainsQ["string",patt]}})

({{StringContainsQ[{"(Subscript[string, 1])","(Subscript[string, 2])",…},patt]}})

({{StringContainsQ[patt]}})

({{StringCount["string","sub"]}})

({{StringCount["string",patt]}})

({{StringCount["string",{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{StringCount[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringDelete["string",patt]}})

({{StringDelete[patt]}})

({{StringEndsQ["string",patt]}})

({{StringEndsQ[{"(Subscript[string, 1])","(Subscript[string, 2])",…},patt]}})

({{StringEndsQ[patt]}})

({{StringFreeQ["string",patt]}})

({{StringFreeQ["string",{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{StringFreeQ[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringFreeQ[patt]}})

({{StringMatchQ["string",patt]}})

({{StringMatchQ["string",RegularExpression["regex"]]}})

({{StringMatchQ[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringMatchQ[patt]}})

({{StringPosition["string","sub"]}})

({{StringPosition["string",patt]}})

({{StringPosition["string",patt,n]}})

({{StringPosition["string",{(Subscript[patt, 1]),(Subscript[patt, 2]),…}]}})

({{StringPosition[{(Subscript[s, 1]),(Subscript[s, 2]),…},p]}})

({{StringPosition[patt]}})

({{StringReplace["string",s->sp]}})

({{StringReplace["string",{(Subscript[s, 1])->(Subscript[sp, 1]),(Subscript[s, 2])->(Subscript[sp, 2]),…}]}})

({{StringReplace["string",srules,n]}})

({{StringReplace[{(Subscript[s, 1]),(Subscript[s, 2]),…},srules]}})

({{StringReplace[srules]}})

({{StringReplaceList["string",s->sp]}})

({{StringReplaceList["string",{(Subscript[s, 1])->(Subscript[sp, 1]),(Subscript[s, 2])->(Subscript[sp, 2]),…}]}})

({{StringReplaceList["string",srules,n]}})

({{StringReplaceList[{(Subscript[s, 1]),(Subscript[s, 2]),…},srules]}})

({{StringStartsQ["string",patt]}})

({{StringStartsQ[{"(Subscript[string, 1])","(Subscript[string, 2])",…},patt]}})

({{StringStartsQ[patt]}})

({{StringTemplate["string"]}})

({{StringTemplate[src]}})

({{StringTemplate[form,args]}})

({{StringTrim["string"]}})

({{StringTrim["string",patt]}})

({{Style[expr,options]}})

({{Style[expr,"style"]}})

({{Style[expr,color]}})

({{Style[expr,Bold]}})

({{Style[expr,Italic]}})

({{Style[expr,Underlined]}})

({{Style[expr,Larger]}})

({{Style[expr,Smaller]}})

({{Style[expr,n]}})

({{Style[expr,Tiny]}})

({{Style[expr,Small]}})

({{StyleBox[boxes,options]}})

({{StyleBox[boxes,"style"]}})

({{Subgraph[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{Subgraph[g,{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{Subgraph[g,patt]}})

({{Subgraph[{v->w,…},…]}})

({{SubresultantPolynomialRemainders[(Subscript[poly, 1]),(Subscript[poly, 2]),var]}})

({{SubresultantPolynomialRemainders[(Subscript[poly, 1]),(Subscript[poly, 2]),var,Modulus->p]}})

({{SubresultantPolynomials[(Subscript[poly, 1]),(Subscript[poly, 2]),var]}})

({{SubresultantPolynomials[(Subscript[poly, 1]),(Subscript[poly, 2]),var,Modulus->p]}})

({{Subresultants[(Subscript[poly, 1]),(Subscript[poly, 2]),var]}})

({{Subresultants[(Subscript[poly, 1]),(Subscript[poly, 2]),var,Modulus->p]}})

({{SubscriptBox[x,y]}})

({{SubsuperscriptBox[x,y,z]}})

({{SubValues[f]}})

({{SumConvergence[f,n]}})

({{SumConvergence[f,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{SummationLayer[]}})

({{SunPosition[]}})

({{SunPosition[datespec]}})

({{SunPosition[locationspec]}})

({{SunPosition[locationspec,datespec]}})

({{SunPosition[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{SunPosition[locationspec,datespec,func]}})

({{Sunrise[]}})

({{Sunrise[datespec]}})

({{Sunrise[locationspec]}})

({{Sunrise[locationspec,datespec]}})

({{Sunrise[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{Sunrise[locationspec,datespec,func]}})

({{Sunset[]}})

({{Sunset[datespec]}})

({{Sunset[locationspec]}})

({{Sunset[locationspec,datespec]}})

({{Sunset[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{Sunset[locationspec,datespec,func]}})

({{SuperscriptBox[x,y]}})

({{SurfaceGraphics[array]}})

({{SurfaceGraphics[array,shades]}})

({{SurvivalDistribution[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{SurvivalDistribution[{(Subscript[cw, 1]),(Subscript[cw, 2]),…}->{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{SurvivalModel[…]}})

({{SurvivalModelFit[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{SwatchLegend[{(Subscript[col, 1]),…},{(Subscript[lbl, 1]),…}]}})

({{SwatchLegend[{(Subscript[col, 1]),…},Automatic]}})

({{SwatchLegend[{(Subscript[lbl, 1]),…}]}})

({{SymmetricMatrixQ[m]}})

({{SystemDialogInput["type"]}})

({{SystemDialogInput["type",init]}})

({{SystemInstall[sys]}})

({{SystemModel["model"]}})

({{SystemModelPlot[sim]}})

({{SystemModelPlot[sim,"name"]}})

({{SystemModelPlot[sim,{"(Subscript[v, 1])","(Subscript[v, 2])",…}]}})

({{SystemModelPlot[{(Subscript[sim, 1]),(Subscript[sim, 2]),…},…]}})

({{SystemModelPlot[model,…]}})

({{SystemOpen["target"]}})

({{SystemsModelDelayApproximate[sys,ord]}})

({{SystemsModelVectorRelativeOrders[sys]}})

({{TableForm[list]}})

({{TabView[{(Subscript[lbl, 1])->(Subscript[expr, 1]), (Subscript[lbl, 2])->(Subscript[expr, 2]), …}]}})

({{TabView[{(Subscript[lbl, 1])->(Subscript[expr, 1]),(Subscript[lbl, 2])->(Subscript[expr, 2]),…},i]}})

({{TabView[{{(Subscript[v, 1]),(Subscript[lbl, 1])->(Subscript[expr, 1])},{(Subscript[v, 2]),(Subscript[lbl, 2])->(Subscript[expr, 2])},…},v]}})

({{TabView[{(Subscript[expr, 1]),(Subscript[expr, 2]),…}]}})

({{TagBox[boxes,tag]}})

({{TakeLargest[list,n]}})

({{TakeLargest[n]}})

({{TakeLargestBy[list,f,n]}})

({{TakeLargestBy[f,n]}})

({{TakeSmallest[list,n]}})

({{TakeSmallest[n]}})

({{TakeSmallestBy[list,f,n]}})

({{TakeSmallestBy[f,n]}})

({{TaskWait[task]}})

({{TautologyQ[bf]}})

({{TautologyQ[expr,{(Subscript[a, 1]),(Subscript[a, 2]),…}]}})

({{TemplateApply[template]}})

({{TemplateApply[template,args]}})

({{TemplateBox[{(Subscript[box, 1]),(Subscript[box, 2]),…},tag]}})

({{TemplateExpression[expr]}})

({{TemplateIf[condition,tclause]}})

({{TemplateIf[condition,tclause,fclause]}})

({{TemplateObject[expr]}})

({{TemplateObject[form,args]}})

({{TemplateSequence[body,list]}})

({{TemplateSlot[n]}})

({{TemplateSlot[name]}})

({{TemporalData[{(Subscript[v, 1]),(Subscript[v, 2]),…},tspec]}})

({{TemporalData[{{(Subscript[v, 11]),(Subscript[v, 12]),…},{(Subscript[v, 21]),(Subscript[v, 22]),…},…},tspec]}})

({{TemporalData[{{(Subscript[t, 1]),(Subscript[v, 1])},{(Subscript[t, 2]),(Subscript[v, 2])}…}]}})

({{TemporalData[{{{(Subscript[t, 11]),(Subscript[v, 11])},{(Subscript[t, 12]),(Subscript[v, 12])}…},{{(Subscript[t, 21]),(Subscript[v, 21])},{(Subscript[t, 22]),(Subscript[v, 22])},…},…}]}})

({{TensorDimensions[tensor]}})

({{TensorExpand[texpr]}})

({{TensorRank[tensor]}})

({{TensorReduce[texpr]}})

({{TensorSymmetry[tensor]}})

({{TensorSymmetry[tensor,slots]}})

({{TestReport[{(Subscript[test, 1]),(Subscript[test, 2]),…}]}})

({{TestReport["file"]}})

({{Tetrahedron[{(Subscript[p, 1]),(Subscript[p, 2]),(Subscript[p, 3]),(Subscript[p, 4])}]}})

({{Tetrahedron[{{(Subscript[p, 1,1]),(Subscript[p, 1,2]),(Subscript[p, 1,3]),(Subscript[p, 1,4])},{(Subscript[p, 2,1]),…},…}]}})

({{Text[expr]}})

({{Text[expr,coords]}})

({{TextCases["text",form]}})

({{TextCases["text",form,n]}})

({{TextCell["string"]}})

({{TextCell["string","style"]}})

({{TextCell["string","(Subscript[style, 1])","(Subscript[style, 2])",…]}})

({{TextGrid[{{(Subscript[expr, 11]),(Subscript[expr, 12]),…},{(Subscript[expr, 21]),(Subscript[expr, 22]),…},…}]}})

({{TextPosition["text",form]}})

({{TextPosition["text",form,n]}})

({{TextRecognize[image]}})

({{TextRecognize[image,level]}})

({{TextRecognize[image,level,prop]}})

({{TextSearch["string"]}})

({{TextSearch[form]}})

({{TextSearch[source,form]}})

({{TextSearch[source,form,"prop"]}})

({{TextSearchReport[source,form]}})

({{TextString[expr]}})

({{TextTranslation["text"]}})

({{TextTranslation["text",lang]}})

({{TextTranslation["text",(Subscript[lang, 1])->(Subscript[lang, 2])]}})

({{ThermometerGauge[value]}})

({{ThermometerGauge[value,{min,max}]}})

({{ThermometerGauge[Dynamic[value],…]}})

({{Thinning[image]}})

({{Thinning[image,n]}})

({{Thinning[image,n,t]}})

({{ThreadingLayer[f]}})

({{Thumbnail[image]}})

({{Thumbnail[file]}})

({{Thumbnail[url]}})

({{Thumbnail[spec,size]}})

({{TideData[spec]}})

({{TideData[spec,prop]}})

({{TideData[spec,prop,datespec]}})

({{TimelinePlot[{(Subscript[date, 1]),(Subscript[date, 2]),…}]}})

({{TimelinePlot[{(Subscript[event, 1]),(Subscript[event, 2]),…}]}})

({{TimelinePlot[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{TimeObject[]}})

({{TimeObject[{h,m,s}]}})

({{TimeObject[date]}})

({{TimeSeries[{{(Subscript[t, 1]),(Subscript[v, 1])},{(Subscript[t, 2]),(Subscript[v, 2])}…}]}})

({{TimeSeries[{(Subscript[v, 1]),(Subscript[v, 2]),…},tspec]}})

({{TimeSeriesForecast[tproc,data,k]}})

({{TimeSeriesForecast[tsmod,k]}})

({{TimeSeriesModel[…]}})

({{TimeSeriesModelFit[data]}})

({{TimeSeriesModelFit[data,mspec]}})

({{TimeSeriesResample[tseries]}})

({{TimeSeriesResample[tseries,rspec]}})

({{TimeSeriesShift[tseries,shift]}})

({{TimeSeriesThread[f,{(Subscript[tseries, 1]),(Subscript[tseries, 2]),…}]}})

({{TimeSeriesWindow[tseries,{(Subscript[t, min]),(Subscript[t, max])}]}})

({{TimeValue[s,i,t]}})

({{ToContinuousTimeModel[lsys]}})

({{ToContinuousTimeModel[tfm,s]}})

({{ToDiscreteTimeModel[lsys,τ]}})

({{ToDiscreteTimeModel[tfm,τ,z]}})

({{Together[expr]}})

({{Toggler[x]}})

({{Toggler[Dynamic[x]]}})

({{Toggler[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{Toggler[x,{(Subscript[val, 1])->(Subscript[pict, 1]),(Subscript[val, 2])->(Subscript[pict, 2]),…}]}})

({{Toggler[x,vlist,dpict]}})

({{TogglerBar[x,{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{TogglerBar[Dynamic[x],{(Subscript[val, 1]),(Subscript[val, 2]),…}]}})

({{TogglerBar[x,{(Subscript[val, 1])->(Subscript[lbl, 1]),(Subscript[val, 2])->(Subscript[lbl, 2]),…}]}})

({{Tooltip[expr,label]}})

({{ToRadicals[expr]}})

({{ToString[expr]}})

({{ToString[expr,form]}})

({{Total[list]}})

({{Total[list,n]}})

({{Total[list,{n}]}})

({{Total[list,{(Subscript[n, 1]),(Subscript[n, 2])}]}})

({{TotalLayer[]}})

({{TotalVariationFilter[data]}})

({{TotalVariationFilter[data,param]}})

({{Trace[expr]}})

({{Trace[expr,form]}})

({{Trace[expr,s]}})

({{TraceDialog[expr]}})

({{TraceDialog[expr,form]}})

({{TraceDialog[expr,s]}})

({{TracePrint[expr]}})

({{TracePrint[expr,form]}})

({{TracePrint[expr,s]}})

({{TraceScan[f,expr]}})

({{TraceScan[f,expr,form]}})

({{TraceScan[f,expr,s]}})

({{TraceScan[f,expr,form,fp]}})

({{TradingChart[{{(Subscript[date, 1]),{(Subscript[open, 1]),(Subscript[high, 1]),(Subscript[low, 1]),(Subscript[close, 1]),(Subscript[volume, 1])}},…}]}})

({{TradingChart[{"name",daterange}]}})

({{TradingChart[{…},{(Subscript[ind, 1]),(Subscript[ind, 2]),…}]}})

({{TraditionalForm[expr]}})

({{TransferFunctionCancel[tfm]}})

({{TransferFunctionCancel[tfm,crit]}})

({{TransferFunctionModel[m,s]}})

({{TransferFunctionModel[{num,den},s]}})

({{TransferFunctionModel[{z,p,g},s]}})

({{TransferFunctionModel[sys]}})

({{TransformedDistribution[expr,x\[Distributed]dist]}})

({{TransformedDistribution[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}\[Distributed]dist]}})

({{TransformedDistribution[expr,x\[Distributed]proc]}})

({{TransformedDistribution[expr,{(Subscript[x, 1])\[Distributed](Subscript[dist, 1]),(Subscript[x, 2])\[Distributed](Subscript[dist, 2]) ,…}]}})

({{TransformedProcess[expr,x\[Distributed]proc,t]}})

({{TransformedProcess[expr,{(Subscript[x, 1])\[Distributed](Subscript[proc, 1]),(Subscript[x, 2])\[Distributed](Subscript[proc, 2]),…},t]}})

({{TransformedRegion[reg,f]}})

({{TransitiveClosureGraph[g]}})

({{TransitiveClosureGraph[{v->w,…}]}})

({{TransitiveReductionGraph[g]}})

({{TransitiveReductionGraph[{v->w,…}]}})

({{Transliterate["string"]}})

({{Transliterate["string",script]}})

({{Transliterate["string",(Subscript[script, 1])->(Subscript[script, 2])]}})

({{Transpose[list]}})

({{Transpose[list,{(Subscript[n, 1]),(Subscript[n, 2]),…}]}})

({{Transpose[list,m<->n]}})

({{TransposeLayer[]}})

({{TransposeLayer[m->n]}})

({{TravelDirections[{(Subscript[loc, 1]),(Subscript[loc, 2]),…}]}})

({{TravelDirections[{(Subscript[loc, 1]),(Subscript[loc, 2]),…},"prop"]}})

({{TravelDirectionsData[…]}})

({{TravelDistance[{(Subscript[loc, 1]),(Subscript[loc, 2]),…}]}})

({{TravelDistanceList[{(Subscript[loc, 1]),(Subscript[loc, 2]),…,(Subscript[loc, n])}]}})

({{TravelTime[{(Subscript[loc, 1]),(Subscript[loc, 2]),…}]}})

({{TreeForm[expr]}})

({{TreeForm[expr,n]}})

({{TreeGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[u, 1]),(Subscript[u, 2]),…}]}})

({{TreeGraph[{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{TreeGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},{(Subscript[e, 1]),(Subscript[e, 2]),…}]}})

({{TreeGraph[{…,(Subscript[w, i])[(Subscript[v, i]),…],…},{…,(Subscript[w, j])[(Subscript[e, j]),…],…}]}})

({{TreeGraph[{(Subscript[v, i])->(Subscript[v, j]),…}]}})

({{TreePlot[g]}})

({{TreePlot[{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[v, i2])->(Subscript[v, j2]),…}]}})

({{TreePlot[{{(Subscript[v, i1])->(Subscript[v, j1]),(Subscript[lbl, 1])},…}]}})

({{TreePlot[g,pos]}})

({{TreePlot[g,pos,(Subscript[v, k])]}})

({{Triangle[{(Subscript[p, 1]),(Subscript[p, 2]),(Subscript[p, 3])}]}})

({{Triangle[{{(Subscript[p, 11]),(Subscript[p, 12]),(Subscript[p, 13])},…}]}})

({{TriangulateMesh[bmr]}})

({{Trigger[Dynamic[u]]}})

({{Trigger[Dynamic[u],{(Subscript[u, min]),(Subscript[u, max])}]}})

({{Trigger[Dynamic[u],{(Subscript[u, min]),(Subscript[u, max]),du}]}})

({{Trigger[Dynamic[u],{(Subscript[u, min]),(Subscript[u, max])},ups]}})

({{TrigReduce[expr]}})

({{TTest[data]}})

({{TTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{TTest[dspec,(Subscript[μ, 0])]}})

({{TTest[dspec,(Subscript[μ, 0]),"property"]}})

({{Tube[{{(Subscript[x, 1]),(Subscript[y, 1]),(Subscript[z, 1])},{(Subscript[x, 2]),(Subscript[y, 2]),(Subscript[z, 2])},…}]}})

({{Tube[{(Subscript[pt, 1]),(Subscript[pt, 2]),…},r]}})

({{Tube[{{(Subscript[pt, 11]),(Subscript[pt, 12]),…},{(Subscript[pt, 21]),…},…},…]}})

({{Tube[curve,…]}})

({{TuranGraph[n,k]}})

({{UnderoverscriptBox[x,y,z]}})

({{UnderscriptBox[x,y]}})

({{UndirectedGraph[g]}})

({{UndirectedGraph[{v->w,…}]}})

({{UniformGraphDistribution[n,m]}})

({{Union[(Subscript[list, 1]),(Subscript[list, 2]),…]}})

({{Union[list]}})

({{UnitaryMatrixQ[m]}})

({{UnitRootTest[data]}})

({{UnitRootTest[data,model,"property"]}})

({{UnitSimplify[quantity]}})

({{UnitVector[k]}})

({{UnitVector[n,k]}})

({{UnitVectorLayer[n]}})

({{UnitVectorLayer[]}})

({{UpValues[f]}})

({{URLBuild["path",{"(Subscript[param, 1])"->(Subscript[val, 1]),"(Subscript[param, 2])"->(Subscript[val, 2]),…}]}})

({{URLBuild[{"(Subscript[path, 1])","(Subscript[path, 2])",…}]}})

({{URLBuild[path,params]}})

({{URLBuild[assoc]}})

({{URLBuild[assoc,params]}})

({{URLDecode["string"]}})

({{URLDownload[url]}})

({{URLDownload[{(Subscript[url, 1]),(Subscript[url, 2]),…}]}})

({{URLDownload[url,file]}})

({{URLDownload[{(Subscript[url, 1]),(Subscript[url, 2]),…},dir]}})

({{URLDownload[req,…]}})

({{URLDownload[{(Subscript[req, 1]),(Subscript[req, 2]),…},…]}})

({{URLDownloadSubmit[url, file]}})

({{URLDownloadSubmit[url,file,{"(Subscript[param, 1])"->(Subscript[val, 1]),"(Subscript[param, 2])"->(Subscript[val, 2]),…}]}})

({{URLDownloadSubmit[obj,…]}})

({{URLDownloadSubmit[HTTPRequest[…],…]}})

({{URLEncode["string"]}})

({{URLExecute[url]}})

({{URLExecute[url,{"(Subscript[param, 1])"->(Subscript[val, 1]),"(Subscript[param, 2])"->(Subscript[val, 2]),…}]}})

({{URLExecute[url,params,format]}})

({{URLExecute[obj,…]}})

({{URLExecute[HTTPRequest[…],…]}})

({{URLExpand["url"]}})

({{URLFetch["url"]}})

({{URLFetch["url",elements]}})

({{URLFetchAsynchronous["url",func]}})

({{URLParse["url"]}})

({{URLParse["url","component"]}})

({{URLParse["url",{(Subscript[component, 1]),(Subscript[component, 2]),…}]}})

({{URLQueryDecode["string"]}})

({{URLQueryEncode[\[LeftAssociation](Subscript[key, 1])->(Subscript[val, 1]),(Subscript[key, 2])->(Subscript[val, 2]),…\[RightAssociation]]}})

({{URLQueryEncode[{(Subscript[param, 1])->(Subscript[val, 1]),(Subscript[param, 2])->(Subscript[val, 1]),…}]}})

({{URLRead[url]}})

({{URLRead[assoc]}})

({{URLRead[HTTPRequest[…]]}})

({{URLRead[req,"elem"]}})

({{URLRead[req,{"(Subscript[elem, 1])","(Subscript[elem, 2])",…}]}})

({{URLRead[{(Subscript[req, 1]),(Subscript[req, 2]),…},…]}})

({{URLResponseTime[url]}})

({{URLResponseTime[url,prop]}})

({{URLSave["url\!\(\*StyleBox["\"", "TI"]\)]}})

({{URLSave["url","file"]}})

({{URLSave["url","file",elements]}})

({{URLSaveAsynchronous["url","file",func]}})

({{URLSubmit[url]}})

({{URLSubmit[url,{"(Subscript[param, 1])"->(Subscript[val, 1]),"(Subscript[param, 2])"->(Subscript[val, 2]),…}]}})

({{URLSubmit[obj,…]}})

({{URLSubmit[HTTPRequest[…],…]}})

({{Variables[poly]}})

({{VarianceEquivalenceTest[{(Subscript[data, 1]),(Subscript[data, 2]),…}]}})

({{VarianceEquivalenceTest[{(Subscript[data, 1]),…},"property"]}})

({{VarianceTest[data]}})

({{VarianceTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{VarianceTest[dspec,((Subscript[σ, 0])^2)]}})

({{VarianceTest[dspec,((Subscript[σ, 0])^2),"property"]}})

({{VerificationTest[input]}})

({{VerificationTest[input,expected]}})

({{VerificationTest[input,expected,messages]}})

({{VerticalGauge[value]}})

({{VerticalGauge[value,{min,max}]}})

({{VerticalGauge[Dynamic[value],…]}})

({{VerticalGauge[{(Subscript[value, 1]),(Subscript[value, 2]),…},…]}})

({{VerticalSlider[y]}})

({{VerticalSlider[Dynamic[y]]}})

({{VerticalSlider[y,{(Subscript[y, min]),(Subscript[y, max])}]}})

({{VerticalSlider[y,{(Subscript[y, min]),(Subscript[y, max]),dy}]}})

({{VerticalSlider[y,{{(Subscript[e, 1]),(Subscript[e, 2]),…}}]}})

({{VerticalSlider[y,{{{(Subscript[e, 1]),(Subscript[h, 1])},{(Subscript[e, 2]),(Subscript[h, 2])},…}}]}})

({{Volume[reg]}})

({{Volume[{(Subscript[x, 1]),…,(Subscript[x, n])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])},{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{Volume[{(Subscript[x, 1]),…,(Subscript[x, n])},{s,(Subscript[s, min]),(Subscript[s, max])},{t,(Subscript[t, min]),(Subscript[t, max])},{u,(Subscript[u, min]),(Subscript[u, max])},chart]}})

({{VoronoiMesh[{(Subscript[p, 1]),…,(Subscript[p, n])}]}})

({{VoronoiMesh[{(Subscript[p, 1]),…,(Subscript[p, n])},{{(Subscript[x, min]),(Subscript[x, max])},…}]}})

({{WaitAsynchronousTask[task]}})

({{WarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{WarpingCorrespondence[(Subscript[s, 1]),(Subscript[s, 2]),win]}})

({{WarpingDistance[(Subscript[s, 1]),(Subscript[s, 2])]}})

({{WarpingDistance[(Subscript[s, 1]),(Subscript[s, 2]),win]}})

({{WatershedComponents[image]}})

({{WatershedComponents[image,marker]}})

({{WatsonUSquareTest[data]}})

({{WatsonUSquareTest[data,dist]}})

({{WatsonUSquareTest[data,dist,"property"]}})

({{WaveletBestBasis[dwd]}})

({{WaveletBestBasis[dwd,cspec]}})

({{WaveletFilterCoefficients[wave,filt]}})

({{WaveletImagePlot[dwd]}})

({{WaveletImagePlot[dwd,r]}})

({{WaveletImagePlot[dwd,r,ifunc]}})

({{WaveletListPlot[dwd]}})

({{WaveletListPlot[dwd,wind]}})

({{WaveletListPlot[dwd,wind,func]}})

({{WaveletListPlot[{(Subscript[dwd, 1]),(Subscript[dwd, 2]),…},…]}})

({{WaveletMatrixPlot[dwd]}})

({{WaveletMatrixPlot[dwd,r]}})

({{WaveletMatrixPlot[dwd,r,func]}})

({{WaveletPhi[wave,x]}})

({{WaveletPhi[wave]}})

({{WaveletPsi[wave,x]}})

({{WaveletPsi[wave]}})

({{WaveletScalogram[wd]}})

({{WaveletScalogram[wd,wind]}})

({{WaveletScalogram[wd,wind,func]}})

({{WeaklyConnectedGraphComponents[g]}})

({{WeaklyConnectedGraphComponents[g,{(Subscript[v, 1]),(Subscript[v, 2]),…}]}})

({{WeaklyConnectedGraphComponents[g,patt]}})

({{WeaklyConnectedGraphComponents[{v->w,…},…]}})

({{WeatherForecastData[loc]}})

({{WeatherForecastData[prop]}})

({{WeatherForecastData[date]}})

({{WeatherForecastData[loc,prop]}})

({{WeatherForecastData[loc,prop,datespec]}})

({{WebImageSearch["string"]}})

({{WebImageSearch[form]}})

({{WebImageSearch[form,elems]}})

({{WebSearch["string"]}})

({{WebSearch[form]}})

({{WebSearch[form,elems]}})

({{WeightedAdjacencyGraph[wmat]}})

({{WeightedAdjacencyGraph[{(Subscript[v, 1]),(Subscript[v, 2]),…},wmat]}})

({{WeightedAdjacencyMatrix[g]}})

({{WeightedAdjacencyMatrix[{v->w,…}]}})

({{WheelGraph[n]}})

({{WhenEvent[event,action]}})

({{WienerFilter[data,r]}})

({{WienerFilter[data,r,ns]}})

({{WienerFilter[data,{(Subscript[r, 1]),(Subscript[r, 2]),…},…]}})

({{WikipediaData[article]}})

({{WikipediaData[article,property,options]}})

({{WikipediaData["Category"->category,property,options]}})

({{WikipediaData["PageID"->pageid,property,options]}})

({{WikipediaSearch[keywords]}})

({{WikipediaSearch["Title"->keywords,options]}})

({{WikipediaSearch["Category"->keywords,options]}})

({{WikipediaSearch["Content"->keywords]}})

({{WikipediaSearch[loc]}})

({{WilksWTest[(Subscript[m, 1]),(Subscript[m, 2])]}})

({{WilksWTest[…,"property"]}})

({{WindDirectionData[]}})

({{WindDirectionData[datespec]}})

({{WindDirectionData[locationspec]}})

({{WindDirectionData[locationspec,datespec]}})

({{WindDirectionData[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{WindSpeedData[]}})

({{WindSpeedData[datespec]}})

({{WindSpeedData[locationspec]}})

({{WindSpeedData[locationspec,datespec]}})

({{WindSpeedData[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{WindVectorData[]}})

({{WindVectorData[datespec]}})

({{WindVectorData[locationspec]}})

({{WindVectorData[locationspec,datespec]}})

({{WindVectorData[{{(Subscript[location, 1]),(Subscript[date, 1])},{(Subscript[location, 2]),(Subscript[date, 2])},…}]}})

({{WolframAlpha["query"]}})

({{WolframAlpha["query",format]}})

({{WordCloud[{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{WordCloud[{(Subscript[w, 1])->(Subscript[s, 1]),…}]}})

({{WordCloud[\[LeftAssociation](Subscript[s, 1])->(Subscript[w, 1]),…\[RightAssociation]]}})

({{WordCloud[{(Subscript[w, 1]),(Subscript[w, 2]),…}->{(Subscript[s, 1]),(Subscript[s, 2]),…}]}})

({{WordCloud[{{(Subscript[s, 1]),(Subscript[w, 1])},{(Subscript[s, 2]),(Subscript[w, 2])},…}]}})

({{WordCloud[data,shape]}})

({{WordCounts["string"]}})

({{WordCounts["string",n]}})

({{WordFrequency[text,word]}})

({{WordFrequency[text,{(Subscript[word, 1]),(Subscript[word, 2]),…}]}})

({{WordFrequencyData[word]}})

({{WordFrequencyData[{(Subscript[word, 1]),(Subscript[word, 2]),…}]}})

({{WordFrequencyData[word,"TimeSeries"]}})

({{WordFrequencyData[word,"TimeSeries",datespec]}})

({{WordFrequencyData[word,"prop"]}})

({{WordList[]}})

({{WordList[type]}})

({{WordStem["word"]}})

({{XMLTemplate["string"]}})

({{XMLTemplate[src]}})

({{XMLTemplate[form,args]}})

({{Zeta[s]}})

({{Zeta[s,a]}})

({{ZTest[data]}})

({{ZTest[{(Subscript[data, 1]),(Subscript[data, 2])}]}})

({{ZTest[dspec,(σ^2)]}})

({{ZTest[dspec,(σ^2),(Subscript[μ, 0])]}})

({{ZTest[dspec,(σ^2),(Subscript[μ, 0]),"property"]}})

({{ZTransform[expr,n,z]}})

({{ZTransform[expr,{(Subscript[n, 1]),(Subscript[n, 2]),…},{(Subscript[z, 1]),(Subscript[z, 2]),…}]}})

({{Animate[expr,{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{Animate[expr,{u,(Subscript[u, min]),(Subscript[u, max]),du}]}})

({{Animate[expr,{u,{(Subscript[u, 1]),(Subscript[u, 2]),…}}]}})

({{Animate[expr,{u,…},{v,…},…]}})

({{Apart[expr]}})

({{Apart[expr,var]}})

({{ApartSquareFree[expr]}})

({{ApartSquareFree[expr,var]}})

({{ArcCurvature[{(Subscript[x, 1]),…,(Subscript[x, n])},t]}})

({{ArcCurvature[{(Subscript[x, 1]),…,(Subscript[x, n])},t,chart]}})

({{ArcLength[reg]}})

({{ArcLength[{(Subscript[x, 1]),…,(Subscript[x, n])},{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{ArcLength[{(Subscript[x, 1]),…,(Subscript[x, n])},{t,(Subscript[t, min]),(Subscript[t, max])},chart]}})

({{BodePlot[lsys]}})

({{BodePlot[lsys,{(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{BodePlot[expr,{ω,(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{Collect[expr,x]}})

({{Collect[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{Collect[expr,var,h]}})

({{ComplexExpand[expr]}})

({{ComplexExpand[expr,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{ContourPlot[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{ContourPlot[f==g,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{ContourPlot[{(Subscript[f, 1])==(Subscript[g, 1]),(Subscript[f, 2])==(Subscript[g, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{ContourPlot[…,{x,y}∈reg]}})

({{ContourPlot3D[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{ContourPlot3D[f==g,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{ControllerManipulate[expr,{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{ControllerManipulate[expr,{u,(Subscript[u, min]),(Subscript[u, max]),du}]}})

({{ControllerManipulate[expr,{{u,(Subscript[u, init])},(Subscript[u, min]),(Subscript[u, max]),…}]}})

({{ControllerManipulate[expr,{u,{(Subscript[u, 1]),(Subscript[u, 2]),…}}]}})

({{ControllerManipulate[expr,{u,…},{v,…},…]}})

({{ControllerManipulate[expr,"(Subscript[c, u])"->{u,…},"(Subscript[c, v])"->{v,…},…]}})

({{Curl[{(Subscript[f, 1]),(Subscript[f, 2])},{(Subscript[x, 1]),(Subscript[x, 2])}]}})

({{Curl[{(Subscript[f, 1]),(Subscript[f, 2]),(Subscript[f, 3])},{(Subscript[x, 1]),(Subscript[x, 2]),(Subscript[x, 3])}]}})

({{Curl[f,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{Curl[f,x,chart]}})

({{D[f,x]}})

({{D[f,{x,n}]}})

({{D[f,x,y,…]}})

({{D[f,{x,n},{y,m},…]}})

({{D[f,{{(Subscript[x, 1]),(Subscript[x, 2]),…}}]}})

({{D[f,{array}]}})

({{DensityPlot[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{DensityPlot[f,{x,y}∈reg]}})

({{DiscreteLimit[f[k],k->∞]}})

({{DiscreteLimit[f[(Subscript[k, 1]),…,(Subscript[k, n])],{(Subscript[k, 1])->(Subscript[k, 1]^( * )),…,(Subscript[k, n])->(Subscript[k, n]^( * ))}]}})

({{DiscreteLimit[f[(Subscript[k, 1]),…,(Subscript[k, n])],{(Subscript[k, 1]),…,(Subscript[k, n])}->{(Subscript[k, 1]^( * )),…,(Subscript[k, n]^( * ))}]}})

({{DiscreteMaxLimit[f[k],k->∞]}})

({{DiscreteMaxLimit[f[(Subscript[k, 1]),…,(Subscript[k, n])],{(Subscript[k, 1])->(Subscript[k, 1]^( * )),…,(Subscript[k, n])->(Subscript[k, n]^( * ))}]}})

({{DiscreteMaxLimit[f,{(Subscript[k, 1]),…,(Subscript[k, n])}->{(Subscript[k, 1]^( * )),…,(Subscript[k, n]^( * ))}]}})

({{DiscreteMinLimit[f[k],k->∞]}})

({{DiscreteMinLimit[f[(Subscript[k, 1]),…,(Subscript[k, n])],{(Subscript[k, 1])->(Subscript[k, 1]^( * )),…,(Subscript[k, n])->(Subscript[k, n]^( * ))}]}})

({{DiscreteMinLimit[f[(Subscript[k, 1]),…,(Subscript[k, n])],{(Subscript[k, 1]),…,(Subscript[k, n])}->{(Subscript[k, 1]^( * )),…,(Subscript[k, n]^( * ))}]}})

({{DiscretePlot[expr,{n,(Subscript[n, max])}]}})

({{DiscretePlot[expr,{n,(Subscript[n, min]),(Subscript[n, max])}]}})

({{DiscretePlot[expr,{n,(Subscript[n, min]),(Subscript[n, max]),dn}]}})

({{DiscretePlot[expr,{n,{(Subscript[n, 1]),(Subscript[n, 2]),…}}]}})

({{DiscretePlot[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},…]}})

({{DiscretePlot3D[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])}]}})

({{DiscretePlot3D[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di},{j,(Subscript[j, min]),(Subscript[j, max]),dj}]}})

({{DiscretePlot3D[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}},{j,{(Subscript[j, 1]),(Subscript[j, 2]),…}}]}})

({{DiscretePlot3D[{(Subscript[expr, 1]),(Subscript[expr, 2]),…},…,…]}})

({{Div[{(Subscript[f, 1]),…,(Subscript[f, n])},{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{Div[{(Subscript[f, 1]),…,(Subscript[f, n])},{(Subscript[x, 1]),…,(Subscript[x, n])},chart]}})

({{Do[expr,n]}})

({{Do[expr,{i,(Subscript[i, max])}]}})

({{Do[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{Do[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{Do[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{Do[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{FactorTerms[poly]}})

({{FactorTerms[poly,x]}})

({{FactorTerms[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{FactorTermsList[poly]}})

({{FactorTermsList[poly,{(Subscript[x, 1]),(Subscript[x, 2]),…}]}})

({{FindMaximum[f,x]}})

({{FindMaximum[f,{x,(Subscript[x, 0])}]}})

({{FindMaximum[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMaximum[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMaximum[{f,cons},{x,y,…}]}})

({{FindMinimum[f,x]}})

({{FindMinimum[f,{x,(Subscript[x, 0])}]}})

({{FindMinimum[f,{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMinimum[{f,cons},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindMinimum[{f,cons},{x,y,…}]}})

({{FindRoot[f,{x,(Subscript[x, 0])}]}})

({{FindRoot[lhs==rhs,{x,(Subscript[x, 0])}]}})

({{FindRoot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FindRoot[{(Subscript[eqn, 1]),(Subscript[eqn, 2]),…},{{x,(Subscript[x, 0])},{y,(Subscript[y, 0])},…}]}})

({{FourierCosTransform[expr,t,ω]}})

({{FourierCosTransform[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[ω, 1]),(Subscript[ω, 2]),…}]}})

({{FourierSinTransform[expr,t,ω]}})

({{FourierSinTransform[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[ω, 1]),(Subscript[ω, 2]),…}]}})

({{FourierTransform[expr,t,ω]}})

({{FourierTransform[expr,{(Subscript[t, 1]),(Subscript[t, 2]),…},{(Subscript[ω, 1]),(Subscript[ω, 2]),…}]}})

({{FrenetSerretSystem[{(Subscript[x, 1]),…,(Subscript[x, n])},t]}})

({{FrenetSerretSystem[{(Subscript[x, 1]),…,(Subscript[x, n])},t,chart]}})

({{FunctionInterpolation[expr,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{FunctionInterpolation[expr,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},…]}})

({{Grad[f,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{Grad[f,{(Subscript[x, 1]),(Subscript[x, 2]),…},chart]}})

({{Integrate[f,x]}})

({{Integrate[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{Integrate[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},…]}})

({{Integrate[f,{x,y,…}∈reg]}})

({{Laplacian[f,{(Subscript[x, 1]),…,(Subscript[x, n])}]}})

({{Laplacian[f,{(Subscript[x, 1]),…,(Subscript[x, n])},chart]}})

({{Limit[f[x],x->(SuperStar[x])]}})

({{Limit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1])->(Subscript[x, 1]^( * )),…,(Subscript[x, n])->(Subscript[x, n]^( * ))}]}})

({{Limit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{LineIntegralConvolutionPlot[{{(Subscript[v, x]),(Subscript[v, y])},image},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{LineIntegralConvolutionPlot[{(Subscript[v, x]),(Subscript[v, y])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{ListLineIntegralConvolutionPlot[{array,image}]}})

({{ListLineIntegralConvolutionPlot[array]}})

({{ListLineIntegralConvolutionPlot[{{{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[vx, 1]),(Subscript[vy, 1])}},…},image}]}})

({{ListLineIntegralConvolutionPlot[{{{(Subscript[x, 1]),(Subscript[y, 1])},{(Subscript[vx, 1]),(Subscript[vy, 1])}},…}]}})

({{LogLinearPlot[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogLinearPlot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogLinearPlot[{…,w[(Subscript[f, i])],…},…]}})

({{LogLinearPlot[…,{x}∈reg]}})

({{LogLogPlot[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogLogPlot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogLogPlot[{…,w[(Subscript[f, i])],…},…]}})

({{LogLogPlot[…,{x}∈reg]}})

({{LogPlot[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogPlot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{LogPlot[{…,w[(Subscript[f, i])],…},…]}})

({{LogPlot[…,{x}∈reg]}})

({{Manipulate[expr,{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{Manipulate[expr,{u,(Subscript[u, min]),(Subscript[u, max]),du}]}})

({{Manipulate[expr,{{u,(Subscript[u, init])},(Subscript[u, min]),(Subscript[u, max]),…}]}})

({{Manipulate[expr,{{u,(Subscript[u, init]),(Subscript[u, lbl])},…}]}})

({{Manipulate[expr,{u,{(Subscript[u, 1]),(Subscript[u, 2]),…}}]}})

({{Manipulate[expr,{u,…},{v,…},…]}})

({{Manipulate[expr,"(Subscript[c, u])"->{u,…},"(Subscript[c, v])"->{v,…},…]}})

({{MaxLimit[f[x],x->(SuperStar[x])]}})

({{MaxLimit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1])->(Subscript[x, 1]^( * )),…,(Subscript[x, n])->(Subscript[x, n]^( * ))}]}})

({{MaxLimit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{MinLimit[f[x],x->(SuperStar[x])]}})

({{MinLimit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1])->(Subscript[x, 1]^( * )),…,(Subscript[x, n])->(Subscript[x, n]^( * ))}]}})

({{MinLimit[f[(Subscript[x, 1]),…,(Subscript[x, n])],{(Subscript[x, 1]),…,(Subscript[x, n])}->{(Subscript[x, 1]^( * )),…,(Subscript[x, n]^( * ))}]}})

({{NicholsPlot[lsys]}})

({{NicholsPlot[lsys,{(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{NicholsPlot[expr,{ω,(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{NIntegrate[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{NIntegrate[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},…]}})

({{NIntegrate[f,{x,y,…}∈reg]}})

({{NProduct[f,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{NProduct[f,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{NSum[f,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{NSum[f,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{NyquistPlot[lsys]}})

({{NyquistPlot[lsys,{(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{NyquistPlot[expr,{ω,(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{ParallelDo[expr,{(Subscript[i, max])}]}})

({{ParallelDo[expr,{i,(Subscript[i, max])}]}})

({{ParallelDo[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ParallelDo[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{ParallelDo[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{ParallelDo[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{ParallelProduct[expr,{i,(Subscript[i, max])}]}})

({{ParallelProduct[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ParallelProduct[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{ParallelProduct[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{ParallelProduct[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{ParallelSum[expr,{i,(Subscript[i, max])}]}})

({{ParallelSum[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ParallelSum[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{ParallelSum[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{ParallelSum[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{ParallelTable[expr,{(Subscript[i, max])}]}})

({{ParallelTable[expr,{i,(Subscript[i, max])}]}})

({{ParallelTable[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{ParallelTable[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{ParallelTable[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{ParallelTable[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{ParametricPlot[{(Subscript[f, x]),(Subscript[f, y])},{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{ParametricPlot[{{(Subscript[f, x]),(Subscript[f, y])},{(Subscript[g, x]),(Subscript[g, y])},…},{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{ParametricPlot[{(Subscript[f, x]),(Subscript[f, y])},{u,(Subscript[u, min]),(Subscript[u, max])},{v,(Subscript[v, min]),(Subscript[v, max])}]}})

({{ParametricPlot[{{(Subscript[f, x]),(Subscript[f, y])},{(Subscript[g, x]),(Subscript[g, y])},…},{u,(Subscript[u, min]),(Subscript[u, max])},{v,(Subscript[v, min]),(Subscript[v, max])}]}})

({{ParametricPlot[…,{u,v}∈reg]}})

({{ParametricPlot3D[{(Subscript[f, x]),(Subscript[f, y]),(Subscript[f, z])},{u,(Subscript[u, min]),(Subscript[u, max])}]}})

({{ParametricPlot3D[{(Subscript[f, x]),(Subscript[f, y]),(Subscript[f, z])},{u,(Subscript[u, min]),(Subscript[u, max])},{v,(Subscript[v, min]),(Subscript[v, max])}]}})

({{ParametricPlot3D[{{(Subscript[f, x]),(Subscript[f, y]),(Subscript[f, z])},{(Subscript[g, x]),(Subscript[g, y]),(Subscript[g, z])}…}…]}})

({{ParametricPlot3D[…,{u,v}∈reg]}})

({{Play[f,{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{Plot[f,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{Plot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{Plot[{…,w[(Subscript[f, i])],…},…]}})

({{Plot[…,{x}∈reg]}})

({{Plot3D[f,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{Plot3D[{(Subscript[f, 1]),(Subscript[f, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{Plot3D[…,{x,y}∈reg]}})

({{PolarPlot[r,{θ,(Subscript[θ, min]),(Subscript[θ, max])}]}})

({{PolarPlot[{(Subscript[f, 1]),(Subscript[f, 2]),…},{θ,(Subscript[θ, min]),(Subscript[θ, max])}]}})

({{Product[f,{i,(Subscript[i, max])}]}})

({{Product[f,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{Product[f,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{Product[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{Product[f,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{Product[f,i]}})

({{RegionPlot[pred,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{RegionPlot3D[pred,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{RepeatingElement[spec]}})

({{RepeatingElement[spec,max]}})

({{RepeatingElement[spec,{min,max}]}})

({{RepeatingElement[spec,{n,{min,max}}]}})

({{RepeatingElement[spec,{{i,n},{min,max}}]}})

({{RevolutionPlot3D[(Subscript[f, z]),{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{RevolutionPlot3D[(Subscript[f, z]),{t,(Subscript[t, min]),(Subscript[t, max])},{θ,(Subscript[θ, min]),(Subscript[θ, max])}]}})

({{RevolutionPlot3D[{(Subscript[f, x]),(Subscript[f, z])},{t,(Subscript[t, min]),(Subscript[t, max])}]}})

({{RevolutionPlot3D[{(Subscript[f, x]),(Subscript[f, z])},{t,(Subscript[t, min]),(Subscript[t, max])},{θ,(Subscript[θ, min]),(Subscript[θ, max])}]}})

({{RevolutionPlot3D[{(Subscript[f, x]),(Subscript[f, y]),(Subscript[f, z])},{t,(Subscript[t, min]),(Subscript[t, max])},…]}})

({{RootLocusPlot[lsys,{k,(Subscript[k, min]),(Subscript[k, max])}]}})

({{Series[f,{x,(Subscript[x, 0]),n}]}})

({{Series[f,{x,(Subscript[x, 0]),(Subscript[n, x])},{y,(Subscript[y, 0]),(Subscript[n, y])}]}})

({{SingularValuePlot[lsys]}})

({{SingularValuePlot[lsys,{(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{SingularValuePlot[expr,{ω,(Subscript[ω, min]),(Subscript[ω, max])}]}})

({{SphericalPlot3D[r,θ,ϕ]}})

({{SphericalPlot3D[r,{θ,(Subscript[θ, min]),(Subscript[θ, max])},{ϕ,(Subscript[ϕ, min]),(Subscript[ϕ, max])}]}})

({{SphericalPlot3D[{(Subscript[r, 1]),(Subscript[r, 2]),…},{θ,(Subscript[θ, min]),(Subscript[θ, max])},{ϕ,(Subscript[ϕ, min]),(Subscript[ϕ, max])}]}})

({{StreamDensityPlot[{{(Subscript[v, x]),(Subscript[v, y])},s},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{StreamDensityPlot[{(Subscript[v, x]),(Subscript[v, y])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{StreamDensityPlot[{{(Subscript[v, x]),(Subscript[v, y])},{(Subscript[w, x]),(Subscript[w, y])},…,s},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{StreamDensityPlot[…,{x,y}∈reg]}})

({{StreamPlot[{(Subscript[v, x]),(Subscript[v, y])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{StreamPlot[{{(Subscript[v, x]),(Subscript[v, y])},{(Subscript[w, x]),(Subscript[w, y])},…},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{StreamPlot[…,{x,y}∈reg]}})

({{Sum[f,{i,(Subscript[i, max])}]}})

({{Sum[f,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{Sum[f,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{Sum[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{Sum[f,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{Sum[f,i]}})

({{Table[expr,n]}})

({{Table[expr,{i,(Subscript[i, max])}]}})

({{Table[expr,{i,(Subscript[i, min]),(Subscript[i, max])}]}})

({{Table[expr,{i,(Subscript[i, min]),(Subscript[i, max]),di}]}})

({{Table[expr,{i,{(Subscript[i, 1]),(Subscript[i, 2]),…}}]}})

({{Table[expr,{i,(Subscript[i, min]),(Subscript[i, max])},{j,(Subscript[j, min]),(Subscript[j, max])},…]}})

({{VectorDensityPlot[{{(Subscript[v, x]),(Subscript[v, y])},s},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{VectorDensityPlot[{(Subscript[v, x]),(Subscript[v, y])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{VectorDensityPlot[{{(Subscript[v, x]),(Subscript[v, y])},{(Subscript[w, x]),(Subscript[w, y])},…,s},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{VectorDensityPlot[…,{x,y}∈reg]}})

({{VectorPlot[{(Subscript[v, x]),(Subscript[v, y])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{VectorPlot[{{(Subscript[v, x]),(Subscript[v, y])},{(Subscript[w, x]),(Subscript[w, y])},…},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{VectorPlot[…,{x,y}∈reg]}})

({{VectorPlot3D[{(Subscript[v, x]),(Subscript[v, y]),(Subscript[v, z])},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{VectorPlot3D[{(Subscript[field, 1]),(Subscript[field, 2]),…},{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])},{z,(Subscript[z, min]),(Subscript[z, max])}]}})

({{For[start,test,incr,body]}})

({{If[condition,t,f]}})

({{If[condition,t,f,u]}})

({{Implies[p,q]}})

({{Nand[(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{NDSolve[eqns,u,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{NDSolve[eqns,u,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{NDSolve[eqns,u,{x,y}∈Ω]}})

({{NDSolve[eqns,u,{t,(Subscript[t, min]),(Subscript[t, max])},{x,y}∈Ω]}})

({{NDSolve[eqns,{(Subscript[u, 1]),(Subscript[u, 2]),…},…]}})

({{NDSolveValue[eqns,expr,{x,(Subscript[x, min]),(Subscript[x, max])}]}})

({{NDSolveValue[eqns,expr,{x,(Subscript[x, min]),(Subscript[x, max])},{y,(Subscript[y, min]),(Subscript[y, max])}]}})

({{NDSolveValue[eqns,expr,{x,y}∈Ω]}})

({{NDSolveValue[eqns,u,{t,(Subscript[t, min]),(Subscript[t, max])},{x,y}∈Ω]}})

({{Nor[(Subscript[e, 1]),(Subscript[e, 2]),…]}})

({{NRoots[lhs==rhs,var]}})

({{NSolve[expr,vars]}})

({{NSolve[expr,vars,Reals]}})

({{Reduce[expr,vars]}})

({{Reduce[expr,vars,dom]}})

({{Solve[expr,vars]}})

({{Solve[expr,vars,dom]}})

({{SolveAlways[eqns,vars]}})

({{Which[(Subscript[test, 1]),(Subscript[value, 1]),(Subscript[test, 2]),(Subscript[value, 2]),…]}})

({{While[test,body]}})

({{Xor[(Subscript[e, 1]),(Subscript[e, 2]),…]}})