Core Language
Please visit the official Wolfram Language Reference for more details and examples on core symbols.
CreateDocument
CreateDocument[{expr1, expr2, ...}] creates an empty notebook and populates with the content.
Use the option Visible->False to create the content and the notebook offscreen
NotebookOpen
NotebookOpen[nb] opens programmatically notebook nb given by RemoteNotebook object or a path
NotebookWrite
NotebookWrite[nb, expr] write expr as a cell, or group of cells to the notebook nb
NotebookClose
NotebookClose[nb] closes opened notebook nb
NotebookSave
NotebookSave[nb] or NotebookSave[nb, path] saves notebook nb to a file given by path or using the existing temporal path
NotebookEvaluate
NotebookEvaluate[nb] evaluates the initialization cells of the notebook and returns the result of the last Wolfram Language cell.
Not recommended to use! Consider NotebookEvaluateAsync instead
Animate
Animate[expr_, {t, tmin, tmax}] animates expr starting from tmin to tmax with a default rate.
EvaluationNotebook
EvaluationNotebook[] gives the notebook in which this function is being evaluated.
Let
A With-like construction that allows recursive assignments, like Let* in scheme
CreateType
CreateType[type, parent, init, {fields}] create type
Button
Button[label,action] represents a button that is labeled with label, and evaluates action whenever it is clicked.
CellularAutomaton
CellularAutomaton[rule,init,t] generates a list representing the evolution of the cellular automaton with the specified rule from initial condition init for t steps.
CellularAutomaton[rule,init] gives the result of evolving init for one step.
CellularAutomaton[rule,init,{tspec,xspec,…}] gives only those parts of the evolution specified by tspec, xspec, etc.
CellularAutomaton[rule,init,{t,All,…}] includes at each step all cells that could be affected over the course of t steps.
CellularAutomaton[rule] is an operator form of CellularAutomaton that represents one step of evolution.
CreateFrontEndObject
CreateFrontEndObject[expr] uploads expression to frontend storage and creates a reference to it. On output it will try to evaluate it using WLJS Intepreter
Riffle
Riffle[{e1,e2,…},x] gives {e1,x,e2,x,…}.
Riffle[{e1,e2,…},{x1,x2,…}] gives {e1,x1,e2,x2,…}.
Riffle[list,x,n] yields a list in which every nth element is x.
Riffle[list,x,{imin,imax,n}] yields a list in which x appears if possible at positions imin, imin+n, imin+2n, … , imax.
SystemDialogInput
SystemDialogInput["type"] brings up an interactive system dialog and returns the value chosen in the dialog.
SystemDialogInput["type",init] uses init as the initial setting in the dialog.
ChoiceDialog
ChoiceDialog[expr] puts up a standard choice dialog that displays expr together with OK and Cancel buttons, and returns True if OK is clicked and False if Cancel is clicked.
ChoiceDialog[expr,{lbl1->val1,lbl2->val2,…}] includes buttons with labels lbli, and returns the corresponding vali for the button clicked.
TabView
TabView[{lbl1->expr1, lbl2->expr2, …}] represents an object in which clicking the tab with label lbli displays expri.
TabView[{lbl1->expr1,lbl2->expr2,…},i] makes the ith tab be the one currently selected.
TabView[{{v1,lbl1->expr1},{v2,lbl2->expr2},…},v] associates values vi with successive tabs, and makes the tab with value v be the one currently selected.
TabView[{expr1,expr2,…}] takes the tab labels to be successive integers.
StringTake
StringTake["string",n] gives a string containing the first n characters in "string".
StringTake["string",-n] gives the last n characters in "string".
StringTake["string",{n}] gives the nth character in "string".
StringTake["string",{m,n}] gives characters m through n in "string".
StringTake["string",{spec1,spec2,…}] gives a list of the substrings specified by the speci.
StringTake[{s1,s2,…},spec] gives the list of results for each of the si.
StringDrop
StringDrop["string",n] gives "string" with its first n characters dropped.
StringDrop["string",-n] gives "string" with its last n characters dropped.
StringDrop["string",{n}] gives "string" with its nth character dropped.
StringDrop["string",{m,n}] gives "string" with characters m through n dropped.
StringDrop[{s1,s2,…},spec] gives the list of results for each of the si.
AnimatedImage
AnimatedImage[{image1,image2,…}] generates an animation whose frames are the successive imagei.
AnimatedImage[file] represents an animated image from file.
ByteCount
ByteCount[expr] gives the number of bytes used internally by the Wolfram System to store expr.
Sum
Sum[f,{i,imax}] evaluates the sum ∑+i=1%imaxf.
Sum[f,{i,imin,imax}] starts with i=imin.
Sum[f,{i,imin,imax,di}] uses steps di.
Sum[f,{i,{i1,i2,…}}] uses successive values i1, i2, ….
Sum[f,{i,imin,imax},{j,jmin,jmax},…] evaluates the multiple sum ∑+i=imin%imax∑+j=jmin%jmax…f.
Sum[f,i] gives the indefinite sum ∑+if.
Product
Product[f,{i,imax}] evaluates the product ∏+i=1%imaxf.
Product[f,{i,imin,imax}] starts with i=imin.
Product[f,{i,imin,imax,di}] uses steps di.
Product[f,{i,{i1,i2,…}}] uses successive values i1, i2, ….
Product[f,{i,imin,imax},{j,jmin,jmax},…] evaluates the multiple product ∏+i=imin%imax∏+j=jmin%jmax… f.
Product[f,i] gives the indefinite product ∏+if.
Differences
Differences[list] gives the successive differences of elements in list.
Differences[list,n] gives the nth differences of list.
Differences[list,n,s] gives the differences of elements step s apart.
Differences[list,{n1,n2,…}] gives the successive nkth differences at level k in a nested list.
Drop
Drop[list,n] gives list with its first n elements dropped.
Drop[list,-n] gives list with its last n elements dropped.
Drop[list,{n}] gives list with its nth element dropped.
Drop[list,{m,n}] gives list with elements m through n dropped.
Drop[list,{m,n,s}] gives list with elements m through n in steps of s dropped.
Drop[list,seq1,seq2,…] gives a nested list in which elements specified by seqi have been dropped at level i in list.
NotebookDirectory
NotebookDirectory[] gives the directory of the current evaluation notebook.
NotebookDirectory[nb] gives the directory for the notebook specified by nb.
EvaluationCell
EvaluationCell[] returns a CellObject corresponding to the cell in which this function is being evaluated.
SystemOpen
SystemOpen["target"] opens the specified file, URL, or other target with the associated program on your computer system.
Annotation
Annotation[expr,data] represents an expression expr, with annotation data.
Annotation[expr,data,"type"] specifies the type of annotation being given.
Annotation[items,key->value] associates key->value pairs with items in objects such as Graph, MeshRegion etc.
Integrate
Integrate[f,x] gives the indefinite integral ∫f dx.
Integrate[f,{x,xmin,xmax}] gives the definite integral ∫xminxmax f dx.
Integrate[f,{x,xmin,xmax},{y,ymin,ymax},…] gives the multiple integral ∫xminxmaxdx∫yminymaxdy … f.
Integrate[f,{x,y,…}∈reg] integrates over the geometric region reg.
TableForm
TableForm[list] prints with the elements of list arranged in an array of rectangular cells.
Item
Item[expr,options] represents an item within constructs such as Grid, Overlay, and Manipulate that displays with expr as the content, and with the specified options applied to the region containing expr.
ToExpression
ToExpression[input] gives the expression obtained by interpreting strings or boxes as Wolfram Language input.
ToExpression[input,form] uses interpretation rules corresponding to the specified form.
ToExpression[input,form,h] wraps the head h around the expression produced before evaluating it.
MakeBoxes
MakeBoxes[expr,form] is the low‐level function used in Wolfram System sessions to convert expressions into boxes.
MakeBoxes[expr] is the function to convert expr to StandardForm boxes.
Transpose
Transpose[list] transposes the first two levels in list.
Transpose[list,{n1,n2,…}] transposes list so that the kth level in list is the nkth level in the result.
Transpose[list,mn] transposes levels m and n in list, leaving all other levels unchanged.
Transpose[list,k] cycles the levels in list k positions to the right.
Series
Series[f,{x,x0,n}] generates a power series expansion for f about the point x=x0 to order (x-x0)n, where n is an explicit integer.
Series[f,x->x0] generates the leading term of a power series expansion for f about the point x=x0.
Series[f,{x,x0,nx},{y,y0,ny},…] successively finds series expansions with respect to x, then y, etc.
AASTriangle
AASTriangle[α,β,a] returns a filled triangle with angles α and β and side length a, where a is adjacent to one angle only.
AbelianGroup
AbelianGroup[{n1,n2,…}] represents the direct product of the cyclic groups of degrees n1,n2,….
Abort
Abort[] generates an interrupt to abort a computation.
AbortKernels
AbortKernels[] aborts evaluations running in all parallel subkernels.
AbortProtect
AbortProtect[expr] evaluates expr, saving any aborts until the evaluation is complete.
Above
Above is a symbol that represents the region above an object for purposes of placement.
Abs
Abs[z] gives the absolute value of the real or complex number z.
AbsArg
AbsArg[z] gives the list {Abs[z],Arg[z]} of the number z.
AbsArgPlot
AbsArgPlot[f,{x,xmin,xmax}] generates a plot of Abs[f] colored by Arg[f] as a function of x∈ from xmin to xmax.
AbsArgPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions.
AbsArgPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
AbsArgPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
AbsoluteCorrelationFunction
AbsoluteCorrelationFunction[data,hspec] estimates the absolute correlation function at lags hspec from data.
AbsoluteCorrelationFunction[proc,hspec] represents the absolute correlation function at lags hspec for the random process proc.
AbsoluteCorrelationFunction[proc,s,t] represents the absolute correlation function at times s and t for the random process proc.
AbsoluteCurrentValue
AbsoluteCurrentValue[item] gives the absolute current value of item at a location in the Wolfram System and interface.
AbsoluteCurrentValue[{item,spec}] gives the absolute current value for the feature of item specified by spec.
AbsoluteCurrentValue[obj,item] gives the absolute current value of item associated with the object obj.
AbsoluteCurrentValue[{obj1,obj2,…},item] gives a list of the absolute current values associated with each of the obji.
AbsoluteDashing
AbsoluteDashing[{d1,d2,…}] is a graphics directive which specifies that lines which follow are to be drawn dashed, with successive segments having absolute lengths d1, d2, … (repeated cyclically).
AbsoluteDashing[d] is equivalent to AbsoluteDashing[{d,d}].
AbsoluteDashing[{d1,d2,…},offset] offsets the dashes by offset.
AbsoluteDashing[{d1,d2,…},offset,capform] sets the CapForm for individual dashes to capform.
AbsoluteFileName
AbsoluteFileName["name"] gives the full absolute version of the name for a file in your filesystem.
AbsoluteOptions
AbsoluteOptions[obj] gives the absolute settings of options used by the given object.
AbsoluteOptions[obj,name] gives the absolute setting for the option name.
AbsoluteOptions[obj,{name1,name2,…}] gives a list of the absolute settings for the options namei.
AbsolutePointSize
AbsolutePointSize[d] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with absolute diameter d.
AbsoluteThickness
AbsoluteThickness[d] is a graphics directive which specifies that lines which follow are to be drawn with absolute thickness d.
AbsoluteTime
AbsoluteTime[] gives the total number of seconds since the beginning of January 1, 1900, in your time zone.
AbsoluteTime[date] gives the absolute time specification corresponding to the given date specification.
AbsoluteTiming
AbsoluteTiming[expr] evaluates expr, returning a list of the absolute number of seconds in real time that have elapsed, together with the result obtained.
AcceptanceThreshold
AcceptanceThreshold is an option that specifies the minimum threshold at which a result is considered acceptable.
AccountingForm
AccountingForm[expr] prints with all numbers in expr given in standard accounting notation.
AccountingForm[expr,n] prints with numbers given to n‐digit precision.
Accumulate
Accumulate[list] gives a list of the successive accumulated totals of elements in list.
Accuracy
Accuracy[x] gives the effective number of digits to the right of the decimal point in the number x.
AccuracyGoal
AccuracyGoal is an option for various numerical operations which specifies how many effective digits of accuracy should be sought in the final result.
Activate
Activate[expr] replaces all instances of Inactive[f] in expr with f.
Activate[expr,patt] replaces only instances of Inactive[f] for which f matches the pattern patt.
ActiveClassification
ActiveClassification[f,{conf1,conf2,…}] gives an object representing the result of active classification obtained by using the function f to determine classes for the example configurations confi.
ActiveClassification[f,reg] generates configurations within the region specified by reg.
ActiveClassification[f,sampler] generates configurations by applying the function sampler.
ActiveClassification[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from one of the confi.
ActiveClassificationObject
ActiveClassificationObject[…] represents the result of an ActiveClassification process.
ActivePrediction
ActivePrediction[f,{conf1,conf2, …}] gives an object representing the result of active prediction obtained by using the function f to determine values for the example configurations confi.
ActivePrediction[f,reg] generates configurations within the region specified by reg.
ActivePrediction[f,sampler] generates configurations by applying the function sampler.
ActivePrediction[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from one of the confi.
ActivePredictionObject
ActivePredictionObject[…] represents the result of an ActivePrediction process.
AddTo
x+=dx adds dx to x and returns the new value of x.
AddToSearchIndex
AddToSearchIndex[obj,content] adds the specified content to the existing search index object obj.
AddToSearchIndex[obj,{content1,…}] adds all the contenti to obj.
AdjacencyGraph
AdjacencyGraph[amat] gives the graph with adjacency matrix amat.
AdjacencyGraph[{v1,v2,…},amat] gives the graph with vertices vi and adjacency matrix amat.
AdjacencyList
AdjacencyList[g,v] gives a list of vertices adjacent to vertex v.
AdjacencyList[g,patt] gives a list of vertices adjacent to vertices that match the pattern patt.
AdjacencyList[g,patt,d] gives a list of vertices that are at distance at most d.
AdjacencyList[{v->w,…},…] uses rules v->w to specify the graph g.
AdjacencyMatrix
AdjacencyMatrix[g] gives the vertex–vertex adjacency matrix of the graph g.
AdjacencyMatrix[{v->w,…}] uses rules v->w to specify the graph g.
Adjugate
Adjugate[m] gives the adjugate of a square matrix m.
AffineHalfSpace
AffineHalfSpace[{p1,…,pk+1},w] represents AffineSpace[{p1,…,pk+1}] extended in the direction w.
AffineHalfSpace[p,{v1,…,vk},w] represents AffineSpace[p,{v1,…,vk}] extended in the direction w.
AffineSpace
AffineSpace[{p1,…,pk+1}] represents the affine space passing through the points pi.
AffineSpace[p,{v1,…,vk}] represents the affine space passing through p in the directions vi.
AffineStateSpaceModel
AffineStateSpaceModel[{a,b,c,d},x] represents the affine state-space model x'(t)a(x(t))+b(x(t)).u(t), y(t)=c(x(t))+d(x(t)).u(t).
AffineStateSpaceModel[sys] gives an affine state-space model corresponding to the system model sys.
AffineStateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},t] gives the affine state-space model obtained by Taylor input linearization about the dependent variable xi at xi0 and input uj at uj0 of the differential equations eqns with outputs gi and independent variable t.
AffineTransform
AffineTransform[m] gives a TransformationFunction that represents an affine transform that maps r to m.r.
AffineTransform[{m,v}] gives an affine transform that maps r to m.r+v.
After
After is a symbol that represents the region after an object for purposes of placement.
AggregatedEntityClass
AggregatedEntityClass[class,"prop"->f] represents an entity class containing a single entity with the property prop whose value is the result of applying the function f to the whole specified entity class.
AggregatedEntityClass[class,{prop1->f1,prop2->f2,…}] constructs multiple properties propi obtained by applying fi to class.
AggregatedEntityClass[class,propspec,gprop] forms groups of elements of class according to their values of the property gprop, then generates an entity class with an entity for each of these groups.
AggregatedEntityClass[class,propspec,"pname"->f] forms groups according to the values obtained by applying the entity function f, with the resulting property named pname.
AggregatedEntityClass[class,propspec,{gspec1,gspec2,…}] forms groups for which the set of values defined by the gspeci is distinct.
AggregationLayer
AggregationLayer[f] represents a layer that aggregates an array of arbitrary rank into a vector, using the function f.
AggregationLayer[f,n] aggregates an array at level n.
AggregationLayer[f,n1;;n2] aggregates an array at levels n1 through n2.
AggregationLayer[f,{n1,n2,…}] aggregates an array at levels n1,n2,….
AiryAi
AiryAi[z] gives the Airy function Ai(z).
AiryAiPrime
AiryAiPrime[z] gives the derivative of the Airy function Ai′(z).
AiryAiZero
AiryAiZero[k] represents the kth zero of the Airy function Ai(x).
AiryAiZero[k,x0] represents the kth zero less than x0.
AiryBi
AiryBi[z] gives the Airy function Bi(z).
AiryBiPrime
AiryBiPrime[z] gives the derivative of the Airy function Bi′(z).
AiryBiZero
AiryBiZero[k] represents the kth zero of the Airy function Bi(x).
AiryBiZero[k,x0] represents the kth zero less than x0.
AlgebraicIntegerQ
AlgebraicIntegerQ[a] yields True if a is an algebraic integer, and yields False otherwise.
AlgebraicNumberDenominator
AlgebraicNumberDenominator[a] gives the smallest positive integer n such that n a is an algebraic integer.
AlgebraicNumberNorm
AlgebraicNumberNorm[a] gives the norm of the algebraic number a.
AlgebraicNumberPolynomial
AlgebraicNumberPolynomial[a,x] gives the polynomial in x corresponding to the AlgebraicNumber object a.
AlgebraicNumberTrace
AlgebraicNumberTrace[a] gives the trace of the algebraic number a.
AlgebraicRulesData
AlgebraicRulesData is an object returned by AlgebraicRules. Its OutputForm appears to be a list of rules, but the rules will be used algebraically rather than syntactically by Replace and related functions.
Algebraics
Algebraics represents the domain of algebraic numbers, as in x∈Algebraics.
AlgebraicUnitQ
AlgebraicUnitQ[a] yields True if a is an algebraic unit, and yields False otherwise.
AlignmentPoint
AlignmentPoint is an option which specifies how objects should by default be aligned when they appear in Inset.
All
All is a setting used for certain options. In Part and related functions, All specifies all parts at a particular level.
AllowedFrequencyRange
AllowedFrequencyRange is an option for audio and signal processing functions that specifies the range of frequencies of interest.
AllowLooseGrammar
AllowLooseGrammar is an option for GrammarRules and related functions that specifies whether grammatical "fluff" should automatically be ignored in applying grammar rules.
AllTrue
AllTrue[{e1,e2,…},test] yields True if test[ei] is True for all of the ei.
AllTrue[expr,test,level] tests parts of expr at level level.
AllTrue[test] represents an operator form of AllTrue that can be applied to an expression.
Alphabet
Alphabet[] gives a list of the lowercase letters a through z in the English alphabet.
Alphabet[type] gives the alphabet for the language or class type.
Alphabet[type,prop] gives the alphabet defined by prop for the language or class type .
AlphabeticOrder
AlphabeticOrder["string1","string2"] gives 1 if "string1" appears before "string2" in alphabetical order, -1 if it is after, and 0 if it is identical.
AlphabeticOrder["string1","string2",lang] uses an ordering suitable for the language lang.
AlphabeticOrder[lang] represents an operator form that compares strings when applied to "string1", "string2".
AlphabeticSort
AlphabeticSort[list] sorts the elements of list into alphabetical order.
AlphabeticSort[list,lang] sorts using an ordering suitable for the language lang.
AlphaChannel
AlphaChannel[color] returns the opacity of color.
AlphaChannel[image] returns the alpha channel of image.
AlphaChannel[video] returns a video containing the alpha channel of the frames in video.
AlternateImage
AlternateImage is an option to CDFInformation that specifies an image that should be used if the plugin is not available.
AlternatingFactorial
AlternatingFactorial[n] gives the alternating factorial af(n).
AlternatingGroup
AlternatingGroup[n] represents the alternating group of degree n.
AlternativeHypothesis
AlternativeHypothesis is an option for hypothesis testing functions like LocationTest that specifies the alternative hypothesis.
Alternatives
p1|p2|… is a pattern object that represents any of the patterns pi.
AmbiguityFunction
AmbiguityFunction is an option for SemanticInterpretation, Interpreter, and related functions that specifies how to resolve ambiguities generated during semantic interpretation.
AmbiguityList
AmbiguityList[{expr1,expr2,…}] represents possible results derived from an ambiguous semantic interpretation.
AmbiguityList[{expr1,expr2,…},"string"] represents possible results from semantic interpretation of an input string.
AmbiguityList[{expr1,expr2,…},"string",{assoc1,assoc2,…}] includes a sequence of associations giving details of the interpretations used to obtain the expri.
Analytic
Analytic is an option for Limit and Series. With Analytic -> True, unrecognized functions are treated as analytic, and processed using Taylor series expansions; with Analytic -> False, Taylor series are not used unless the function is recognized as analytic.
AnatomyData
AnatomyData[entity,property] gives the value of the specified property for the anatomical structure entity.
AnatomyData[{entity1,entity2,…},property] gives a list of property values for the specified anatomical structure entities.
AnatomyData[entity,property,annotation] gives the specified annotation associated with the given property.
AnatomyPlot3D
AnatomyPlot3D[primitives,options] represents a three-dimensional graphical image that works with anatomical entities as well as standard 3D graphics primitives and directives.
AnchoredSearch
AnchoredSearch is an option for Find and FindList that specifies whether the text searched for must be at the beginning of a record.
And
e1&&e2&&… is the logical AND function. It evaluates its arguments in order, giving False immediately if any of them are False, and True if they are all True.
AndersonDarlingTest
AndersonDarlingTest[data] tests whether data is normally distributed using the Anderson–Darling test.
AndersonDarlingTest[data,dist] tests whether data is distributed according to dist using the Anderson–Darling test.
AndersonDarlingTest[data,dist,"property"] returns the value of "property".
AngerJ
AngerJ[ν,z] gives the Anger function Jν(z).
AngerJ[ν,μ,z] gives the associated Anger function Jνμ(z).
AngleBisector
AngleBisector[{q1,p,q2}] gives the bisector of the interior angle at p formed by the triangle with vertex points p, q1 and q2.
AngleBisector[{q1,p,q2},"type"] gives the angle bisector of the specified type.
AngleBracket
AngleBracket[x,y,…] displays as 〈x,y,…〉.
AnglePath
AnglePath[{θ1,θ2,θ3,…}] gives the list of 2D coordinates corresponding to a path that starts at {0,0}, then takes a series of steps of unit length at successive relative angles θi.
AnglePath[{{r1,θ1},{r2,θ2},{r3,θ3},…}] takes successive steps of lengths ri.
AnglePath[θ0,{step1,step2,…}] starts at angle θ0 with respect to the x axis.
AnglePath[{x,y},{step1,step2,…}] starts at the point {x,y} with initial angle 0 with respect to the x axis.
AnglePath[{{x,y},θ0},{step1,step2,…}] starts at {x,y} with initial angle θ0 with respect to the x axis.
AnglePath[{{x,y},{dx,dy}},{step1,step2,…}] takes the first step to go from {x,y} to {x+dx,y+dy}.
AnglePath[init,steps,form] returns at each step the data of the form specified by form.
AnglePath3D
AnglePath3D[{{α1,β1,γ1},{α2,β2,γ2},…}] gives the list of 3D coordinates of a path of an object that starts at {0,0,0}, then takes a series of steps of unit length, each in the direction of the x axis obtained after successive rotation of the object by the Euler angles αi, βi, γi.
AnglePath3D[{{α1,β1},{α2,β2},…}] assumes the Euler angles γi to be 0.
AnglePath3D[{mat1,mat2,…}] takes the successive rotations to be specified by the 3D rotation matrices mati.
AnglePath3D[{{r1,rot1},{r2,rot2},…}] takes successive steps of length ri with Euler angles or rotation matrices specified by roti.
AnglePath3D[{x0,y0,z0},steps] starts at the point {x0,y0,z0}.
AnglePath3D[{rot0},steps] starts in the x axis direction specified by rotating the object according to Euler angles or rotation matrix rot0.
AnglePath3D[{{x0,y0,z0},rot0},steps] starts at point {x0,y0,z0} with the x axis direction specified by rot0.
AnglePath3D[init,steps,form] returns at each step the data of the form specified by form.
AngleVector
AngleVector[θ] gives the list representing the 2D unit vector at angle θ relative to the x axis.
AngleVector[{r,θ}] gives the list representing the 2D vector of length r at angle θ.
AngleVector[{x,y},θ] gives the result of starting from the point {x,y}, then going a unit distance at angle θ.
AngleVector[{x,y},{r,θ}] gives the result of starting from the point {x,y}, then going distance r at angle θ.
AnimationRate
AnimationRate is an option for Animate and Animator that specifies at what rate an animation should run, in units per second.
AnimationRepetitions
AnimationRepetitions is an option to Animate and related functions that specifies how many times the animation they create runs before stopping.
Annuity
Annuity[p,t] represents an annuity of fixed payments p made over t periods.
Annuity[p,t,q] represents a series of payments occurring at time intervals q.
Annuity[{p,{pinitial,pfinal}},t,q] represents an annuity with the specified initial and final payments.
AnnuityDue
AnnuityDue[p,t] represents an annuity due of fixed payments p made over t periods.
AnnuityDue[p,t,q] represents a series of payments occurring at time intervals q.
AnnuityDue[{p,{pinitial,pfinal}},t,q] represents an annuity due with the specified initial and final payments.
Annulus
Annulus[{x,y},{rinner,router}] represents an annulus centered at {x,y} with inner radius rinner and outer radius router.
Annulus[{x,y},{rinner,router},{θ1,θ2}] represents an annulus from angle θ1 to θ2.
AnomalyDetection
AnomalyDetection[{example1,example2,…}] generates an AnomalyDetectorFunction[…] based on the examples given.
AnomalyDetection[LearnedDistribution[…]] generates an anomaly detector based on the given distribution.
AnomalyDetection[<|True->{example11,example12,…},False->{example21,…}|>] can be used to indicate which examples should be considered anomalous.
AnomalyDetector
AnomalyDetector is an option for functions such as Classify that specifies an anomaly detector for them to include.
AnomalyDetectorFunction
AnomalyDetectorFunction[…] represents a function generated by AnomalyDetection for detecting whether data is anomalous or not.
Anonymous
Anonymous represents an option or other value that indicates the absence of a name.
Antialiasing
Antialiasing is an option that specifies whether antialiasing should be done.
Antihermitian
Antihermitian[{1,2}] represents the symmetry of an antihermitian matrix.
AntihermitianMatrixQ
AntihermitianMatrixQ[m] gives True if m is explicitly antihermitian, and False otherwise.
Antisymmetric
Antisymmetric[{s1,…,sn}] represents the symmetry of a tensor that is antisymmetric in the slots si.
AntisymmetricMatrixQ
AntisymmetricMatrixQ[m] gives True if m is explicitly antisymmetric, and False otherwise.
Antonyms
Antonyms["word"] returns the antonyms associated with the specified word.
AnyOrder
AnyOrder[p1,p2,…] is a grammar rules pattern object that represents a sequence of elements matching p1, p2, … in any order.
AnySubset
AnySubset[{c1,c2,…}] represents an element in an interpreter or form that accepts any subset of the choices ci.
AnySubset[{lab1->c1,lab2->c2,…}] accepts any subset of the labi, yielding the corresponding ci as results.
AnySubset[EntityClass["type","class"]] accepts any subset of the entities in the specified entity class.
AnySubset[choices,max] allows at most max choices to be selected.
AnySubset[choices,{min,max}] allows at least min and at most max choices to be selected.
AnyTrue
AnyTrue[{e1,e2,…},test] yields True if test[ei] is True for any of the ei.
AnyTrue[expr,test,level] tests parts of expr at level level.
AnyTrue[test] represents an operator form of AnyTrue that can be applied to an expression.
Apart
Apart[expr] rewrites a rational expression as a sum of terms with minimal denominators.
Apart[expr,var] treats all variables other than var as constants.
ApartSquareFree
ApartSquareFree[expr] rewrites a rational expression as a sum of terms whose denominators are powers of square-free polynomials.
ApartSquareFree[expr,var] treats all variables other than var as constants.
APIFunction
APIFunction[{name1->type1,name2->type2,…},fun] represents an API with parameters namei that evaluates the function fun whenever it is called. The function fun is applied to <|name1->val1,name2->val2,…|>, where the vali are the settings for the parameters, interpreted as being of types typei.
APIFunction[{name1->type1->default1,…},fun] takes the value of the parameter namei to be defaulti if it is not specified when the API is called.
APIFunction[params,fun,fmt] specifies that the result from applying fun should be returned in format fmt.
APIFunction[params,fun,{fmt,rform}] specifies that the result should be returned as a response of the form rform.
APIFunction[params,fun,{fmt,rform,failfmt}] specifies that in the event of failure, the result should be returned in format failfmt.
Appearance
Appearance is an option for displayed objects such as Button and Slider that specifies the general type of appearance they should have.
AppearanceElements
AppearanceElements is an option for functions like Manipulate that specifies what elements should be included in the displayed form of the object generated.
AppearanceRules
AppearanceRules is an option for form and page generation functions that specifies the overall appearance of the generated object.
AppellF1
AppellF1[a,b1,b2,c,x,y] is the Appell hypergeometric function of two variables F1(a;b1,b2;c;x,y).
Append
Append[expr,elem] gives expr with elem appended.
Append[elem] represents an operator form of Append that can be applied to an expression.
AppendLayer
AppendLayer[] represents a net layer that takes an input array and appends another array to it.
AppendTo
AppendTo[x,elem] appends elem to the value of x, and resets x to the result.
Application
fg or Application[f,g] represents the formal application of f to g.
Apply
f@@expr or Apply[f,expr] replaces the head of expr by f.
f@@@expr or Apply[f,expr,{1}] replaces heads at level 1 of expr by f.
Apply[f,expr,levelspec] replaces heads in parts of expr specified by levelspec.
Apply[f] represents an operator form of Apply that can be applied to an expression.
ApplyTo
ApplyTo[x,f] or x//=f computes f[x] and resets x to the result.
ArcCos
ArcCos[z] gives the arc cosine cos-1(z) of the complex number z.
ArcCosh
ArcCosh[z] gives the inverse hyperbolic cosine cosh-1(z) of the complex number z.
ArcCot
ArcCot[z] gives the arc cotangent cot-1(z) of the complex number z.
ArcCoth
ArcCoth[z] gives the inverse hyperbolic cotangent coth-1(z) of the complex number z.
ArcCsc
ArcCsc[z] gives the arc cosecant csc-1(z) of the complex number z.
ArcCsch
ArcCsch[z] gives the inverse hyperbolic cosecant csch-1(z) of the complex number z.
ArcCurvature
ArcCurvature[{x1,…,xn},t] gives the curvature of the parametrized curve whose Cartesian coordinates xi are functions of t.
ArcCurvature[{x1,…,xn},t,chart] interprets the xi as coordinates in the specified coordinate chart.
ARCHProcess
ARCHProcess[κ,{α1,…,αq}] represents an autoregressive conditionally heteroscedastic process of order q, driven by a standard white noise.
ARCHProcess[κ,{α1,…,αq},init] represents an ARCH process with initial data init.
ArcLength
ArcLength[reg] gives the length of the one-dimensional region reg.
ArcLength[{x1,…,xn},{t,tmin,tmax}] gives the length of the parametrized curve whose Cartesian coordinates xi are functions of t.
ArcLength[{x1,…,xn},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.
ArcSec
ArcSec[z] gives the arc secant sec-1(z) of the complex number z.
ArcSech
ArcSech[z] gives the inverse hyperbolic secant sech-1(z) of the complex number z.
ArcSin
ArcSin[z] gives the arc sine sin-1(z) of the complex number z.
ArcSinDistribution
ArcSinDistribution[{xmin,xmax}] represents the arc sine distribution supported between xmin and xmax.
ArcSinDistribution[] represents the arc sine distribution supported between zero and one.
ArcSinh
ArcSinh[z] gives the inverse hyperbolic sine sinh-1(z) of the complex number z.
ArcTan
ArcTan[z] gives the arc tangent tan-1(z) of the complex number z.
ArcTan[x,y] gives the arc tangent of y/x, taking into account which quadrant the point (x,y) is in.
ArcTanh
ArcTanh[z] gives the inverse hyperbolic tangent tanh-1(z) of the complex number z.
Area
Area[reg] gives the area of the two-dimensional region reg.
Area[{x1,…,xn},{s,smin,smax},{t,tmin,tmax}] gives the area of the parametrized surface whose Cartesian coordinates xi are functions of s and t.
Area[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.
Arg
Arg[z] gives the argument of the complex number z.
ArgMax
ArgMax[f,x] gives a position xmax at which f is maximized.
ArgMax[f,{x,y,…}] gives a position {xmax,ymax,…} at which f is maximized.
ArgMax[{f,cons},{x,y,…}] gives a position at which f is maximized subject to the constraints cons.
ArgMax[…,x∈rdom] constrains x to be in the region or domain rdom.
ArgMax[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
ArgMin
ArgMin[f,x] gives a position xmin at which f is minimized.
ArgMin[f,{x,y,…}] gives a position {xmin,ymin,…} at which f is minimized.
ArgMin[{f,cons},{x,y,…}] gives a position at which f is minimized subject to the constraints cons.
ArgMin[…,x∈rdom] constrains x to be in the region or domain rdom.
ArgMin[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
ArgumentCountQ
ArgumentCountQ[head, len, min, max] tests whether the number len of arguments of a function head is between min and max.
ArgumentCountQ[head,len,{m1,m2,…,mi}] tests whether the number len of arguments of a function head is one of the mi.
ArgumentsOptions
ArgumentsOptions[f[args],n] tries to separate args into a list of n positional arguments followed by a list of valid options for f.
ArgumentsOptions[f[args],{min,max}] requires the number of positional arguments to be between min and max.
ArgumentsOptions[f[args],spec,assoc] modifies the behavior based on the information in the association assoc.
ArithmeticGeometricMean
ArithmeticGeometricMean[a,b] gives the arithmetic‐geometric mean of a and b.
Around
Around[x,δ] represents an approximate number or quantity with a value around x and an uncertainty δ.
Around[x,{δ-,δ+}] represents a number or quantity with a value around x and asymmetric uncertainties δ-, δ+.
Around[dist] gives an approximate number or quantity around the mean of the distribution dist, with an uncertainty corresponding to the standard deviation of the distribution.
Around[list] gives an approximate object around the mean of the elements of list and with an uncertainty corresponding to their standard deviation.
Around[s] gives an approximate object derived from the number, interval or string specification s.
AroundReplace
AroundReplace[expr,{s1->Around[x1,δ1],s2->Around[x2,δ2],…}] propagates uncertainty in expr by replacing all occurrences of si by Around[xi,δi].
AroundReplace[expr,rules,n] propagates uncertainty in expr using a series expansion to order n.
Array
Array[f,n] generates a list of length n, with elements f[i].
Array[f,n,r] generates a list using the index origin r.
Array[f,n,{a,b}] generates a list using n values from a to b.
Array[f,{n1,n2,…}] generates an n1×n2×… array of nested lists, with elements f[i1,i2,…].
Array[f,{n1,n2,…},{r1,r2,…}] generates a list using the index origins ri (default 1).
Array[f,{n1,n2,…},{{a1,b1},{a2,b2},…}] generates a list using ni values from ai to bi.
Array[f,dims,origin,h] uses head h, rather than List, for each level of the array.
ArrayComponents
ArrayComponents[array] gives an array in which all identical elements of array are replaced by an integer index representing the component in which the element lies.
ArrayComponents[array,level] finds the identical elements at the specified level in array
ArrayComponents[array,level,rules] uses a rule or a list of rules for specifying the labels.
ArrayDepth
ArrayDepth[expr] gives the depth to which expr is a full array, with all the parts at a particular level having the same length.
ArrayFilter
ArrayFilter[f,array,r] applies f to all range-r blocks in the specified array.
ArrayFilter[f,array,{r1,r2,…}] applies f to blocks with ranges r1, r2, … in successive dimensions.
ArrayFilter[f,array,template] applies f over blocks specified by the position of 1s in the array template.
ArrayFlatten
ArrayFlatten[{{m11,m12,…},{m21,m22,…},…}] creates a single flattened matrix from a matrix of matrices mij.
ArrayFlatten[a,r] flattens out r pairs of levels in the array a.
ArrayPad
ArrayPad[array,m] gives an array with m zeros of padding on every side.
ArrayPad[array,m,padding] uses the specified padding.
ArrayPad[array,{m,n},…] pads with m elements at the beginning and n elements at the end.
ArrayPad[array,{{m1,n1},{m2,n2},…},…] pads with mi, ni elements at level i in array.
ArrayPlot
ArrayPlot[array] generates a plot in which the values in an array are shown in a discrete array of squares.
ArrayPlot3D
ArrayPlot3D[array] generates a plot in which the values in an array are shown in a discrete array of cubes.
ArrayQ
ArrayQ[expr] gives True if expr is a full array or a SparseArray object, and gives False otherwise.
ArrayQ[expr,patt] requires expr to be a full array with a depth that matches the pattern patt.
ArrayQ[expr,patt,test] requires also that test yield True when applied to each of the array elements in expr.
ArrayReduce
ArrayReduce[f,array,n] reduces dimension n of array by applying f.
ArrayReduce[f,array,n1;;n2] reduces dimensions n1 through n2.
ArrayReduce[f,array,{n1,n2,…}] reduces dimensions n1, n2, etc.
ArrayReduce[f,array,{{n11,n12,…},{n21,n22,…},…}] applies f to arrays formed by combining all dimensions nij to make each dimension i.
ArrayResample
ArrayResample[array,{n1,n2,…}] resamples array to have dimensions {n1,n2,…}.
ArrayResample[array,dspec] resamples array according to the dimension specification dspec.
ArrayResample[array,dspec,scheme] specifies resampling scheme, either point or bin based.
ArrayResample[array,dspec,scheme,{{xmin,xmax},…}] resamples only the data in the specified subrange {{xmin,xmax},…}.
ArrayReshape
ArrayReshape[list,dims] arranges the elements of list into a rectangular array with dimensions dims.
ArrayReshape[list,dims,padding] uses the specified padding if list does not contain enough elements.
ArrayRules
ArrayRules[SparseArray[…]] gives the rules {pos1->val1,pos2->val2,…} specifying elements in a sparse array.
ArrayRules[list] gives rules for SparseArray[list].
Arrays
Arrays[{d1,…,dr}] represents the domain of arrays of rank r and dimensions di.
Arrays[{d1,…,dr},dom] represents the domain of arrays of dimensions di, with components in the domain dom.
Arrays[{d1,…,dr},dom,sym] represents the subdomain of arrays with dimensions di and symmetry sym.
Arrow
Arrow[{pt1,pt2}] is a graphics primitive that represents an arrow from pt1 to pt2.
Arrow[{pt1,pt2},s] represents an arrow with its ends set back from pt1 and pt2 by a distance s.
Arrow[{pt1,pt2},{s1,s2}] sets back by s1 from pt1 and s2 from pt2.
Arrow[curve,…] represents an arrow following the specified curve.
Arrowheads
Arrowheads[spec] is a graphics directive specifying that arrows that follow should have arrowheads with sizes, positions, and forms specified by spec.
ASATriangle
ASATriangle[α,c,β] returns a filled triangle with angles α and β and side length c, and c is adjacent to both angles.
AspectRatio
AspectRatio is an option for Graphics and related functions that specifies the ratio of height to width for a plot.
Assert
Assert[test] represents the assertion that test is True. If assertions have been enabled, test is evaluated when the assertion is encountered. If test is not True, then an assertion failure is generated.
Assert[test,tag] specifies a tag that will be used to identify the assertion if it fails.
AssessmentFunction
AssessmentFunction[key] represents a tool for assessing whether answers are correct according to the key.
AssessmentFunction[key,method] uses the specified answer comparison method.
AssessmentFunction[key,f] uses the function f to compare answers with the key.
AssessmentFunction[key,comp] performs assessment using the custom assessment defined in the Association comp.
AssessmentFunction[obj] represents an assessment function that performs assessment using the CloudObject obj.
AssessmentFunction[{obj,id}] assesses the specified question within the CloudObject obj.
AssessmentFunction[…][answer] gives an AssessmentResultObject representing the correctness of answer.
AssessmentResultObject
AssessmentResultObject[assoc] represents the results of an assessment.
AssessmentResultObject[{aro1,aro2,…}] represents a collection of many assessments.
AssociateTo
AssociateTo[a,key->val] changes the association a by adding the key-value pair key->val.
AssociateTo[a,{key1->val1,key2->val2,…}] adds all key-value pairs keyi->vali.
Association
Association[key1->val1,key2->val2,…] or <|key1->val1,key2->val2,…|> represents an association between keys and values.
AssociationFormat
AssociationFormat is an option to TextString and related functions that determines how associations are formatted.
AssociationMap
AssociationMap[f,{key1,key2,…}] creates the association <|key1->f[key1],key2->f[key2],…|>.
AssociationMap[f,<|key1->val1,key2->val2,…|>] creates the association <|f[key1->val1],f[key2->val2],…|>.
AssociationMap[f] represents an operator form of AssociationMap that can be applied to an expression.
AssociationQ
AssociationQ[expr] gives True if expr is a valid Association object, and False otherwise.
AssociationThread
AssociationThread[{key1,key2,…}->{val1,val2,…}] gives the association <|key1->val1,key2->val2,…|>.
AssociationThread[{key1,key2,…},{val1,val2,…}] also gives the association <|key1->val1,key2->val2,…|>.
AssumeDeterministic
AssumeDeterministic is an option for functions such as BayesianMinimization that specifies whether or not the function being considered should be assumed to be deterministic.
Assuming
Assuming[assum,expr] evaluates expr with assum appended to $Assumptions, so that assum is included in the default assumptions used by functions such as Refine, Simplify, and Integrate.
Assumptions
Assumptions is an option for functions such as Simplify, Refine, and Integrate that specifies default assumptions to be made about symbolic quantities.
AstronomicalData
AstronomicalData["name","property"] gives the value of the specified property of the astronomical object with the specified name.
AstronomicalData["name",{"property",date}] gives the value of a property at a particular date and time.
Asymptotic
Asymptotic[expr,x->x0] gives an asymptotic approximation for expr near x0.
Asymptotic[expr,{x,x0,n}] gives an asymptotic approximation for expr near x0 to order n.
AsymptoticDSolveValue
AsymptoticDSolveValue[eqn,f,x->x0] computes an asymptotic approximation to the differential equation eqn for f[x] centered at x0.
AsymptoticDSolveValue[{eqn1,eqn2,…},{f1,f2,…},x->x0] computes an asymptotic approximation to a system of differential equations.
AsymptoticDSolveValue[eqn,f,x,ϵ->ϵ0] computes an asymptotic approximation of f[x,ϵ] for the parameter ϵ centered at ϵ0.
AsymptoticDSolveValue[eqn,f,…,{ξ,ξ0,n}] computes the asymptotic approximation to order n.
AsymptoticEqual
AsymptoticEqual[f,g,x->x*] gives conditions for f(x)≍g(x) or f(x)∈Θ(g(x)) as x->x*.
AsymptoticEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≍g(x1,…,xn) or f(x1,…,xn)∈Θ(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticEquivalent
AsymptoticEquivalent[f,g,x->x*] gives conditions for f(x)∼g(x) as x->x*.
AsymptoticEquivalent[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn) ~g(x1,…,xn) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticExpectation
AsymptoticExpectation[expr,xdist,a->a0] computes an asymptotic approximation for the expectation of expr centered at a0, under the assumption that x follows the probability distribution dist.
AsymptoticExpectation[expr,{x1,x2,…}dist,a->a0] computes an asymptotic approximation for the expectation of expr centered at a0, under the assumption that {x1,x2,…} follows the multivariate distribution dist.
AsymptoticExpectation[expr,vars,{a,a0,n}] computes the asymptotic expectation to order n.
AsymptoticGreater
AsymptoticGreater[f,g,x->x*] gives conditions for f(x)≻g(x) or f(x)∈ω(g(x)) as x->x*.
AsymptoticGreater[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≻g(x1,…,xn) or f(x1,…,xn)∈ω(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticGreaterEqual
AsymptoticGreaterEqual[f,g,x->x*] gives conditions for f(x)⪰g(x) or f(x)∈Ω(g(x)) as x->x*.
AsymptoticGreaterEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)⪰g(x1,…,xn) or f(x1,…,xn)∈Ω(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticLess
AsymptoticLess[f,g,x->x*] gives conditions for f(x)≺g(x) or f(x)∈o(g(x)) as x->x*.
AsymptoticLess[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)≺g(x1,…,xn) or f(x1,…,xn)∈o(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticLessEqual
AsymptoticLessEqual[f,g,x->x*] gives conditions for f(x)⪯g(x) or f(x)∈O(g(x)) as x->x*.
AsymptoticLessEqual[f,g,{x1,…,xn}->{x1*,…,xn*}] gives conditions for f(x1,…,xn)⪯g(x1,…,xn) or f(x1,…,xn)∈O(g(x1,…,xn)) as {x1,…,xn}->{x1*,…,xn*}.
AsymptoticOutputTracker
AsymptoticOutputTracker[sys,{f1,…},{p1,…}] gives the state feedback control law that causes the outputs of the affine system sys to track the reference signals fi with decay rates pj.
AsymptoticOutputTracker[{sys,{out1,…},{in1,…}},…] specifies outputs outi and control inputs inj to use.
AsymptoticProbability
AsymptoticProbability[pred,xdist,a->a0] computes an asymptotic approximation for the probability of pred centered at a0, under the assumption that x follows the probability distribution dist.
AsymptoticProbability[pred,{x1,x2,…}dist,a->a0] computes an asymptotic approximation for the probability of pred centered at a0, under the assumption that {x1,x2,…} follows the multivariate distribution dist.
AsymptoticProbability[pred,vars,{a,a0,n}] computes the asymptotic probability to order n.
AsymptoticRSolveValue
AsymptoticRSolveValue[eqn,f,x->∞] computes an asymptotic approximation to the difference equation eqn for f[x] near ∞.
AsymptoticRSolveValue[{eqn1,eqn2,…},{f1,f2,…},x-> ∞] computes an asymptotic approximation to a system of difference equations.
AsymptoticRSolveValue[eqn,f,x,ϵ->ϵ0] computes an asymptotic approximation of f[x,ϵ] for the parameter ϵ centered at ϵ0.
AsymptoticRSolveValue[eqn,f,…,{ξ,ξ0,n}] computes the asymptotic approximation to order n.
AsymptoticSolve
AsymptoticSolve[eqn,y->b,x->a] computes asymptotic approximations of solutions y[x] of the equation eqn passing through {a,b}.
AsymptoticSolve[eqn,{y},x->a] computes asymptotic approximations of solutions y[x] of the equation eqn for x near a.
AsymptoticSolve[eqns,{y1,y2,…}->{b1,b2,…},{x1,x2,…}->{a1,a2,…}] computes asymptotic approximations of solutions {y1[x1,x2,…],y2[x1,x2,…],…} of the system of equations eqns.
AsymptoticSolve[eqns,…,{{x1,x2,…},{a1,a2,…},n}] computes the asymptotic approximation to order n.
AsymptoticSolve[…,Reals] computes only solutions that are real valued for real argument values.
Asynchronous
Asynchronous is an option for WolframAlpha that determines whether to use the asynchronous features of the Wolfram|Alpha API.
AsynchronousTaskObject
AsynchronousTaskObject["name",id,sessionid] is an object that represents asynchronous evaluations from a particular asynchronous task.
AsynchronousTasks
AsynchronousTasks[] returns a list of running asynchronous tasks.
Atom
Atom["sym"] represents an atom with atomic symbol "sym".
Atom["sym",name->value,…] represents an atom with atomic symbol "sym" and specified properties.
AtomCoordinates
AtomCoordinates is an option for Molecule and related functions that specifies the three-dimensional coordinates of the atoms.
AtomDiagramCoordinates
AtomDiagramCoordinates is an option for Molecule and related functions that specifies the two-dimensional coordinates of the atoms.
AtomLabels
AtomLabels is an option for MoleculePlot and MoleculePlot3D that specifies what labels and label positions should be used for atoms.
AtomLabelStyle
AtomLabelStyle is an option for MoleculePlot and MoleculePlot3D that specifies the style to use for atom labels.
AtomQ
AtomQ[expr] yields True if expr is an expression which cannot be divided into subexpressions, and yields False otherwise.
AttentionLayer
AttentionLayer[] represents a trainable net layer that learns to pay attention to certain portions of its input.
AttentionLayer[net] specifies a particular net to give scores for portions of the input.
AttentionLayer[net,opts] includes options for weight normalization, masking and other parameters.
Attributes
Attributes[symbol] gives the list of attributes for a symbol.
Attributes["symbol"] gives the attributes for the symbol named "symbol" if it exists.
Attributes[{s1,s2,…}] gives a list of the attributes for each of the si.
Audio
Audio[file] represents audio stored in the given file.
Audio[url] represents audio stored in the given URL.
Audio[data] represents audio with samples given by the array data.
AudioAmplify
AudioAmplify[audio,s] multiplies all samples of audio by a factor s.
AudioAmplify[video,s] amplifies the first audio track in video.
AudioAnnotate
AudioAnnotate[audio,prop] computes the property prop and adds it as an annotation to audio.
AudioAnnotate[audio,name->spec] adds an annotation with the specified name and values spec to audio.
AudioAnnotationLookup
AudioAnnotationLookup[audio] gives all annotations associated to audio.
AudioAnnotationLookup[audio,tags] gives the annotations specified by tags.
AudioAnnotationLookup[audio,tags->selector] gives a selection of annotations using selector.
AudioAnnotationLookup[audio,tags->selector,format] formats each annotation element according to format.
AudioBlockMap
AudioBlockMap[f,audio,dur] applies f to non-overlapping partitions of length dur in audio.
AudioBlockMap[f,audio,{dur,offset}] applies f to partitions with offset offset in audio.
AudioBlockMap[f,audio,{dur,offset,wfun}] applies f after applying wfun to partitions in audio.
AudioChannelAssignment
AudioChannelAssignment is an option for Audio and related functions that specifies a mapping from audio channels to available speakers of the output audio device.
AudioChannelCombine
AudioChannelCombine[{audio1,audio2,…}] creates a multichannel audio object by combining the sequence of channels in audioi.
AudioChannelMix
AudioChannelMix[audio] mixes channels of audio by averaging and returns a center-panned stereo audio object.
AudioChannelMix[audio,desttype] mixes audio channels into the specified desttype.
AudioChannelMix[video,…] mixes audio channels of video.
AudioChannels
AudioChannels[audio] returns the number of channels in the Audio object audio.
AudioChannels[video] returns the number of channels of the first audio track of video.
AudioChannelSeparate
AudioChannelSeparate[audio] gives a list of Audio objects, each of which represents one channel of audio.
AudioChannelSeparate[audio,channel] returns the specified channel from audio.
AudioData
AudioData[audio] gives an array of audio samples.
AudioData[audio,"type"] gives an array of audio samples converted to the specified "type".
AudioDelay
AudioDelay[audio,delay] creates audio by adding repeated decaying echos to audio spaced by the specified delay.
AudioDelay[audio,delay,feedback] uses the specified feedback as the amount of signal to preserve during each repetition.
AudioDelay[audio,delay,feedback,mix] uses mix to control the ratio between original and delayed audio.
AudioDelay[video,…] add delay to the first audio track in video.
AudioDelete
AudioDelete[audio,t] deletes the first t seconds of audio.
AudioDelete[audio,-t] deletes the last t seconds of audio.
AudioDelete[audio,{t1,t2}] deletes from time t1 to time t2, returning the remaining audio as a single Audio object.
AudioDelete[audio,{{t11,t12},…}] deletes multiple time intervals.
AudioDevice
AudioDevice is an option for Audio and related functions that specifies the device to use for playback.
AudioDistance
AudioDistance[audio1,audio2] returns a distance measure between audio1 and audio2.
AudioDistance[video1,video2] returns a distance measure between the audio tracks of video1 and video2.
AudioEncoding
AudioEncoding is an option for Export and other functions that specifies the audio encoding to use when creating an audio or a video file.
AudioFade
AudioFade[audio] returns audio in which the beginning and end of audio are faded.
AudioFade[audio,t] fades the first and last t seconds of audio.
AudioFade[audio,{t1,t2}] fades t1 seconds at the beginning and t2 seconds at the end.
AudioFade[video,…] fades the first audio track in video.
AudioFrequencyShift
AudioFrequencyShift[audio,freq] gives audio by shifting the spectrum of audio by freq.
AudioFrequencyShift[audio,freq,mix] uses mix to control the ratio between the original and shifted audio.
AudioFrequencyShift[video,…] shifts the spectrum of the first audio track in video.
AudioGenerator
AudioGenerator[model] generates one second of audio of a given model.
AudioGenerator[model,t] generates t seconds of audio.
AudioGenerator[model,t,"type"] generates audio samples of the specified "type".
AudioIdentify
AudioIdentify[audio] yields the result of attempting to identify what audio is a recording of.
AudioIdentify[audio,category] restricts the identification to the specified category.
AudioIdentify[audio,category,n] gives a list of up to n possible identifications.
AudioIdentify[audio,category,n,"prop"] gives the specified property for each identification.
AudioInputDevice
AudioInputDevice is an option for AudioCapture that specifies the device to use for audio recording.
AudioInsert
AudioInsert[audio,t->new] inserts the audio signal new at time t.
AudioInsert[audio,{t1,t2,…}->new] inserts the same audio at multiple positions.
AudioInsert[audio,{t1->new1,…}] inserts multiple audio signals at different positions.
AudioInstanceQ
AudioInstanceQ[audio,obj] gives True if audio sounds to be an instance of the object obj, and gives False otherwise.
AudioInstanceQ[audio,obj,cat] assumes that audio is the sound of something in the category cat.
AudioIntervals
AudioIntervals[audio] returns audible intervals of audio.
AudioIntervals[audio,crit] returns intervals of audio for which the criterion crit is satisfied.
AudioIntervals[audio,crit,mindur] returns only intervals larger than the given duration mindur.
AudioIntervals[video,…] returns only intervals from the first audio track in video.
AudioJoin
AudioJoin[audio1,audio2,…] or AudioJoin[{audio1,audio2,…}] concatenates all audioi and returns an audio object.
AudioJoin[{audio1,t1},{audio2,t2},…] inserts ti seconds of silence after each audioi.
AudioLabel
AudioLabel is an option for an Audio object that specifies the label to show on the object.
AudioLength
AudioLength[audio] returns the number of samples in the Audio object audio.
AudioLocalMeasurements
AudioLocalMeasurements[audio,"prop"] computes the property "prop" locally for partitions of audio.
AudioLocalMeasurements[audio,{prop1,prop2,…}] computes several properties "propi".
AudioLocalMeasurements[audio,"prop",format] returns the measurements in the specified output format.
AudioLocalMeasurements[video,…] computes the measurements from the first audio track in video.
AudioLooping
AudioLooping is an option for AudioStream and related functions to specify the playback looping.
AudioLoudness
AudioLoudness[audio] computes the loudness of audio according to the EBU momentary definition.
AudioLoudness[audio,def] computes the loudness according to the definition def.
AudioLoudness[video,…] computes the loudness of the first audio track in video.
AudioMeasurements
AudioMeasurements[audio,"prop"] computes the property "prop" for the entire audio.
AudioMeasurements[audio,{prop1,prop2,…}] computes several properties "propi".
AudioMeasurements[audio,"prop",format] returns the values in the specified output format.
AudioMeasurements[{audio1,audio2,…},…] returns measurements for all audioi.
AudioMeasurements[video,…] returns measurements for the first audio track in video.
AudioNormalize
AudioNormalize[audio] normalizes audio so that the maximum absolute value of its samples is 1.
AudioNormalize[audio,model] normalizes the audio signal based on the specified model.
AudioNormalize[video] normalizes the first audio track in video.
AudioOutputDevice
AudioOutputDevice is an option for Audio and related functions that specifies the device to use for playback.
AudioOverlay
AudioOverlay[{audio1,audio2,…}] returns an audio object by overlaying all audioi.
AudioPad
AudioPad[audio,t] adds t seconds of silence to the end of audio.
AudioPad[audio,{t1,t2}] adds t1 seconds of silence to the beginning and t2 seconds to the end of audio.
AudioPad[audio,tspec,padding] pads using the value or method specified by padding.
AudioPan
AudioPan[audio] returns a center-panned stereo audio object from a mono audio.
AudioPan[audio,pan] returns a stereo audio object after panning left and right channels using the specified pan.
AudioPan[video,…] pans the first audio track in video.
AudioPartition
AudioPartition[audio,dur] partitions an audio object into non-overlapping segments of duration dur.
AudioPartition[audio,dur,offset] generates segments with specified offset.
AudioPause
AudioPause[] pauses the playback of all AudioStream objects.
AudioPause[astream] pauses the playback of the AudioStream object astream.
AudioPause[audio] pauses the playback for all streams originated by audio.
AudioPitchShift
AudioPitchShift[audio,r] applies pitch shifting to audio by the ratio r, shifting every frequency f to r f.
AudioPitchShift[video,r] applies pitch shifting to the first audio track in video.
AudioPlay
AudioPlay[audio] returns a new AudioStream object from audio and starts the playback.
AudioPlay[astream] starts playing an AudioStream object astream.
AudioPlot
AudioPlot[audio] plots the waveform of audio.
AudioPlot[{audio1,audio2,…}] plots waveforms of all audioi.
AudioPlot[video] plots the waveform of the first audio track in video.
AudioQ
AudioQ[audio] yields True if audio has the form of a valid Audio object, and False otherwise.
AudioRecord
AudioRecord[] returns a new AudioStream object and starts to record from the default input audio device.
AudioRecord[inputdev] records from the input audio device inputdev.
AudioRecord[astream] starts recording an AudioStream object astream that is connected to an input device.
AudioReplace
AudioReplace[audio,{t1,t2}->new] replaces the audio signal between t1 and t2 with the new signal new.
AudioReplace[audio,{{t11,t12},…}->new] replaces multiple intervals with the same audio new.
AudioReplace[audio,{{t11,t12}->new1,…}] replaces multiple intervals.
AudioReplace[audio,{t1,t2}->new,fitting] uses the specified fitting method.
AudioResample
AudioResample[audio,sr] resamples audio to have the sample rate of sr.
AudioResample[video,sr] resamples the first audio track in video to have the sample rate of sr.
AudioReverb
AudioReverb[audio] adds reverberation to audio.
AudioReverb[audio,model] adds reverberation following the room model.
AudioReverb[audio,model,mix] controls the mix ratio between original and reverberated audio.
AudioReverb[video,…] adds reverberation to the first audio track in video.
AudioReverse
AudioReverse[audio] reverses audio so that the signal is played backward.
AudioReverse[video] reverses the first audio track in video.
AudioSampleRate
AudioSampleRate[audio] returns the sample rate of the Audio object audio.
AudioSampleRate[video] returns the sample rate of the first audio track of video.
AudioSpectralMap
AudioSpectralMap[f,audio] transforms audio by applying the function f to its short-time Fourier transform.
AudioSpectralMap[f,{audio1,…}] applies the function f to the list of short-time Fourier transforms of all audioi.
AudioSpectralMap[f,video] transforms the first audio track in video.
AudioSpectralTransformation
AudioSpectralTransformation[f,audio] returns a modified version of audio by applying a time-frequency transformation f to its short-time Fourier transform.
AudioSpectralTransformation[f,video] transforms the first audio track in video.
AudioSplit
AudioSplit[audio,t] splits audio at time t.
AudioSplit[audio,{t1,t2,…}] splits audio at times ti.
AudioStop
AudioStop[] stops the playback of all AudioStream objects.
AudioStop[astream] stops the playback of the AudioStream object astream.
AudioStop[audio] stops the playback for all streams originated by audio.
AudioStream
AudioStream[source] creates a new AudioStream object from source.
AudioStream[id] is an object that represents a unique audio stream.
AudioStreams
AudioStreams[] returns all existing streams.
AudioStreams[audio] returns all existing streams that originated from audio.
AudioStreams[audio,"prop"] returns "prop" for all streams that originated from audio.
AudioTimeStretch
AudioTimeStretch[audio,r] applies time stretching to audio by the specified factor r.
AudioTimeStretch[video,r] applies time stretching to the first audio track in video.
AudioTrackApply
AudioTrackApply[f,video] applies the function f to the first audio track of the Video object video.
AudioTrackSelection
AudioTrackSelection is an option that specifies the audio tracks of interest.
AudioTrim
AudioTrim[audio] trims silence from the beginning and end of audio.
AudioTrim[audio,t] returns the first t seconds of audio.
AudioTrim[audio,-t] returns the last t seconds of audio.
AudioTrim[audio,{t1,t2}] returns audio starting at time t1 and ending at time t2 of audio.
AudioTrim[audio,{{t11,t12},…}] returns a list of audio for all given intervals {ti1,ti2}.
AudioType
AudioType[audio] returns the data type used to represent samples in the Audio object audio.
AugmentedPolyhedron
AugmentedPolyhedron[poly] gives the augmented polyhedron poly by replacing each face by a pyramid.
AugmentedPolyhedron[poly,h] gives the augmented polyhedron with a pyramid of height h.
AugmentedSymmetricPolynomial
AugmentedSymmetricPolynomial[{r1,r2,…}] represents a formal augmented symmetric polynomial with exponents r1, r2, ….
AugmentedSymmetricPolynomial[{{r11,…,r1n},{r21,…,r2n},…}] represents a multivariate formal augmented symmetric polynomial with exponent vectors {r11, …, r1n}, {r21, …, r2n}, ….
AugmentedSymmetricPolynomial[rspec,data] gives the augmented symmetric polynomial in data.
Autocomplete
Autocomplete[{string1,string2,…},"string"] gives a list of the stringi that can complete string.
Autocomplete[<|s1->w1,s2->w2,…|>,"string"] puts the completions in order of decreasing weights wi.
Autocomplete[{assoc1,assoc2,…},"string"] uses completions specified by the associations associ.
Autocomplete[comps,"string",n] gives the first at most n completions.
Autocomplete[comps] gives an AutocompletionFunction[…] that can be applied to a string.
AutocompletionFunction
AutocompletionFunction[…] represents a function to be applied to a string to generate possible completions.
AutocorrelationTest
AutocorrelationTest[data] tests whether the data is autocorrelated.
AutocorrelationTest[data,k] tests whether the data is autocorrelated up to lag k.
AutocorrelationTest[data,k,"property"] returns the value of "property" for a given model.
AutoIndent
AutoIndent is an option for Style and Cell that specifies what automatic indentation should be done at the beginning of a new line after an explicit return character has been entered.
AutoItalicWords
AutoItalicWords is an option for Cell that gives a list of words that should automatically be put in italics when they are entered.
AutoloadPath
AutoloadPath is a global option that specifies from which directories packages are automatically loaded when the Wolfram System is started.
Automatic
Automatic represents an option or other value that is to be chosen automatically by a built‐in function.
Axes
Axes is an option for graphics functions that specifies whether axes should be drawn.
AxesEdge
AxesEdge is an option for three-dimensional graphics functions that specifies on which edges of the bounding box axes should be drawn.
AxesLabel
AxesLabel is an option for graphics functions that specifies labels for axes.
AxesOrigin
AxesOrigin is an option for graphics functions that specifies where any axes drawn should cross.
AxesStyle
AxesStyle is an option for graphics functions that specifies how axes should be rendered.
AxiomaticTheory
AxiomaticTheory["theory"] gives an axiomatic representation of the specified axiomatic theory.
AxiomaticTheory[{"theory",<|op1->s1,op2->s2,…|>}] uses si to represent the operator opi in the theory.
AxiomaticTheory[theory,"property"] gives the specified property of an axiomatic theory.
Axis
Axis is a symbol that represents the axis for purposes of alignment and positioning.
AxisLabel
AxisLabel is an option for AxisObject that specifies a label for the axis.
AxisObject
AxisObject[path] is a Graphics primitive that represents an axis with a quantitative scale along the path path.
AxisObject[path,scale] uses the scale specified by scale.
AxisStyle
AxisStyle is an option for AxisObject that specifies how to style the path of an axis.
BabyMonsterGroupB
BabyMonsterGroupB[] represents the sporadic simple baby monster group B.
Back
Back is a symbol that represents the back of a graphic for purposes of placement and alignment.
Background
Background is an option that specifies what background color to use.
Backslash
Backslash[x,y,…] displays as x∖y∖….
Backward
Backward is a symbol that represents the backward direction for purposes of motion and animation.
Ball
Ball[p] represents the unit ball centered at the point p.
Ball[p,r] represents the ball of radius r centered at the point p.
Ball[{p1,p2,…},r] represents a collection of balls of radius r.
Band
Band[{i,j}] represents the sequence of positions on the diagonal band that starts with {i,j} in a sparse array.
Band[{imin,jmin,…},{imax,jmax,…}] represents the positions between {imin,jmin,…} and {imax,jmax,…}.
Band[{imin,jmin,…},{imax,jmax,…},{di,dj,…}] represents positions starting with {imin,jmin,…} and then moving with step {di,dj,…}.
BandpassFilter
BandpassFilter[data,{ω1,ω2}] applies a bandpass filter with cutoff frequencies ω1 and ω2 to an array of data.
BandpassFilter[data,{{ω,q}}] uses center frequency ω and quality factor q.
BandpassFilter[data,spec,n] uses a filter kernel of length n.
BandpassFilter[data,spec,n,wfun] applies a smoothing window wfun to the filter kernel.
BandstopFilter
BandstopFilter[data,{ω1,ω2}] applies a bandstop filter with cutoff frequencies ω1 and ω2 to an array of data.
BandstopFilter[data,{{ω,q}}] uses center frequency ω and quality factor q.
BandstopFilter[data,spec,n] uses a filter kernel of length n.
BandstopFilter[data,spec,n,wfun] applies a smoothing window wfun to the filter kernel.
BarabasiAlbertGraphDistribution
BarabasiAlbertGraphDistribution[n,k] represents a Barabasi–Albert graph distribution for n-vertex graphs where a new vertex with k edges is added at each step.
BarChart
BarChart[{y1,y2,…,yn}] makes a bar chart with bar lengths y1, y2, ….
BarChart[{…,wi[yi,…],…,wj[yj,…],…}] makes a bar chart with bar features defined by the symbolic wrappers wk.
BarChart[{data1,data2,…}] makes a bar chart from multiple datasets datai.
BarChart3D
BarChart3D[{y1,y2,…}] makes a 3D bar chart with bar lengths y1, y2, … .
BarChart3D[{…,wi[yi,…],…,wj[yj,…],…}] makes a 3D bar chart with bar features defined by the symbolic wrappers wk.
BarChart3D[{data1,data2,…}] makes a 3D bar chart from multiple datasets datai.
BarcodeImage
BarcodeImage["string"] generates a barcode image of "string" in the "QR" format.
BarcodeImage["string",format] generates a barcode image of "string" in the specified format.
BarcodeImage["string",format,size] attempts to generate a barcode image of the specified size.
BarcodeRecognize
BarcodeRecognize[image] recognizes a barcode in image and returns it as a string.
BarcodeRecognize[image,"prop"] returns the specified property of the barcode.
BarcodeRecognize[image,"prop",format] recognizes barcodes of the specified format only.
BarcodeRecognize[video,…] recognizes barcodes in frames of video.
BaringhausHenzeTest
BaringhausHenzeTest[data] tests whether data follows a MultinormalDistribution using the Baringhaus–Henze test.
BaringhausHenzeTest[data,MultinormalDistribution[μ,Σ]] tests whether data follows the distribution with mean vector μ and covariance matrix Σ.
BaringhausHenzeTest[data,"property"] returns the value of "property".
BarLegend
BarLegend[cf] generates a legend that identifies colors from the color function cf with an automatic range of values.
BarLegend[{cf,{min,max}}] generates a legend that identifies colors from the color function cf with the range of values between min and max.
BarLegend[cf,contours] generates a legend that identifies color ranges from the color function cf based on the set of contours contours.
BarlowProschanImportance
BarlowProschanImportance[rdist] gives the Barlow–Proschan importances for all components in the ReliabilityDistribution rdist.
BarlowProschanImportance[fdist] gives the Barlow–Proschan importances for all components in the FailureDistribution fdist.
BarnesG
BarnesG[z] gives the Barnes G-function G(z).
BarOrigin
BarOrigin is an option to BarChart and related functions that specifies the origin placement for bars.
BarSpacing
BarSpacing is an option to BarChart and related functions that controls the spacing between bars and groups of bars.
BartlettHannWindow
BartlettHannWindow[x] represents a Bartlett–Hann window function of x.
BartlettWindow
BartlettWindow[x] represents a Bartlett window function of x.
BaseDecode
BaseDecode["string"] decodes the Base64 data contained in a string and returns the result as a byte array.
BaseDecode["string","encoding"] decodes using the string using the specified encoding.
BaseEncode
BaseEncode[ba] encodes the byte array ba as a Base64 string.
BaseEncode[ba,"encoding"] encodes using the specified encoding.
BaseForm
BaseForm[expr,n] prints with the numbers in expr given in base n.
Baseline
Baseline is a symbol that represents the baseline for purposes of alignment and positioning.
BaselinePosition
BaselinePosition is an option that specifies where the baseline of an object is considered to be for purposes of alignment with surrounding text or other expressions.
BasicRecurrentLayer
BasicRecurrentLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors each of size n.
BasicRecurrentLayer[n,opts] includes options for initial weights and other parameters.
BatchNormalizationLayer
BatchNormalizationLayer[] represents a trainable net layer that normalizes its input data by learning the data mean and variance.
BatchSize
BatchSize is an option for NetTrain and related functions that specifies the size of a batch of examples to process together.
BatesDistribution
BatesDistribution[n] represents the distribution of a mean of n random variables uniformly distributed from 0 to 1.
BatesDistribution[n,{min,max}] represents the distribution of a mean of n random variables uniformly distributed from min to max.
BattleLemarieWavelet
BattleLemarieWavelet[] represents the Battle–Lemarié wavelet of order 3.
BattleLemarieWavelet[n] represents the Battle–Lemarié wavelet of order n evaluated on equally spaced interval {-10,10}.
BattleLemarieWavelet[n,lim] represents the Battle–Lemarié wavelet of order n evaluated on equally spaced interval {-lim,lim}.
BayesianMaximization
BayesianMaximization[f,{conf1,conf2,…}] gives an object representing the result of Bayesian maximization over the function f over the configurations confi.
BayesianMaximization[f,reg] maximizes over the region represented by the region specification reg.
BayesianMaximization[f,sampler] maximizes over configurations obtained by applying the function sampler.
BayesianMaximization[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from the confi.
BayesianMaximizationObject
BayesianMaximizationObject[…] represents the result of a Bayesian maximization process.
BayesianMinimization
BayesianMinimization[f,{conf1,conf2,…}] gives an object representing the result of Bayesian minimization of the function f over the configurations confi.
BayesianMinimization[f,reg] minimizes over the region represented by the region specification reg.
BayesianMinimization[f,sampler] minimizes over configurations obtained by applying the function sampler.
BayesianMinimization[f,{conf1,conf2,…}->nsampler] applies the function nsampler to successively generate configurations starting from the confi.
BayesianMinimizationObject
BayesianMinimizationObject[…] represents the result of a Bayesian minimization process.
Because
Because[x,y] displays as x∵y.
BeckmannDistribution
BeckmannDistribution[μ1,μ2,σ1,σ2] represents the Beckmann distribution with means μ1 and μ2 and standard deviations σ1 and σ2.
BeckmannDistribution[μ1,μ2,σ1,σ2,ρ] represents the Beckmann distribution with means μ1 and μ2, standard deviations σ1 and σ2, and correlation ρ.
Beep
Beep[] generates an audible beep when evaluated.
Beep["message"] beeps and populates the Why the Beep dialog with message.
Before
Before is a symbol that represents the region before an object for purposes of placement.
Begin
Begin["context`"] resets the current context.
BeginDialogPacket
BeginDialogPacket[integer] is a WSTP packet that indicates the start of the Dialog subsession referenced by integer.
BellB
BellB[n] gives the Bell number Bn.
BellB[n,x] gives the Bell polynomial Bn(x).
BellY
BellY[n,k,{x1,…,xn-k+1}] gives the partial Bell polynomial Yn,k(x1,…,xn-k+1).
BellY[n,k,m] gives the generalized partial Bell polynomial of a matrix m.
BellY[m] gives the generalized Bell polynomial of a matrix m.
Below
Below is a symbol that represents the region below an object for purposes of placement.
BenfordDistribution
BenfordDistribution[b] represents a Benford distribution with base parameter b.
BeniniDistribution
BeniniDistribution[α,β,σ] represents a Benini distribution with shape parameters α and β and scale parameter σ.
BenktanderGibratDistribution
BenktanderGibratDistribution[a,b] represents a Benktander distribution of type I with parameters a and b.
BenktanderWeibullDistribution
BenktanderWeibullDistribution[a,b] represents a Benktander distribution of type II with parameters a and b.
BernoulliB
BernoulliB[n] gives the Bernoulli number Bn.
BernoulliB[n,x] gives the Bernoulli polynomial Bn(x).
BernoulliDistribution
BernoulliDistribution[p] represents a Bernoulli distribution with probability parameter p.
BernoulliGraphDistribution
BernoulliGraphDistribution[n,p] represents a Bernoulli graph distribution for n-vertex graphs with edge probability p.
BernoulliProcess
BernoulliProcess[p] represents a Bernoulli process with event probability p.
BernsteinBasis
BernsteinBasis[d,n,x] represents the nth Bernstein basis function of degree d at x.
BesagL
BesagL[pdata,r] estimates Besag's L function L(r) for point data pdata at radius r.
BesagL[pproc,r] computes L(r) for the point process pproc.
BesagL[bdata,r] computes L(r) for binned data bdata.
BesagL[pspec] generates the function L that can be applied repeatedly to different radii r.
BesselFilterModel
BesselFilterModel[n] designs a lowpass Bessel filter of order n and cutoff frequency 1.
BesselFilterModel[{n,ωc}] uses the cutoff frequency ωc.
BesselFilterModel[{n,ωc},var] expresses the model in terms of the variable var.
BesselI
BesselI[n,z] gives the modified Bessel function of the first kind In(z).
BesselJ
BesselJ[n,z] gives the Bessel function of the first kind Jn(z).
BesselJZero
BesselJZero[n,k] represents the kth zero of the Bessel function Jn(x).
BesselJZero[n,k,x0] represents the kth zero greater than x0.
BesselK
BesselK[n,z] gives the modified Bessel function of the second kind Kn(z).
BesselY
BesselY[n,z] gives the Bessel function of the second kind Yn(z).
BesselYZero
BesselYZero[n,k] represents the kth zero of the Bessel function of the second kind Yn(x).
BesselYZero[n,k,x0] represents the kth zero greater than x0.
Beta
Beta[a,b] gives the Euler beta function Β(a,b).
Beta[z,a,b] gives the incomplete beta function Βz(a,b).
BetaBinomialDistribution
BetaBinomialDistribution[α,β,n] represents a beta binomial mixture distribution with beta distribution parameters α and β, and n binomial trials.
BetaDistribution
BetaDistribution[α,β] represents a continuous beta distribution with shape parameters α and β.
BetaNegativeBinomialDistribution
BetaNegativeBinomialDistribution[α,β,n] represents a beta negative binomial mixture distribution with beta distribution parameters α and β and n successful trials.
BetaPrimeDistribution
BetaPrimeDistribution[p,q] represents a beta prime distribution with shape parameters p and q.
BetaPrimeDistribution[p,q,β] represents a generalized beta prime distribution with scale parameter β.
BetaPrimeDistribution[p,q,α,β] represents a generalized beta distribution of the second kind with shape parameter α.
BetaRegularized
BetaRegularized[z,a,b] gives the regularized incomplete beta function Iz(a,b).
Between
Between[x,{min,max}] is equivalent to min≤x≤max.
Between[x,{{min1,max1},{min2,max2},…}] is equivalent to min1≤x≤max1||min2≤x≤max2||….
Between[range] is an operator form that yields Between[x,range] when applied to an expression x.
BetweennessCentrality
BetweennessCentrality[g] gives a list of betweenness centralities for the vertices in the graph g.
BetweennessCentrality[{v->w,…}] uses rules v->w to specify the graph g.
BeveledPolyhedron
BeveledPolyhedron[poly] gives the beveled polyhedron of poly, by beveling each edge.
BeveledPolyhedron[poly,l] bevels the polyhedron poly by a length ratio l at its edges.
BezierCurve
BezierCurve[{pt1,pt2,…}] is a graphics primitive that represents a Bézier curve with control points pti.
BezierFunction
BezierFunction[{pt1,pt2,…}] represents a Bézier function for a curve defined by the control points pti.
BezierFunction[array] represents a Bézier function for a surface or high-dimensional manifold.
BilateralFilter
BilateralFilter[data,σ,μ] applies a bilateral filter of spatial spread σ and pixel value spread μ to data.
BilateralLaplaceTransform
BilateralLaplaceTransform[expr,t,s] gives the bilateral Laplace transform of expr.
BilateralLaplaceTransform[expr,{t1,t2,…,tn},{s1,s2,…,sn}] gives the multidimensional bilateral Laplace transform of expr.
BilateralZTransform
BilateralZTransform[expr,n,z] gives the bilateral Z transform of expr.
BilateralZTransform[expr,{n1,…,nk},{z1,…,zk}] gives the multidimensional bilateral Z transform of expr.
Binarize
Binarize[image] creates a binary image from image by replacing all values above a globally determined threshold with 1 and others with 0.
Binarize[image,t] creates a binary image by replacing all values above t with 1 and others with 0.
Binarize[image,{t1,t2}] creates a binary image by replacing all values in the range t1 through t2 with 1 and others with 0.
Binarize[image,f] creates a binary image by replacing all channel value lists for which f[v] yields True with 1 and others with 0.
BinaryDeserialize
BinaryDeserialize[ByteArray[…]] recovers an expression from a binary representation generated by BinarySerialize.
BinaryDeserialize[ByteArray[…],h] wraps h around the expression produced before returning it.
BinaryDistance
BinaryDistance[u,v] gives the binary distance between vectors u and v, equal to 0 if they are identical and 1 otherwise.
BinaryFormat
BinaryFormat is an option for OpenRead and related functions that specifies that a stream should be opened in binary format, so that no textual interpretation of newlines or other data is done.
BinaryImageQ
BinaryImageQ[image] yields True if image has the form of a binary Image or Image3D object, and False otherwise.
BinaryRead
BinaryRead[stream] reads one byte of raw binary data from an input stream, and returns an integer from 0 to 255.
BinaryRead[stream,type] reads an object of the specified type.
BinaryRead[stream,{type1,type2,…}] reads a sequence of objects of the specified types.
BinaryReadList
BinaryReadList["file"] reads all remaining bytes from a file, and returns them as a list of integers from 0 to 255.
BinaryReadList["file",type] reads objects of the specified type from a file, until the end of the file is reached. The list of objects read is returned.
BinaryReadList["file",{type1,type2,…}] reads objects with a sequence of types, until the end of the file is reached.
BinaryReadList["file",types,n] reads only the first n objects of the specified types.
BinarySerialize
BinarySerialize[expr] gives a binary representation of any expression expr as a ByteArray object.
BinaryWrite
BinaryWrite[channel,b] writes a byte of data, specified as an integer from 0 to 255.
BinaryWrite[channel,{b1,b2,…}] writes a sequence of bytes.
BinaryWrite[channel,"string"] writes the raw sequence of characters in a string.
BinaryWrite[channel,ByteArray[…]] writes the contents of a ByteArray object.
BinaryWrite[channel,x,type] writes an object of the specified type.
BinaryWrite[channel,{x1,x2,…},type] writes a sequence of objects of the specified type.
BinaryWrite[channel,{x1,x2,…},{type1,type2,…}] writes a sequence of objects with a sequence of types.
BinCounts
BinCounts[data] counts the number of elements of data whose values lie in successive integer bins.
BinCounts[data,binspec] counts the number of elements of data whose values lie in successive bins specified by binspec.
BinLists
BinLists[data] gives lists of the elements of data whose values lie in successive integer bins.
BinLists[data,binspec] gives lists of the elements of data whose values lie in successive bins specified by binspec.
BinLists[data->inds,…] gives the lists of the labels inds specified by the binning of data.
BinnedVariogramList
BinnedVariogramList[{loc1->val1,loc2->val2,…}] computes a variogram using binned values.
BinnedVariogramList[{loc1,loc2,…}->{val1,val2,…}] generates the same result.
BinnedVariogramList[…,spec] allows binning spec to be specified as given in HistogramList.
Binomial
Binomial[n,m] gives the binomial coefficient (�).
BinomialDistribution
BinomialDistribution[n,p] represents a binomial distribution with n trials and success probability p.
BinomialPointProcess
BinomialPointProcess[n,reg] represents a binomial point process with n points in the region reg.
BinomialProcess
BinomialProcess[p] represents a binomial process with event probability p.
BioSequenceModify
BioSequenceModify[seq,"mod"] gives the result of applying the modification "mod" to the sequence seq.
BioSequenceModify[seq,{"mod",params}] specifies the parameters params for "mod".
BioSequenceModify[modspec] represents an operator form of BioSequenceModify that can be applied to a biomolecular sequence.
BipartiteGraphQ
BipartiteGraphQ[g] yields True if the graph g is a bipartite graph and False otherwise.
BiquadraticFilterModel
BiquadraticFilterModel[{ω,q}] creates a lowpass biquadratic filter using the characteristic frequency ω and the quality factor q.
BiquadraticFilterModel[{"type",spec}] creates a filter of a given {"type",spec}.
BiquadraticFilterModel[{"type",spec},var] expresses the model in terms of the variable var.
BirnbaumImportance
BirnbaumImportance[rdist,t] gives the Birnbaum importances for all components in the ReliabilityDistribution rdist at time t.
BirnbaumImportance[fdist,t] gives the Birnbaum importances for all components in the FailureDistribution fdist at time t.
BirnbaumSaundersDistribution
BirnbaumSaundersDistribution[α,λ] represents the Birnbaum–Saunders distribution with shape parameter α and scale parameter λ.
BitAnd
BitAnd[n1,n2,…] gives the bitwise AND of the integers ni.
BitClear
BitClear[n,k] sets to 0 the bit corresponding to the coefficient of 2k in the integer n.
BitGet
BitGet[n,k] gets the bit corresponding to the coefficient of 2k in the integer n.
BitLength
BitLength[n] gives the number of binary bits necessary to represent the integer n.
BitNot
BitNot[n] gives the bitwise NOT of the integer n.
BitOr
BitOr[n1,n2,…] gives the bitwise OR of the integers ni.
BitRate
BitRate is an option that specifies an approximate number of bits per second when creating video and audio files.
BitSet
BitSet[n,k] sets to 1 the bit corresponding to the coefficient of 2k in the integer n.
BitShiftLeft
BitShiftLeft[n,k] shifts the binary bits in the integer n to the left by k places, padding with zeros on the right.
BitShiftLeft[n] shifts one bit to the left.
BitShiftRight
BitShiftRight[n,k] shifts the binary bits in the integer n to the right by k places, dropping bits that are shifted past the unit's position on the right.
BitShiftRight[n] shifts one bit to the right.
BitXor
BitXor[n1,n2,…] gives the bitwise XOR of the integers ni.
BiweightLocation
BiweightLocation[list] gives the value of the biweight location estimator of the elements in list.
BiweightLocation[list,c] gives the value of the biweight location estimator with scaling parameter c.
BiweightMidvariance
BiweightMidvariance[list] gives the value of the biweight midvariance of the elements in list.
BiweightMidvariance[list,c] gives the value of the biweight midvariance with scaling parameter c.
Black
Black represents the color black in graphics or style specifications.
BlackmanHarrisWindow
BlackmanHarrisWindow[x] represents a Blackman–Harris window function of x.
BlackmanNuttallWindow
BlackmanNuttallWindow[x] represents a Blackman–Nuttall window function of x.
BlackmanWindow
BlackmanWindow[x] represents a Blackman window function of x.
Blank
_ or Blank[] is a pattern object that can stand for any Wolfram Language expression.
_h or Blank[h] can stand for any expression with head h.
BlankNullSequence
___ (three _ characters) or BlankNullSequence[] is a pattern object that can stand for any sequence of zero or more Wolfram Language expressions.
___h or BlankNullSequence[h] can stand for any sequence of expressions, all of which have head h.
BlankSequence
__ (two _ characters) or BlankSequence[] is a pattern object that can stand for any sequence of one or more Wolfram Language expressions.
__h or BlankSequence[h] can stand for any sequence of one or more expressions, all of which have head h.
Blend
Blend[{col1,col2},x] gives a color obtained by blending a fraction 1-x of color col1 and x of color col2.
Blend[{col1,col2,col3,…},x] linearly interpolates between colors coli as x varies from 0 to 1.
Blend[{{x1,col1},{x2,col2},…},x] interpolates to give coli when x=xi.
Blend[{col1,col2,…},{u1,u2,…}] blends all the coli, using fraction ui of color coli.
Blend[{image1,image2,…},…] blends pixel values of 2D or 3D images imagei.
Block
Block[{x,y,…},expr] specifies that expr is to be evaluated with local values for the symbols x, y, ….
Block[{x=x0,…},expr] defines initial local values for x, ….
BlockMap
BlockMap[f,list,n] applies f to non-overlapping sublists of length n in list.
BlockMap[f,list,n,d] applies f to sublists with offset d in list.
BlockMap[f,list,{n1,n2,…},…] applies f to blocks of size n1×n2×….
BlockRandom
BlockRandom[expr] evaluates expr with all pseudorandom generators localized, so that uses of SeedRandom, RandomInteger, and related functions within the evaluation of expr do not affect subsequent pseudorandom sequences.
BlomqvistBetaTest
BlomqvistBetaTest[v1,v2] tests whether the vectors v1 and v2 are independent.
BlomqvistBetaTest[m1,m2] tests whether the matrices m1 and m2 are independent.
BlomqvistBetaTest[…,"property"] returns the value of "property".
Blue
Blue represents the color blue in graphics or style specifications.
Blur
Blur[image] gives a blurred version of image.
Blur[image,r] gives a version of image blurred over pixel radius r.
BodePlot
BodePlot[lsys] generates a Bode plot of a linear time-invariant system lsys.
BodePlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.
BodePlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.
BohmanWindow
BohmanWindow[x] represents a Bohman window function of x.
Bold
Bold represents a bold font weight.
Bond
Bond[{idi,idj},type] represents a chemical bond between atoms with indices idi and idj of the specified type.
BondLabels
BondLabels is an option for MoleculePlot and MoleculePlot3D that specifies what labels and label positions should be used for bonds.
BondLabelStyle
BondLabelStyle is an option for MoleculePlot and MoleculePlot3D that specifies the style to use for bond labels.
Bookmarks
Bookmarks is an option for Manipulate and related functions that gives a list of bookmark settings.
Boole
Boole[expr] yields 1 if expr is True and 0 if it is False.
BooleanConvert
BooleanConvert[expr] converts the Boolean expression expr to disjunctive normal form.
BooleanConvert[expr,form] converts the Boolean expression expr to the specified form.
BooleanConvert[expr,form,cond] finds an expression in the specified form that is equivalent to expr when cond is true.
BooleanCountingFunction
BooleanCountingFunction[kmax,n] represents a Boolean function of n variables that gives True if at most kmax variables are True.
BooleanCountingFunction[{k},n] represents a function of n variables that gives True if exactly k variables are True.
BooleanCountingFunction[{kmin,kmax},n] represents a function that gives True if between kmin and kmax variables are True.
BooleanCountingFunction[{{k1,k2,…}},n] represents a function that gives True if exactly ki variables are True.
BooleanCountingFunction[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the Boolean counting function specified by spec.
BooleanCountingFunction[spec,{a1,a2,…},form] gives the Boolean expression in the form specified by form.
BooleanFunction
BooleanFunction[k,n] represents the kth Boolean function in n variables.
BooleanFunction[values] represents the Boolean function corresponding to the specified vector of truth values.
BooleanFunction[{{i11,i12,…}->o1,…}] represents the Boolean function defined by the specified mapping from inputs to outputs.
BooleanFunction[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the Boolean function specified by spec.
BooleanFunction[spec,{a1,a2,…},form] gives the Boolean expression in the form specified by form.
BooleanGraph
BooleanGraph[bfunc,g1,…,gn] gives the Boolean graph defined by the Boolean function bfunc on the graphs g1, …, gn.
BooleanMaxterms
BooleanMaxterms[k,n] represents the kth maxterm in n variables.
BooleanMaxterms[{k1,k2,…},n] represents the conjunction of the maxterms ki.
BooleanMaxterms[{{u1,…,un},{v1,…},…}] represents the conjunction of maxterms given by the exponent vectors ui, vi, ….
BooleanMaxterms[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the maxterms function specified by spec.
BooleanMaxterms[spec,{a,a2,…},form] gives the Boolean expression in the form specified by form.
BooleanMinimize
BooleanMinimize[expr] finds a minimal-length disjunctive normal form representation of expr.
BooleanMinimize[expr,form] finds a minimal-length representation for expr in the specified form.
BooleanMinimize[expr,form,cond] finds a minimal-length expression in the specified form that is equivalent to expr when cond is true.
BooleanMinterms
BooleanMinterms[k,n] represents the kth minterm in n variables.
BooleanMinterms[{k1,k2,…},n] represents the disjunction of the minterms ki.
BooleanMinterms[{{u1,…,un},{v1,…},…}] represents the disjunction of minterms given by the exponent vectors ui, vi, ….
BooleanMinterms[spec,{a1,a2,…}] gives the Boolean expression in variables ai corresponding to the minterms function specified by spec.
BooleanMinterms[spec,{a,a2,…},form] gives the Boolean expression in the form specified by form.
BooleanQ
BooleanQ[expr] returns True if expr is either True or False.
BooleanRegion
BooleanRegion[bfunc,{reg1,reg2,…}] represents the Boolean combination bfunc of regions reg1, reg2, ….
Booleans
Booleans represents the domain of Booleans, as in x∈Booleans.
BooleanStrings
BooleanStrings is an option to TextString and related functions that determines what strings correspond to the Wolfram Language symbols True and False.
BooleanTable
BooleanTable[bf] gives a list of truth values for all possible combinations of variable values supplied to the Boolean function bf.
BooleanTable[expr,{a1,a2,…}] gives a list of the truth values of the Boolean expression expr for all possible combinations of values of the ai.
BooleanTable[expr,{a1,a2,…},{b1,…},…] gives a nested table of truth values of expr with the outermost level giving possible combinations of the ai.
BooleanVariables
BooleanVariables[expr] gives a list of the Boolean variables in the Boolean expression expr.
BooleanVariables[bf] gives the number of Boolean variables in the BooleanFunction object bf.
BorderDimensions
BorderDimensions[image] gives the pixel width of uniform borders of image in the form {{left,right},{bottom,top}}.
BorderDimensions[image,t] finds borders whose pixels vary by an amount less than t.
BorelTannerDistribution
BorelTannerDistribution[α,n] represents a Borel–Tanner distribution with shape parameters α and n.
Bottom
Bottom is a symbol that represents the bottom for purposes of alignment and positioning.
BottomHatTransform
BottomHatTransform[image,ker] gives the morphological bottom-hat transform of image with respect to structuring element ker.
BottomHatTransform[image,r] gives the bottom-hat transform with respect to a range-r square.
BottomHatTransform[data,…] applies a bottom-hat transform to an array of data.
BoundaryDiscretizeGraphics
BoundaryDiscretizeGraphics[g] discretizes a 2D or 3D graphic g into a BoundaryMeshRegion.
BoundaryDiscretizeGraphics[g,patt] discretizes only the elements in g that match the pattern patt.
BoundaryDiscretizeRegion
BoundaryDiscretizeRegion[reg] discretizes the region reg into a BoundaryMeshRegion.
BoundaryDiscretizeRegion[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.
BoundaryMesh
BoundaryMesh[mreg] gives a BoundaryMeshRegion from a MeshRegion mreg.
BoundaryMeshRegionQ
BoundaryMeshRegionQ[reg] yields True if the region reg is a valid BoundaryMeshRegion object and False otherwise.
BoundaryStyle
BoundaryStyle is an option for plotting functions that specifies the style in which boundaries of regions should be drawn.
BoundedRegionQ
BoundedRegionQ[reg] gives True if reg is a bounded region and False otherwise.
BracketingBar
BracketingBar[x, y, …] displays as x,y,….
BrayCurtisDistance
BrayCurtisDistance[u,v] gives the Bray–Curtis distance between vectors u and v.
BreadthFirstScan
BreadthFirstScan[g,s,{event1->f1,event2->f2,…}] performs a breadth-first scan (bfs) of the graph g starting at the vertex s and evaluates fi whenever "eventi" occurs.
BreadthFirstScan[g,{event1->f1,event2->f2,…}] performs a breadth-first scan of the whole graph g.
BreadthFirstScan[{v->w,…},…] uses rules v->w to specify the graph g.
Break
Break[] exits the nearest enclosing Do, For, Until or While.
BridgeData
BridgeData[entity,property] gives the value of the specified property for the bridge entity.
BridgeData[{entity1,entity2,…},property] gives a list of property values for the specified bridge entities.
BridgeData[entity,property,annotation] gives the specified annotation associated with the given property.
BrightnessEqualize
BrightnessEqualize[image] adjusts the brightness across image, correcting uneven illumination.
BrightnessEqualize[image,flatfield] uses the correction model given by flatfield, which models the variation in brightness across image.
BrightnessEqualize[image,flatfield,darkfield] uses the dark environment model given by darkfield.
BroadcastStationData
BroadcastStationData[entity,property] gives the value of the specified property for the broadcast station entity.
BroadcastStationData[{entity1,entity2,…},property] gives a list of property values for the specified broadcast station entities.
BroadcastStationData[entity,property,annotation] gives the specified annotation associated with the given property.
Brown
Brown represents the color brown in graphics or style specifications.
BrownianBridgeProcess
BrownianBridgeProcess[σ,{t1,a},{t2,b}] represents the Brownian bridge process from value a at time t1 to value b at time t2 with volatility σ.
BrownianBridgeProcess[{t1,a},{t2,b}] represents the standard Brownian bridge process from value a at time t1 to value b at time t2.
BrownianBridgeProcess[t1,t2] represents the standard Brownian bridge process pinned at 0 at times t1 and t2.
BrownianBridgeProcess[] represents the standard Brownian bridge process pinned at 0 at time 0 and at time 1.
BSplineCurve
BSplineCurve[{pt1,pt2,…}] is a graphics primitive that represents a nonuniform rational B-spline curve with control points pti.
BSplineFunction
BSplineFunction[{pt1,pt2,…}] represents a B-spline function for a curve defined by the control points pti.
BSplineFunction[array] represents a B-spline function for a surface or high-dimensional manifold.
BSplineSurface
BSplineSurface[array] is a graphics primitive that represents a nonuniform rational B-spline surface defined by an array of x,y,z control points.
BubbleChart
BubbleChart[{{x1,y1,z1},{x2,y2,z2},…}] makes a bubble chart with bubbles at positions {xi,yi} with sizes zi.
BubbleChart[{…,wi[{xi,yi,zi},…],…,wj[{xj,yj,zj},…],…}] makes a bubble chart with bubble features defined by the symbolic wrappers wk.
BubbleChart[{data1,data2,…}] makes a bubble chart from multiple datasets datai.
BubbleChart3D
BubbleChart3D[{{x1,y1,z1,u1},{x2,y2,z2,u2},…}] makes a 3D bubble chart with bubbles at positions {xi,yi,zi} with sizes ui.
BubbleChart3D[{…,wi[{xi,yi,zi,ui},…],…,wj[{xj,yj,zj,uj},…],…}] makes a 3D bubble chart with bubble features defined by the symbolic wrappers wk.
BubbleChart3D[{data1,data2,…}] makes a 3D bubble chart from multiple datasets datai.
BubbleScale
BubbleScale is an option to BubbleChart and related functions that specifies how the scale of each bubble should be determined from the value of each data element.
BubbleSizes
BubbleSizes is an option to BubbleChart and related functions that specifies the range of sizes used for bubbles.
BuildingData
BuildingData[entity,property] gives the value of the specified property for the building entity.
BuildingData[{entity1,entity2,…},property] gives a list of property values for the specified building entities.
BuildingData[entity,property,annotation] gives the specified annotation associated with the given property.
BulletGauge
BulletGauge[value,reference,{min,max}] draws a bullet gauge showing value and reference in a range of min to max.
BulletGauge[value,reference,{min,m1,m2,…,max}] draws a bullet gauge with performance regions split at the mi.
BulletGauge[{v1,v2,…},…] draws a bullet gauge with multiple values v1, v2, ….
BulletGauge[values,{r1,r2,…},…] draws a bullet gauge with multiple references r1, r2, ….
BusinessDayQ
BusinessDayQ[date] returns True if the date is a business day and returns False otherwise.
ButterflyGraph
ButterflyGraph[n] gives the order-n butterfly graph.
ButterflyGraph[n,b] gives the base-b order-n butterfly graph.
ButterworthFilterModel
ButterworthFilterModel[n] creates a lowpass Butterworth filter of order n and cutoff frequency of 1.
ButterworthFilterModel[{n,ωc}] uses the cutoff frequency ωc.
ButterworthFilterModel[{"type",spec}] creates a filter of a given "type" using the specified parameters spec.
ButterworthFilterModel[{"type",spec},var] expresses the model in terms of the variable var.
Byte
Byte represents a single byte of data in Read.
ByteArray
ByteArray[{b1,b2,…}] constructs a ByteArray object containing the byte values bi.
ByteArray["string"] constructs a ByteArray object by extracting byte values from a Base64-encoded string.
ByteArrayFormat
ByteArrayFormat[ba] attempts to determine what ImportByteArray format could be used to import the ByteArray object ba.
ByteArrayFormatQ
ByteArrayFormatQ[ba,"fmt"] gives True if the ByteArray object ba might be imported as format "fmt" and gives False otherwise.
ByteArrayFormatQ[ba,{fmt1,fmt2,…}] gives True if ba might be imported as one of "fmti".
ByteArrayQ
ByteArrayQ[expr] gives True if expr is a valid ByteArray object, and False otherwise.
ByteArrayToString
ByteArrayToString[ba] returns a string by decoding the data in the byte array ba, assuming UTF-8 encoding.
ByteArrayToString[ba,"encoding"] interprets the data in the specified character encoding.
ByteOrdering
ByteOrdering is an option for BinaryRead, BinaryWrite, and related functions that specifies what ordering of bytes should be assumed for your computer system.
CalendarConvert
CalendarConvert[date,calendar] converts the date object date to the specified calendar type calendar.
CalendarConvert[date] converts to the default calendar type.
CalendarConvert[{date1,…,daten},calendar] converts date1 through daten to the specified calendar.
CalendarData
CalendarData[cal] gives the default parameters associated with the date calendar cal.
CalendarData[country] gives available holiday calendars for the stock exchanges in the country entity.
CalendarData[cal,param] gives the value of the specified parameter param for calendar cal.
CalendarType
CalendarType is an option that determines the calendar system in which all dates are to be interpreted and output.
CallPacket
CallPacket[integer,list] is a WSTP packet encapsulating a request to invoke the external function numbered integer with the arguments contained in list.
CanberraDistance
CanberraDistance[u,v] gives the Canberra distance between vectors u and v.
Cancel
Cancel[expr] cancels out common factors in the numerator and denominator of expr.
CandlestickChart
CandlestickChart[{{date1,{open1,high1,low1,close1}},…}] makes a chart with candles representing open, high, low, and close prices for each date.
CandlestickChart[{"name",daterange}] makes a candlestick chart for the financial entity "name" over the date range daterange.
CanonicalGraph
CanonicalGraph[g] gives a canonical form of the graph g.
CanonicalGraph[{v->w,…}] uses rules v->w to specify the graph.
CanonicalizePolygon
CanonicalizePolygon[poly] gives a canonical representation of the polygon poly with shared coordinates and with inner and outer boundaries.
CanonicalizePolygon[poly,"filter"] gives a canonical representation of poly with the specified filter.
CanonicalizePolyhedron
CanonicalizePolyhedron[poly] gives a canonical representation of the polyhedron poly with shared coordinates and with inner and outer boundaries.
CanonicalizeRegion
CanonicalizeRegion[reg] gives a canonical representation of the region reg.
CanonicalName
CanonicalName[entity] gives the canonical name for the entity specified by entity.
CanonicalName[{entity1,…,entityn}] gives the canonical name for entity1 through entityn.
CanonicalWarpingCorrespondence
CanonicalWarpingCorrespondence[s1,s2] gives the canonical time warping (CTW) correspondence between sequences s1 and s2.
CanonicalWarpingCorrespondence[s1,s2,warp] uses warp as initial warping correspondence.
CanonicalWarpingCorrespondence[s1,s2,warp,win] uses a window win for local search.
CanonicalWarpingDistance
CanonicalWarpingDistance[s1,s2] gives the canonical time warping (CTW) distance between sequences s1 and s2.
CanonicalWarpingDistance[s1,s2,init] uses init as the initial correspondence between the two sequences.
CanonicalWarpingDistance[s1,s2,init,win] uses a window win for local search.
CantorMesh
CantorMesh[n] gives a mesh region representing the nth-step Cantor set.
CantorMesh[n,d] gives the nth-step Cantor set in dimension d.
CantorStaircase
CantorStaircase[x] gives the Cantor staircase function FC(x).
Cap
Cap[x,y,…] displays as x⌢y⌢….
CapForm
CapForm[type] is a graphics primitive that specifies what type of caps should be used at the ends of lines, tubes, and related primitives.
CapitalDifferentialD
CapitalDifferentialD[x] displays as x.
Capitalize
Capitalize[string] yields a string in which the first character has been made uppercase.
Capitalize[string,scheme] gives a string capitalized using the specified capitalization scheme.
CapsuleShape
CapsuleShape[{{x1,y1,z1},{x2,y2,z2}},r] represents the filled capsule between points {xi,yi,zi} and radius r.
CarlemanLinearize
CarlemanLinearize[sys,spec] Carleman linearizes the nonlinear state-space model sys according to spec.
CarlsonRC
CarlsonRC[x,y] gives the Carlson's elliptic integral RC(x,y).
CarlsonRD
CarlsonRD[x,y,z] gives the Carlson's elliptic integral RD(x,y,z).
CarlsonRE
CarlsonRE[x,y] gives the Carlson's elliptic integral RE(x,y).
CarlsonRF
CarlsonRF[x,y,z] gives the Carlson's elliptic integral RF(x,y,z).
CarlsonRG
CarlsonRG[x,y,z] gives the Carlson's elliptic integral RG(x,y,z).
CarlsonRJ
CarlsonRJ[x,y,z,ρ] gives Carlson's elliptic integral RJ(x,y,z,ρ).
CarlsonRK
CarlsonRK[x,y] gives the Carlson's elliptic integral RK(x,y).
CarlsonRM
CarlsonRM[x,y,ρ] gives Carlson's elliptic integral RM(x,y,ρ).
CarmichaelLambda
CarmichaelLambda[n] gives the Carmichael function λ(n).
CaseOrdering
CaseOrdering is an option for AlphabeticSort and related functions that specifies how upper versus lower case should be sorted.
Cases
Cases[{e1,e2,…},pattern] gives a list of the ei that match the pattern.
Cases[{e1,…},pattern->rhs] gives a list of the values of rhs corresponding to the ei that match the pattern.
Cases[expr,pattern,levelspec] gives a list of all parts of expr on levels specified by levelspec that match the pattern.
Cases[expr,pattern->rhs,levelspec] gives the values of rhs that match the pattern.
Cases[expr,pattern,levelspec,n] gives the first n parts in expr that match the pattern.
Cases[pattern] represents an operator form of Cases that can be applied to an expression.
CaseSensitive
CaseSensitive[patt] represents a string pattern that requires matching typographical case, even with the overall option setting IgnoreCase->True.
Cashflow
Cashflow[{c0,c1,…,cn}] represents a series of cash flows occurring at unit time intervals.
Cashflow[{c0,c1,…,cn},q] represents cash flows occurring at time intervals q.
Cashflow[{{time1,c1},{time2,c2},…}] represents cash flows occurring at the specified times.
Casoratian
Casoratian[{y1,y2,…},n] gives the Casoratian determinant for the sequences y1, y2, … depending on n.
Casoratian[eqn,y,n] gives the Casoratian determinant for the basis of the solutions of the linear difference equation eqn involving y[n+m].
Casoratian[eqns,{y1,y2,…},n] gives the Casoratian determinant for the system of linear difference equations eqns.
Catalan
Catalan is Catalan's constant, with numerical value ≃0.915966.
CatalanNumber
CatalanNumber[n] gives the nth Catalan number Cn.
Catch
Catch[expr] returns the argument of the first Throw generated in the evaluation of expr.
Catch[expr,form] returns value from the first Throw[value,tag] for which form matches tag.
Catch[expr,form,f] returns f[value,tag].
CategoricalDistribution
CategoricalDistribution[{c1,c2,…}] represents a uniform categorical distribution over classes c1, c2, etc.
CategoricalDistribution[{c1,c2,…},{w1,w2,…}] represents a categorical distribution over classes ci with weights wi.
CategoricalDistribution[{{a1,a2,…},{b1,b2,…},…}] represents a uniform multivariate categorical distribution over domain {a1,a2,…}×{b1,b2,…}×….
CategoricalDistribution[domain,weights] uses the array weights to define probabilities over each element of the domain.
Catenate
Catenate[{list1,list2,…}] yields a single list with all elements from the listi in order.
Catenate[{assoc1,assoc2,…}] yields a list of all values in order appearing in the associations associ.
CatenateLayer
CatenateLayer[] represents a net layer that takes a list of input arrays and catenates them.
CatenateLayer[n] represents a net layer that takes a list of input arrays and catenates them at level n.
CauchyDistribution
CauchyDistribution[a,b] represents a Cauchy distribution with location parameter a and scale parameter b.
CauchyDistribution[] represents a Cauchy distribution with location parameter 0 and scale parameter 1.
CauchyWindow
CauchyWindow[x] represents a Cauchy window function of x.
CauchyWindow[x,α] uses the parameter α.
CayleyGraph
CayleyGraph[group] returns a Cayley graph representation of group.
CDFWavelet
CDFWavelet[] represents a Cohen–Daubechies–Feauveau wavelet of type "9/7".
CDFWavelet["type"] represents a Cohen–Daubechies–Feauveau wavelet of type "type".
Ceiling
Ceiling[x] gives the smallest integer greater than or equal to x.
Ceiling[x,a] gives the smallest multiple of a greater than or equal to x.
CensoredDistribution
CensoredDistribution[{xmin,xmax},dist] represents the distribution of values that come from dist and are censored to be between xmin and xmax.
CensoredDistribution[{{xmin,xmax},{ymin,ymax},…},dist] represents the distribution of values that come from the multivariate distribution dist and are censored to be between xmin and xmax, ymin and ymax, etc.
Censoring
Censoring[t,c] represents a censored event time t with censoring c.
Censoring[{t1,t2,…},c] represents a vector of censored event times ti with censoring c.
Censoring[{t1,t2,…},{c1,c2,…}] represents a vector of event times ti with corresponding censoring ci.
Center
Center is a symbol that represents the center for purposes of alignment and positioning.
CenterArray
CenterArray[a,n] creates a list of length n with the elements of a at the center and zeros elsewhere.
CenterArray[a,{n1,n2,…}] creates an n1×n2×… array with the array a at the center and zeros elsewhere.
CenterArray[a,nspec,pad] uses pad instead of zero for the background.
CenterArray[nspec] creates an array with a single 1 at the center and zeros elsewhere.
CenterDot
CenterDot[x,y,…] displays as x·y·….
CenteredInterval
CenteredInterval[x,dx] for real numbers x and dx gives a centered interval that contains the real interval {a∈|x-dx≤a≤x+dx}.
CenteredInterval[x+ y,dx+ dy] gives a centered interval that contains the complex rectangle {a+ b∈|x-dx≤a≤x+dx∧y-dy≤b≤y+dy}.
CenteredInterval[c] for an approximate number c gives a centered interval that contains all values within the error bounds of c.
CentralFeature
CentralFeature[{x1,x2,…}] gives the central feature of the elements xi.
CentralFeature[{x1->v1,x2->v2,…}] gives the vi corresponding to the central feature xi.
CentralFeature[data] gives the central feature for several different forms of data.
CentralMoment
CentralMoment[data,r] gives the order r central moment μ&~r of data.
CentralMoment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate central moment μ&~r1, …, rm of data.
CentralMoment[dist,…] gives the central moment of the distribution dist.
CentralMoment[r] represents the order r formal central moment.
CentralMomentGeneratingFunction
CentralMomentGeneratingFunction[dist,t] gives the central moment-generating function for the distribution dist as a function of the variable t.
CentralMomentGeneratingFunction[dist,{t1,t2,…}] gives the central moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, ….
Cepstrogram
Cepstrogram[data] plots the array of power cepstra computed on each partition of data.
Cepstrogram[data,n] uses partitions of length n.
Cepstrogram[data,n,d] uses partitions with offset d.
Cepstrogram[data,n,d,wfun] applies a smoothing window wfun to each partition.
Cepstrogram[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
CepstrogramArray
CepstrogramArray[data] computes an array of cepstra on data.
CepstrogramArray[data,n] uses partitions of length n.
CepstrogramArray[data,n,d] uses partitions with offset d.
CepstrogramArray[data,n,d,wfun] applies a smoothing window wfun to each partition.
CepstrogramArray[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
CepstrumArray
CepstrumArray[data] computes the power cepstrum of data.
CepstrumArray[data,type] computes the specified type of cepstrum of data.
CForm
CForm[expr] prints as a C language version of expr.
ChampernowneNumber
ChampernowneNumber[b] gives the base-b Champernowne number Cb.
ChampernowneNumber[] gives the base-10 Champernowne number.
ChannelBase
ChannelBase is an option specifying the base URL of the server to use for brokering channel communications.
ChannelBrokerAction
ChannelBrokerAction is an option specifying the action to execute on the channel broker server in addition to routing a message.
ChannelHistoryLength
ChannelHistoryLength is an option to ChannelListen that specifies the maximum number of messages to cache in the channel listener object.
ChannelListen
ChannelListen[channel] starts listening on the specified channel.
ChannelListen[channel,func] applies func to the association corresponding to each message received on the channel.
ChannelListen[channel,None] stores each message received on the channel, without applying any function.
ChannelListen[url] listens on the specified URL, storing messages received, without requiring an explicit channel to exist on the channel broker.
ChannelListener
ChannelListener[…] represents a channel listener created by ChannelListen.
ChannelListeners
ChannelListeners[] gives a list of currently active channel listeners.
ChannelObject
ChannelObject[] gives a new anonymous channel specification.
� represents a channel specified by a given URL.
ChannelObject["relpath"] represents a channel for the currently authenticated user at a relative path.
ChannelObject["id:�] represents a channel for the user with the specified Wolfram ID at the given path.
ChannelObject["/�] represents a channel at an absolute path on the channel broker.
ChannelReceiverFunction
ChannelReceiverFunction[fun] represents a channel receiver function that applies fun to any channel message it receives.
ChannelSend
ChannelSend[channel,msg] sends the specified message msg to the specified channel.
ChannelSubscribers
ChannelSubscribers[channel] gives a list of users currently subscribed to the specified channel.
ChannelSubscribers[{channel1,channel2,…}] gives a list of subscribed users for each of the channels channeli.
ChanVeseBinarize
ChanVeseBinarize[image] finds a two-level segmentation of image by computing optimal contours around regions of consistent intensity in image.
ChanVeseBinarize[image,marker] uses marker to create an initial contour.
ChanVeseBinarize[image,marker,{μ,ν,λ1,λ2}] specify the Chan–Vese weights μ, ν, λ1, and λ2.
Character
Character represents a single character in Read.
CharacterCounts
CharacterCounts["string"] gives an association whose keys are the distinct characters in string, and whose values give the number of times those characters appear in string.
CharacterCounts["string",n] gives counts of the distinct n-grams consisting of runs of n characters in string.
CharacterCounts[{string1,string2,…},…] gives the counts for each of the stringi.
CharacterEncoding
CharacterEncoding is an option for input and output functions which specifies what raw character encoding should be used.
CharacterEncodingsPath
CharacterEncodingsPath is a global option that specifies which directories are searched for character encoding files.
CharacteristicFunction
CharacteristicFunction[dist,t] gives the characteristic function for the distribution dist as a function of the variable t.
CharacteristicFunction[dist,{t1,t2,…}] gives the characteristic function for the multivariate distribution dist as a function of the variables t1, t2, ….
CharacteristicPolynomial
CharacteristicPolynomial[m,x] gives the characteristic polynomial for the matrix m.
CharacteristicPolynomial[{m,a},x] gives the generalized characteristic polynomial with respect to a.
CharacterName
CharacterName["c"] gives the name of the character c.
CharacterName[n] gives the name of the character with character code n.
CharacterName[c,"type"] gives a name of the specified type.
CharacterNormalize
CharacterNormalize["text",form] converts the characters in text to the specified normalization form.
CharacterRange
CharacterRange[c1,c2] yields a list of the characters in the range from "c1" to "c2".
CharacterRange[n1,n2] yields a list of the characters with character codes in the range n1 to n2.
Characters
Characters["string"] gives a list of the characters in a string.
ChartBaseStyle
ChartBaseStyle is an option for charting functions that specifies the base style for all chart elements.
ChartElementFunction
ChartElementFunction is an option for charting functions such as BarChart that gives a function to use to generate the primitives for rendering each chart element.
ChartElements
ChartElements is an option to charting functions such as BarChart that specifies the graphics to use as the basis for bars or other chart elements.
ChartLabels
ChartLabels is an option for charting functions that specifies what labels should be used for chart elements.
ChartLayout
ChartLayout is an option to charting functions that specifies the overall layout to use.
ChartLegends
ChartLegends is an option for charting functions that specifies what legends should be used for chart elements.
ChartStyle
ChartStyle is an option for charting functions that specifies styles in which chart elements should be drawn.
Chebyshev1FilterModel
Chebyshev1FilterModel[n] creates a lowpass Chebyshev type 1 filter of order n.
Chebyshev1FilterModel[{n,ωc}] uses the cutoff frequency ωc.
Chebyshev1FilterModel[{"type",spec}] creates a filter of a given "type" using the specified parameters spec.
Chebyshev1FilterModel[{"type",spec},var] expresses the model in terms of the variable var.
Chebyshev2FilterModel
Chebyshev2FilterModel[n] creates a lowpass Chebyshev type 2 filter of order n.
Chebyshev2FilterModel[{n,ωc}] uses the cutoff frequency ωc.
Chebyshev2FilterModel[{"type",spec}] uses the full filter specification {"type",spec}.
Chebyshev2FilterModel[{"type",spec},var] expresses the model in terms of the variable var.
ChebyshevDistance
ChebyshevDistance[u,v] gives the Chebyshev or sup norm distance between vectors u and v.
ChebyshevT
ChebyshevT[n,x] gives the Chebyshev polynomial of the first kind Tn(x).
ChebyshevU
ChebyshevU[n,x] gives the Chebyshev polynomial of the second kind Un(x).
Check
Check[expr,failexpr] evaluates expr, and returns the result, unless messages were generated, in which case it evaluates and returns failexpr.
Check[expr,failexpr,{s1::t1,s2::t2,…}] checks only for the specified messages.
Check[expr,failexpr,"name"] checks only for messages in the named message group.
CheckAbort
CheckAbort[expr,failexpr] evaluates expr, returning failexpr if an abort occurs.
CheckAll
CheckAll[expr,f] evaluates expr and returns f[expr,HoldComplete[control1,…]] where the controli expressions are aborts, throws, or other flow control commands currently being executed (but stopped by CheckAll).
CheckArguments
CheckArguments[f[args],n] gives True if args consists of exactly n positional arguments followed by valid options for f, and False otherwise.
CheckArguments[f[args],{min,max}] requires the number of positional arguments to be between min and max.
CheckArguments[f[args],spec,assoc] modifies the behavior based on the information in the association assoc.
ChemicalData
ChemicalData["name","property"] gives the value of the specified property for the chemical "name".
ChemicalData["name"] gives a structure diagram for the chemical with the specified name.
ChemicalData["class"] gives a list of available chemicals in the specified class.
ChemicalFormula
ChemicalFormula[<|elem1->n1,elem2->n2,…|>] represents a chemical species with ni atoms of the element elemi.
ChemicalFormula[chem] returns the chemical formula corresponding to the given input.
ChemicalFormula[…,<|qual1->val1,qual2->val2 …|>] represents a species whose qualifiers quali have values vali.
ChemicalReaction
ChemicalReaction[reactants->products] represents a chemical reaction between the given reactants and products.
ChessboardDistance
ChessboardDistance[u,v] gives the chessboard, Chebyshev, or sup norm distance between vectors u and v.
ChiDistribution
ChiDistribution[ν] represents a χ distribution with ν degrees of freedom.
ChineseRemainder
ChineseRemainder[{r1,r2,…},{m1,m2,…}] gives the smallest x with x≥0 that satisfies all the integer congruences x mod mirimod mi.
ChineseRemainder[{r1,r2,…},{m1,m2,…},d] gives the smallest x with x≥d that satisfies all the integer congruences x mod mirimod mi.
ChiSquareDistribution
ChiSquareDistribution[ν] represents a χ2 distribution with ν degrees of freedom.
CholeskyDecomposition
CholeskyDecomposition[m] gives the Cholesky decomposition of a matrix m.
Chop
Chop[expr] replaces approximate real numbers in expr that are close to zero by the exact integer 0.
Chop[expr,delta] replaces numbers smaller in absolute magnitude than delta by 0.
ChromaticityPlot
ChromaticityPlot[colspace] plots a 2D slice of the color space colspace.
ChromaticityPlot[color] plots the specific color.
ChromaticityPlot[{col1,col2,…}] plots multiple colors and color spaces.
ChromaticityPlot[image] plots the pixels of image as individual colors.
ChromaticityPlot[…,refcolspace] uses the reference color space refcolspace.
ChromaticityPlot3D
ChromaticityPlot3D[colspace] returns a 3D gamut of the color space colspace.
ChromaticityPlot3D[color] plots the specific color.
ChromaticityPlot3D[image] plots the pixels of image as individual colors.
ChromaticityPlot3D[{input1,input2,…}] plots multiple colors, color spaces and images.
ChromaticityPlot3D[…,refcolspace] uses the reference color space refcolspace.
ChromaticPolynomial
ChromaticPolynomial[g,k] gives the chromatic polynomial of the graph g.
ChromaticPolynomial[{v->w,…},…] uses rules v->w to specify the graph g.
Circle
Circle[{x,y},r] represents a circle of radius r centered at {x,y}.
Circle[{x,y}] gives a circle of radius 1.
Circle[{x,y},{rx,ry}] gives an axis-aligned ellipse with semiaxes lengths rx and ry.
Circle[{x,y},…,{θ1,θ2}] gives a circular or ellipse arc from angle θ1 to θ2.
CircleDot
CircleDot[x,y,…] displays as x⊙y⊙….
CircleMinus
CircleMinus[x,y] displays as x⊖y.
CirclePlus
CirclePlus[x,y,…] displays as x⊕y⊕….
CirclePoints
CirclePoints[n] gives the positions of n points equally spaced around the unit circle.
CirclePoints[r,n] gives the positions of n points equally spaced around a circle of radius r.
CirclePoints[{r,θ1},n] starts at angle θ1 with respect to the x axis.
CirclePoints[{x,y},rspec,n] centers the circle at {x,y}.
CircleThrough
CircleThrough[{p1,p2,…}] represents a circle passing through the points pi.
CircleThrough[{p1,p2,…},q] represents a circle with center q.
CircleThrough[{p1,p2,…},q,r] represents a circle with radius r.
CircleTimes
CircleTimes[x] displays as ⊗x.
CircleTimes[x,y,…] displays as x⊗y⊗….
CirculantGraph
CirculantGraph[n,j] gives the circulant graph Cn(j) with n vertices and jump j.
CirculantGraph[n,{j1,j2,…}] gives the circulant graph Cn(j1,j2,…) with n vertices and jumps j1, j2, ….
CircularOrthogonalMatrixDistribution
CircularOrthogonalMatrixDistribution[n] represents a circular orthogonal matrix distribution with matrix dimensions {n,n}.
CircularQuaternionMatrixDistribution
CircularQuaternionMatrixDistribution[n] represents a circular quaternion matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers.
CircularRealMatrixDistribution
CircularRealMatrixDistribution[n] represents a circular real matrix distribution with matrix dimensions {n,n}.
CircularSymplecticMatrixDistribution
CircularSymplecticMatrixDistribution[n] represents a circular symplectic matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers.
CircularUnitaryMatrixDistribution
CircularUnitaryMatrixDistribution[n] represents a circular unitary matrix distribution with matrix dimensions {n,n}.
Circumsphere
Circumsphere[{p1,…,pn+1}] gives the sphere that circumscribes the points pi in n.
Circumsphere[poly] gives the circumsphere of a polyhedron or polygon poly.
CityData
CityData[name,"property"] gives the value of the specified property for the city with the specified name.
CityData[name] gives a list of the full specifications of cities whose names are consistent with name.
ClassifierFunction
ClassifierFunction[…] represents a function generated by Classify that classifies data into classes.
ClassifierInformation
ClassifierInformation[classifier] generates a report giving information on the classifier function classifier.
ClassifierInformation[classifier,prop] gives information for classifier associated with property prop.
ClassifierMeasurements
ClassifierMeasurements[classifier,testset,prop] gives measurements associated with property prop when classifier is evaluated on testset.
ClassifierMeasurements[classifier,testset] yields a measurement report that can be applied to any property.
ClassifierMeasurements[data,…] uses classifications data instead of a classifier.
ClassifierMeasurements[…,{prop1,prop2,…}] gives properties prop1, prop2, etc.
ClassifierMeasurementsObject
ClassifierMeasurementsObject[…] represents an object generated by ClassifierMeasurements that can be applied to properties.
Classify
Classify[{in1->class1,in2->class2,…}] generates a ClassifierFunction that attempts to predict classi from the example ini.
Classify[data,input] attempts to predict the output associated with input from the training examples given.
Classify[data,input,prop] computes the specified property prop relative to the prediction.
ClassPriors
ClassPriors is an option for Classify and related functions that specifies explicit prior probabilities to assume for output classes, independent of anything deduced from the training set.
Clear
Clear[s1,s2,…] clears values and definitions for the symbols si.
Clear[patt1,patt2,…] clears values and definitions for all symbols whose names textually match any of the arbitrary string patterns patti.
Clear[{spec1,spec2,…}] clears values and definitions for any symbols that are equal to or whose names match any of the speci.
ClearAll
ClearAll[s1,s2,…] clears all values, definitions, attributes, defaults, options and messages for the symbols si.
ClearAll[patt1,patt2,…] clears all symbols whose names textually match any of the arbitrary string patterns patti.
ClearAll[{spec1,spec,…}] clears any symbols that are equal to or whose names match any of the speci.
ClearAttributes
ClearAttributes[symbol,attr] removes attr from the list of attributes of the symbol symbol.
ClearAttributes["symbol",attr] removes attr from the attributes of the symbol named "symbol" if it exists.
ClearAttributes[s,{attr1,attr2,…}] removes several attributes at a time.
ClearAttributes[{s1,s2,…},attrs] removes attributes from several symbols at a time.
ClearCookies
ClearCookies[domain] clears all persistent and session cookies associated with the specified domain.
ClearCookies[assoc] clears all cookies whose attributes match the specification in the association assoc.
ClearCookies[All] clears all persistent and session cookies for all domains.
ClebschGordan
ClebschGordan[{j1,m1},{j2,m2},{j,m}] gives the Clebsch–Gordan coefficient for the decomposition of j,m〉 in terms of j1,m1〉j2,m2〉.
ClickPane
ClickPane[image,func] represents a clickable pane that displays as image and applies func to the x,y coordinates of each click within the pane.
ClickPane[image,{{xmin,ymin},{xmax,ymax}},func] specifies the range of coordinates to use.
ClickToCopy
ClickToCopy[expr] represents a button that copies expr whenever it is clicked.
ClickToCopy[label,expr] displays with label on the button.
ClickToCopyEnabled
ClickToCopyEnabled is an option for Cell that specifies whether to show a click-to-copy overlay when hovering over a cell.
Clip
Clip[x] gives x clipped to be between -1 and +1.
Clip[x,{min,max}] gives x for min≤x≤max, min for x<min and max for x>max.
Clip[x,{min,max},{vmin,vmax}] gives vmin for x<min and vmax for x>max.
ClipFill
ClipFill is an option for plotting functions that specifies what should be shown where curves or surfaces would extend beyond the plot range.
ClippingStyle
ClippingStyle is an option for plotting functions that specifies the style of what should be drawn when curves or surfaces would extend beyond the plot range.
ClipPlanes
ClipPlanes is an option to Graphics3D that specifies a list of clipping planes that can cut away portions of a 3D scene from the resulting view.
ClipPlanesStyle
ClipPlanesStyle is an option to Graphics3D that specifies how clipping planes defined with the ClipPlanes option should be rendered.
ClipRange
ClipRange is an option to Raster3D that specifies a rectangular region that is cut away from the resulting view.
ClockGauge
ClockGauge[] draws an analog clock face showing the local time with hours, minutes, and seconds.
ClockGauge[time] draws an analog clock face showing the time corresponding to an AbsoluteTime, DateObject, or TimeObject specification.
ClockGauge[{h,m,s}] draws an analog clock face showing hour h, minute m, and seconds s.
ClockGauge[{y,m,d,h,m,s}] draws an analog clock face showing the time corresponding to the date list in a DateList specification.
ClockGauge["string"] draws an analog clock face showing the time DateList["string"].
Close
Close[obj] closes a stream or socket.
CloseKernels
CloseKernels[] terminates all parallel kernels from the list ParallelKernels[].
CloseKernels[k] terminates the kernel k.
CloseKernels[{k1,k2,…}] terminates the kernels k1, k2, ….
CloseKernels["prop"] terminates kernels that satisfy the given property.
ClosenessCentrality
ClosenessCentrality[g] gives a list of closeness centralities for the vertices in the graph g.
ClosenessCentrality[{v->w,…}] uses rules v->w to specify the graph g.
Closing
Closing[image,ker] gives the morphological closing of image with respect to the structuring element ker.
Closing[image,r] gives the closing with respect to a range-r square.
Closing[data,…] applies closing to an array of data.
ClusterClassify
ClusterClassify[data] generates a ClassifierFunction[…] by partitioning data into clusters of similar elements.
ClusterClassify[data,n] generates a ClassifierFunction[…] with n clusters.
ClusterDissimilarityFunction
ClusterDissimilarityFunction is an option for ClusteringTree and Dendrogram that specifies the intercluster dissimilarity.
ClusteringComponents
ClusteringComponents[array] gives an array in which each element at the lowest level of array is replaced by an integer index representing the cluster in which the element lies.
ClusteringComponents[array,n] finds n clusters.
ClusteringComponents[array,n,level] finds clusters at the specified level in array.
ClusteringComponents[image] finds clusters of pixels with similar values in image.
ClusteringComponents[image,n] finds n clusters in image.
ClusteringTree
ClusteringTree[{e1,e2,…}] constructs a weighted tree from the hierarchical clustering of the elements e1, e2, ….
ClusteringTree[{e1->v1,e2->v2,…}] represents ei with vi in the constructed graph.
ClusteringTree[{e1,e2,…}->{v1,v2,…}] represents ei with vi in the constructed graph.
ClusteringTree[<|label1->e1,label2->e2…|>] represents ei using labels labeli in the constructed graph.
ClusteringTree[data,h] constructs a weighted tree from the hierarchical clustering of data by joining subclusters at distance less than h.
CMYKColor
CMYKColor[c,m,y,k] represents a color in the CMYK color space with cyan, magenta, yellow and black components.
CMYKColor[c,m,y,k,a] specifies opacity a.
CMYKColor["string"] returns a color from an HTML color name etc.
CMYKColor[color] returns the CMYK representation of color.
Coefficient
Coefficient[expr,form] gives the coefficient of form in the polynomial expr.
Coefficient[expr,form,n] gives the coefficient of form^n in expr.
CoefficientArrays
CoefficientArrays[polys,vars] gives the arrays of coefficients of the variables vars in the polynomials polys.
CoefficientList
CoefficientList[poly,var] gives a list of coefficients of powers of var in poly, starting with power 0.
CoefficientList[poly,{var1,var2,…}] gives an array of coefficients of the vari.
CoefficientList[poly,{var1,var2,…},{dim1,dim2,…}] gives an array of dimensions {dim1,dim2,…}, truncating or padding with zeros as needed.
CoefficientRules
CoefficientRules[poly,{x1,x2,…}] gives the list {{e11,e12,…}->c1,{e21,…}->c2,…} of exponent vectors and coefficients for the monomials in poly with respect to the xi.
CoefficientRules[poly,{x1,x2,…},order] gives the result with the monomial ordering specified by order.
CoifletWavelet
CoifletWavelet[] represents a Coiflet wavelet of order 2.
CoifletWavelet[n] represents a Coiflet wavelet of order n.
Collect
Collect[expr,x] collects together terms involving the same powers of objects matching x.
Collect[expr,{x1,x2,…}] successively collects together terms that involve the same powers of objects matching x1, then x2, ….
Collect[expr,var,h] applies h to the expression that forms the coefficient of each term obtained.
CollinearPoints
CollinearPoints[{p1,p2,p3,…,pn}] tests whether the points p1,p2,p3,…,pn are collinear.
Colon
Colon[x,y,…] displays as x∶y∶….
ColonForm
ColonForm[a,b] prints as a: b.
ColorBalance
ColorBalance[image] adjusts the colors in image to achieve a balance that simulates the effect of neutral lighting.
ColorBalance[image,ref] adjusts colors in image so that the reference color specified by ref is mapped to white.
ColorBalance[image,ref->target] maps the reference color ref to target.
ColorCombine
ColorCombine[{image1,image2,…}] creates a multichannel image by combining the sequence of channels in the imagei.
ColorCombine[{image1,image2,…},colorspace] combines images that represent the color components specified by colorspace.
ColorConvert
ColorConvert[color,colspace] converts the color space of a color to the specified color space colspace.
ColorConvert[image,colspace] converts the color space of image.
ColorConvert[{expr1,…},colspace] converts the color space of a list of colors and images.
ColorCoverage
ColorCoverage is an option for DominantColors that specifies the minimum image coverage that each color cluster should have.
ColorData
ColorData["scheme"] gives a function that generates colors in the named color scheme when applied to parameter values.
ColorData["scheme","property"] gives the specified property of a color scheme.
ColorData["collection"] gives a list of color schemes in a named collection.
ColorData[] gives a list of named collections of color schemes.
ColorDataFunction
ColorDataFunction[range,…] is a function that represents a color scheme.
ColorDetect
ColorDetect[image,cspec] returns a mask image representing regions in image with colors within the specified color region.
ColorDistance
ColorDistance[c1,c2] gives the approximate perceptual distance between color directives c1 and c2.
ColorDistance[list,c] gives color distances between elements of list and c.
ColorDistance[list1,list2] gives color distances between corresponding elements of list1 and list2.
ColorDistance[image,c] gives an image whose pixel values are color distance between pixels in image and the color c.
ColorDistance[image1,image2] yields an image giving the pixelwise color distance between image1 and image2.
ColorFunction
ColorFunction is an option for graphics functions that specifies a function to apply to determine colors of elements.
ColorFunctionBinning
ColorFunctionBinning is an option for plotting functions that divides values into a limited set of bins for styling.
ColorFunctionScaling
ColorFunctionScaling is an option for graphics functions that specifies whether arguments supplied to a color function should be scaled to lie between 0 and 1.
Colorize
Colorize[m] generates an image from an integer matrix m, using colors for positive integers and black for non-positive integers.
Colorize[image] replaces intensity values in image with pseudocolor values.
ColorNegate
ColorNegate[color] gives the negative of a color.
ColorNegate[image] gives the negative of image, in which all colors have been negated.
ColorNegate[video] negates every frame of a video.
ColorNegate[{expr1,…}] gives a list of negative images or colors.
ColorOutput
ColorOutput is an option for graphics functions that specifies the type of color output to produce.
ColorProfileData
ColorProfileData[<>,"Description"->"desc","DeviceColorSpace"->"device","IndependentColorSpace"->"ics"] represents an ICC color profile that can convert between the independent color space "ics" and the device-dependent color space "device".
ColorQ
ColorQ[color] yields True if color is a valid color directive and False otherwise.
ColorQuantize
ColorQuantize[image] gives an approximation to image by quantizing to distinct colors.
ColorQuantize[image,n] uses at most n distinct colors.
ColorQuantize[image,{col1,…,coln}] represents an image using only the n specified colors coli.
ColorReplace
ColorReplace[image,color] finds regions in image whose pixel values are similar to color and replaces them with transparent pixels.
ColorReplace[image,color->replacement] replaces all pixels with the specified replacement color.
ColorReplace[image,color->replacement,d] replaces all pixels whose values are within a distance d from color.
ColorReplace[image,{color1->replacement1,…},{d1,…}] does multiple color replacements.
ColorSeparate
ColorSeparate[image] gives a list of single-channel images corresponding to each of the color channels in image.
ColorSeparate[image,colorspace] gives a list of images corresponding to the components of colorspace.
ColorSeparate[image,channel] returns a single-channel image containing the specified channel.
ColorsNear
ColorsNear[color] represents a region around color.
ColorsNear[color,d] represents a region with maximum distance d around color.
ColorsNear[color,d,dfun] uses the specified color distance function dfun.
ColorSpace
ColorSpace is an option for Image and related functions that specifies the color space to which color values refer.
ColorToneMapping
ColorToneMapping[image] applies a tone mapping to color values in image so as to make variations of luminance visible even in small intervals of the dynamic range.
ColorToneMapping[image,c] maps colors by compressing the overall range of luminance values by a factor c.
ColorToneMapping[image,range] applies a mapping only to colors whose initial luminance lies in the specified range.
ColorToneMapping[image,{range,c}] takes the specified range of colors and compresses their overall luminance values by a factor c.
ColorToneMapping[image,{{range1,c1},{range2,c2},…}] uses different compression factors ci for different ranges rangei.
ColorToneMapping[image,spec,s] uses the color compensation factor s to correct for saturation distortion introduced during tone mapping.
Column
Column[{expr1,expr2,…}] is an object that formats with the expri arranged in a column, with expr1 above expr2, etc.
Column[list,alignment] aligns each element horizontally in the specified way.
Column[list,alignment,spacing] leaves the specified number of x-heights of spacing between successive elements.
ColumnForm
ColumnForm[{e1,e2,…}] prints as a column with e1 above e2, etc.
ColumnForm[list,horiz] specifies the horizontal alignment of each element.
ColumnForm[list,horiz,vert] also specifies the vertical alignment of the whole column.
CombinatorB
CombinatorB represents the <b>B</b> combinator.
CombinatorC
CombinatorC represents the <b>C</b> combinator.
CombinatorI
CombinatorI represents the <b>I</b> combinator.
CombinatorK
CombinatorK represents the <b>K</b> combinator.
CombinatorS
CombinatorS represents the <b>S</b> combinator.
CombinatorW
CombinatorW represents the <b>W</b> combinator.
CombinatorY
CombinatorY represents the <b>Y</b> combinator.
CombinedEntityClass
CombinedEntityClass[class1,class2,prop] represents a class of entities obtained by combining the properties of those pairs of entities from class1 and class2 for which the value of the property prop is the same for the two entities in the pair.
CombinedEntityClass[class1,class2,prop1->prop2] combines pairs of entities from class1 and class2 for which the value of prop1 of the entity from class1 is the same as the value of prop2 for the entity from class2.
CombinedEntityClass[class1,class2,{pspeca,pspecb,…}] combines pairs of entities for which all the property specifications pspeck agree.
CombinedEntityClass[class1,class2,f] combines pairs of entities for which the application of the entity function f yields True.
CombinedEntityClass[class1,class2,spec,"jspec"] uses "jspec" to determine when to allow entities with missing properties to be included.
CombinerFunction
CombinerFunction is an option for template functions that specifies how fragments should be assembled to give the result of applying a template.
CometData
CometData[entity,property] gives the value of the specified property for the comet entity.
CometData[{entity1,entity2,…},property] gives a list of property values for the specified comet entities.
CometData[entity,property,annotation] gives the specified annotation associated with the given property.
Commonest
Commonest[list] gives a list of the elements that are the most common in list.
Commonest[list,n] gives a list of the n most common elements in list.
CommonName
CommonName[entity] gives the common name for the entity specified by entity.
CommonName[{entity1,…,entityn}] gives the common name for entity1 through entityn.
CommonUnits
CommonUnits[{quantity1,quantity2,…,quantityn}] converts quantity1 through quantityn to common units across compatible dimensions.
CommunityBoundaryStyle
CommunityBoundaryStyle is an option to CommunityGraphPlot that specifies how to style community boundaries.
CommunityGraphPlot
CommunityGraphPlot[g] generates a plot showing the community structure of the graph g.
CommunityGraphPlot[g,{{vi1,vi2,…},…}] generates a plot for the graph g with communities {vi1,vi2,…}, ….
CommunityGraphPlot[g,{…,wj[{vi1,…}],…}] generates a plot with highlighting features defined by the symbol wrappers wj.
CommunityGraphPlot[{vi1->vj1,vi2->vj2,…},…] generates a plot for a graph in which vertex vik is connected to vertex vjk.
CommunityGraphPlot[m,…] generates a plot for a graph represented by the adjacency matrix m.
CommunityLabels
CommunityLabels is an option to CommunityGraphPlot that controls what labels and placement to use for communities.
CommunityRegionStyle
CommunityRegionStyle is an option to CommunityGraphPlot that specifies how to style community regions.
CompanyData
CompanyData[entity,property] gives the value of the specified property for the company entity.
CompanyData[{entity1,entity2,…},property] gives a list of property values for the specified company entities.
CompanyData[entity,property,annotation] gives the specified annotation associated with the given property.
CompatibleUnitQ
CompatibleUnitQ[quantity1,quantity2] returns True if quantity1 and quantity2 have compatible units, and False otherwise.
CompilationOptions
CompilationOptions is an option for Compile that specifies settings for the compilation process.
CompilationTarget
CompilationTarget is an option for Compile that specifies the target runtime for the compiled function.
Compile
Compile[{x1,x2,…},expr] creates a compiled function that evaluates expr assuming numerical values of the xi.
Compile[{{x1,t1},…},expr] assumes that xi is of a type that matches ti.
Compile[{{x1,t1,n1},…},expr] assumes that xi is a rank ni array of objects, each of a type that matches ti.
Compile[vars,expr,{{p1,pt1},…}] assumes that subexpressions in expr that match pi are of types that match pti.
Compiled
Compiled is an option for various numerical and plotting functions which specifies whether the expressions they work with should automatically be compiled.
CompiledCodeFunction
CompiledCodeFunction[…] is a function created by FunctionCompile that contains compiled code that is run when the CompiledCodeFunction is applied to suitable arguments.
CompiledFunction
CompiledFunction[�] represents compiled code for evaluating a compiled function.
CompiledLayer
CompiledLayer[func] represents a net layer whose computation is defined by the compilable function func.
CompiledLayer[func,gradientfunc] specifies a gradient propagating function allowing the layer to be used in NetTrain.
CompilerEnvironment
CompilerEnvironment is an option for FunctionCompile and related functions that allows definitions to be included in the compilation.
CompilerEnvironmentAppendTo
CompilerEnvironmentAppendTo[{def1,def2,…}] appends declarations to $CompilerEnvironment.
CompilerEnvironmentAppendTo[env,{def1,def2,…}] appends declarations to CompilerEnvironmentObject env.
CompilerEnvironmentObject
CompilerEnvironmentObject represents a collection of definitions that can be included in compilations by FunctionCompile and related functions.
CompilerOptions
CompilerOptions is an option for FunctionCompile and related functions that allows options for the compilation pipeline to be specified.
Complement
Complement[eall,e1,e2,…] gives the elements in eall that are not in any of the ei.
ComplementedEntityClass
ComplementedEntityClass[classall,class1,…] represents an entity class containing all the entities in classall that are not in any of the classi.
CompleteGraph
CompleteGraph[n] gives the complete graph with n vertices Kn.
CompleteGraph[{n1,n2,…,nk}] gives the complete k-partite graph with n1+n2+⋯+nk vertices Kn1,n2,…,nk.
CompleteGraphQ
CompleteGraphQ[g] yields True if the graph g is a complete graph, and False otherwise.
CompleteGraphQ[g,vlist] yields True if the subgraph induced by vlist is a complete graph, and False otherwise.
CompleteIntegral
CompleteIntegral[pde,u,{x1,…,xn}] gives a complete integral u for the first-order partial differential equation pde, with independent variables {x1,…,xn}.
CompleteKaryTree
CompleteKaryTree[n] gives the complete binary tree with n levels.
CompleteKaryTree[n,k] gives the complete k-ary tree with n levels.
Complex
Complex is the head used for complex numbers.
ComplexArrayPlot
ComplexArrayPlot[array] generates a plot in which complex values zij in an array array are shown in a discrete array of squares with Arg[zij] indicated by color and Abs[zij] by shading.
ComplexContourPlot
ComplexContourPlot[f,{z,zmin,zmax}] generates a filled contour plot of f as a function of z.
ComplexContourPlot[{f1,f2,…},{z,zmin,zmax}] generates contour lines for f1, f2, ….
ComplexContourPlot[f==g,{z,zmin,zmax}] plots contour lines for which f=g.
ComplexContourPlot[{f1==g1,f2==g2,…},{z,zmin,zmax}] plots contour lines for each of f1g1, f2=g2, ….
Complexes
Complexes represents the domain of complex numbers, as in x∈Complexes.
ComplexExpand
ComplexExpand[expr] expands expr assuming that all variables are real.
ComplexExpand[expr,{x1,x2,…}] expands expr assuming that variables matching any of the xi are complex.
ComplexInfinity
ComplexInfinity represents a quantity with infinite magnitude, but undetermined complex phase.
ComplexityFunction
ComplexityFunction is an option for Simplify and other functions which gives a function to rank the complexity of different forms of an expression.
ComplexListPlot
ComplexListPlot[{z1,z2,…}] plots complex numbers z1, z2, … as points in the complex plane.
ComplexListPlot[{data1,data2,…}] plots data from all datai.
ComplexListPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ComplexPlot
ComplexPlot[f,{z,zmin,zmax}] generates a plot of Arg[f] over the complex rectangle with corners zmin and zmax.
ComplexPlot3D
ComplexPlot3D[f,{z,zmin,zmax}] generates a 3D plot of Abs[f] colored by Arg[f] over the complex rectangle with corners zmin and zmax.
ComplexRegionPlot
ComplexRegionPlot[pred,{z,zmin,zmax}] makes a plot showing the region in the complex plane for which pred is True.
ComplexRegionPlot[{pred1,pred2,…},{z,zmin,zmax}] plots regions given by the multiple predicates predi.
ComplexStreamPlot
ComplexStreamPlot[f,{z,zmin,zmax}] generates a streamline plot of the vector field {Re[f],Im[f]} over the complex rectangle with corners zmin and zmax.
ComplexVectorPlot
ComplexVectorPlot[f,{z,zmin,zmax}] generates a vector plot of the vector field {Re[f],Im[f]} over the complex rectangle with corners zmin and zmax.
ComplexVectorPlot[{f1,f2,…},{z,zmin,zmax}] plots several vector fields.
ComponentMeasurements
ComponentMeasurements[{image,lmat},"prop"] computes the property "prop" for components of image indicated by the label matrix lmat.
ComponentMeasurements[image,"prop"] computes the property "prop" for connected components of image.
ComponentMeasurements[…,"prop",crit] only returns measurements for components that satisfy the criterion crit.
ComponentMeasurements[…,"prop",crit,format] formats the result according to the output specification format.
ComposeList
ComposeList[{f1,f2,…},x] generates a list of the form {x,f1[x],f2[f1[x]],…}.
ComposeSeries
ComposeSeries[series1,series2,…] composes several power series.
CompositeQ
CompositeQ[n] yields True if n is a composite number, and yields False otherwise.
Composition
Composition[f1,f2,f3,…] represents a composition of the functions f1, f2, f3, ….
CompoundElement
CompoundElement[{spec1,spec2,…}] represents a form or interpreter specification for a list of fields or inputs that gives a list of results.
CompoundElement[<|key1->spec1,key2->spec2,…|>] represents a form or interpreter specification that gives an association of results.
CompoundExpression
expr1;expr2;… evaluates the expri in turn, giving the last one as the result.
CompoundPoissonDistribution
CompoundPoissonDistribution[λ,dist] represents a compound Poisson distribution with rate parameter λ and jump size distribution dist.
CompoundPoissonProcess
CompoundPoissonProcess[λ,jdist] represents a compound Poisson process with rate parameter λ and jump size distribution jdist.
CompoundRenewalProcess
CompoundRenewalProcess[rdist,jdist] represents a compound renewal process with renewal-time distribution rdist and jump size distribution jdist.
Compress
Compress[expr] gives a compressed representation of expr as a string.
CompressionLevel
CompressionLevel is an option for Export and CreateArchive that specifies the amount of compression to use when compressing data.
ComputeUncertainty
ComputeUncertainty is an option for ClassifierMeasurements, LearnedDistribution and other functions to specify if numeric results should be returned along with their uncertainty.
ConcaveHullMesh
ConcaveHullMesh[{p1,p2,…}] gives the concave hull mesh from the points p1,p2,….
ConcaveHullMesh[{p1,p2,…},α] gives the concave hull mesh of the specified parameter α.
ConcaveHullMesh[{p1,p2,…},α,d] gives the concave hull mesh of cells of dimension d.
Condition
patt/;test is a pattern which matches only if the evaluation of test yields True.
lhs:>rhs/;test represents a rule which applies only if the evaluation of test yields True.
lhs:=rhs/;test is a definition to be used only if test yields True.
ConditionalExpression
ConditionalExpression[expr,cond] is a symbolic construct that represents the expression expr when the condition cond is True.
Conditioned
Conditioned[expr,cond] or exprcond represents expr conditioned by the predicate cond.
Cone
Cone[{{x1,y1,z1},{x2,y2,z2}},r] represents a cone with a base of radius r centered at (x1,y1,z1) and a tip at (x2,y2,z2).
Cone[{{x1,y1,z1},{x2,y2,z2}}] represents a cone with a base of radius 1.
ConfidenceLevel
ConfidenceLevel is an option for LinearModelFit and other fitting functions that specifies the level to use in various confidence and prediction intervals and bands.
ConfidenceRange
ConfidenceRange is an option for SurvivalModelFit and other functions that specifies the range over which simultaneous confidence intervals and bands are computed.
ConfidenceTransform
ConfidenceTransform is an option for functions such as SurvivalModelFit that specifies the transformation used for confidence intervals and bands.
ConfigurationPath
ConfigurationPath is a global option that specifies which directories are searched for systemwide configuration information.
Confirm
Confirm[expr] confirms that expr is not considered a failure, otherwise throwing an error to the nearest surrounding Enclose.
Confirm[expr,info] evaluates info and includes its value in the thrown error if expr is not confirmed.
Confirm[expr,info,tag] uses the specified tag for any thrown errors.
ConfirmAssert
ConfirmAssert[test] confirms that test is True, otherwise throwing an error to the nearest surrounding Enclose.
ConfirmAssert[test,info] evaluates info and includes its value in the thrown error if test is not True.
ConfirmAssert[test,info,tag] uses the specified tag for any thrown errors.
ConfirmBy
ConfirmBy[expr,f] confirms that f[expr] returns True, otherwise throwing an error to the nearest surrounding Enclose.
ConfirmBy[expr,f,info] evaluates info and includes its value in the thrown error if expr is not confirmed.
ConfirmBy[expr,f,info,tag] uses the specified tag for any thrown errors.
ConfirmMatch
ConfirmMatch[expr,form] confirms that expr matches the pattern form, otherwise throwing an error to the nearest surrounding Enclose.
ConfirmMatch[expr,form,info] evaluates info and includes its value in the thrown error if expr is not confirmed.
ConfirmMatch[expr,form,info,tag] uses the specified tag for any thrown errors.
ConfirmQuiet
ConfirmQuiet[expr] confirms that no messages are generated during the evaluation of expr, otherwise quieting them and throwing an error to the nearest surrounding Enclose.
ConfirmQuiet[expr,s::t] tests only for the specified message.
ConfirmQuiet[expr,{s1::t1,s2::t2,…}] tests only for the specified list of messages.
ConfirmQuiet[expr,"group"] tests only for messages in the named message group.
ConfirmQuiet[expr,mspec,info] evaluates info and includes its value in the thrown error if expr is not confirmed.
ConfirmQuiet[expr,mspec,info,tag] uses the specified tag for any thrown errors.
ConformationMethod
ConformationMethod is an option for VideoJoin and others that specifies how to conform frames of different videos.
ConformAudio
ConformAudio[{audio1,audio2,…}] returns a list of audio objects where all audioi are made to have conforming properties, including duration, data type, and number of channels.
ConformAudio[{audio1,audio2,…},spec] returns all audio objects of the specified spec.
ConformImages
ConformImages[{image1,image2,…}] returns a list of images where all imagei are made to have conforming properties, including dimensions, data type, color space, and interleaving.
ConformImages[{image1,image2,…},spec] returns all images of the specified spec.
ConformImages[{image1,image2,…},spec,fitting] resizes images using the specified fitting method.
Congruent
Congruent[x,y,…] displays as x≡y≡….
ConicGradientFilling
ConicGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using a progressive transition between colors coli along a circle.
ConicGradientFilling[{θ1,θ2,…,θn}->{col1,col2,…,coln}] uses the colors coli at angles θi.
ConicGradientFilling[{θ1,θ2,…,θn}->{col1,col2,…,coln},{x,y}] rotates from the center point {x,y}.
ConicHullRegion
ConicHullRegion[{p1, …,pm+1}] represents the m-dimensional affine hull region passing through points pi.
ConicHullRegion[p,{v1,…,vm}] represents the m-dimensional affine hull region passing through the point p and parallel to vi.
ConicHullRegion[{p1,…,pm+1},{w1,…,wn}] represents the m-dimensional affine hull plus the conic hull generated by the vectors wj.
ConicHullRegion[p,{v1,…,vm},{w1,…,wn}] represents the m-dimensional affine hull plus the conic hull generated by the vectors wj.
ConicOptimization
ConicOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to conic constraints cons.
ConicOptimization[…,"prop"] specifies what solution property "prop" should be returned.
Conjugate
Conjugate[z] or z gives the complex conjugate of the complex number z.
ConjugateTranspose
ConjugateTranspose[m] or m gives the conjugate transpose of m.
Conjunction
Conjunction[expr,{a1,a2,…}] gives the conjunction of expr over all choices of the Boolean variables ai.
Connect
Connect is a setting for the LinkMode option of LinkOpen. LinkMode->Connect causes a link to be created that will connect to a link listening on a named port.
ConnectedComponents
ConnectedComponents[g] gives the connected components of the graph g.
ConnectedComponents[g,{v1,v2,…}] gives the connected components that include at least one of the vertices v1, v2, … .
ConnectedComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.
ConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g.
ConnectedGraphComponents
ConnectedGraphComponents[g] gives the connected components of the graph g.
ConnectedGraphComponents[g,{v1,v2,…}] gives the connected components that include at least one of the vertices v1, v2, … .
ConnectedGraphComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.
ConnectedGraphComponents[{v->w,…},…] uses rules v->w to specify the graph g.
ConnectedGraphQ
ConnectedGraphQ[g] yields True if the graph g is connected, and False otherwise.
ConnectedMeshComponents
ConnectedMeshComponents[mr] gives a list {c1,c2,…} of disjoint path connected meshed regions.
ConnectedMoleculeQ
ConnectedMoleculeQ[mol] returns True if the atoms in mol form are connected by bonds, and False otherwise.
ConnectionSettings
ConnectionSettings is an option for URLRead and related functions to specify advanced connection settings.
ConnectLibraryCallbackFunction
ConnectLibraryCallbackFunction[mname,cf] connects a CompiledFunction cf with the library callback manager with name mname.
ConnesWindow
ConnesWindow[x] represents a Connes window function of x.
ConnesWindow[x,α] uses the parameter α.
ConservativeConvectionPDETerm
ConservativeConvectionPDETerm[vars,α] represents a conservative convection term ∇{x1,…,xn}·(-α u) with conservative convection coefficient α and model variables vars.
ConservativeConvectionPDETerm[vars,α,pars] uses model parameters pars.
Constant
Constant is an attribute that indicates zero derivative of a symbol with respect to all parameters.
ConstantArray
ConstantArray[c,n] generates a list of n copies of the element c.
ConstantArray[c,{n1,n2,…}] generates an n1n2… array of nested lists containing copies of the element c.
ConstantArrayLayer
ConstantArrayLayer[] represents a layer that has no input and produces as output a constant array.
ConstantArrayLayer[opts] includes options for initial value of the array or output size.
ConstantImage
ConstantImage[val,size] gives an image of the specified size with constant pixel values of val.
ConstantImage[val,size,"type"] gives an image converted to the specified type.
ConstantPlusLayer
ConstantPlusLayer[] represents a layer that adds a learnable bias to its input.
ConstantPlusLayer[opts] includes options for initial bias and other parameters.
ConstantRegionQ
ConstantRegionQ[reg] gives True if the reg is a constant region and False otherwise.
Constants
Constants is an option for Dt which gives a list of objects to be taken as constants.
ConstantTimesLayer
ConstantTimesLayer[] represents a layer that multiplies its input by a learnable scaling array.
ConstantTimesLayer[opts] includes options for initial scaling and other parameters.
ConstellationData
ConstellationData[entity,property] gives the value of the specified property for the constellation entity.
ConstellationData[{entity1,entity2,…},property] gives a list of property values for the specified constellation entities.
ConstellationData[entity,property,annotation] gives the specified annotation associated with the given property.
Construct
Construct[f,x] gives f[x].
Construct[f,x1,…,xn] gives f[x1,…,xn].
Containing
Containing["outer","inner"] represents an object of type outer containing objects of type inner.
ContainsAll
ContainsAll[list1,list2] yields True if list1 contains all of the elements of list2.
ContainsAll[list2] is an operator form that yields True when the object to which it is applied contains all of the elements of list2.
ContainsAny
ContainsAny[list1,list2] yields True if list1 contains any of the elements of list2.
ContainsAny[list2] is an operator form that yields True when the object to which it is applied contains any of the elements in list2.
ContainsExactly
ContainsExactly[list1,list2] yields True if list1 contains exactly the same elements as list2.
ContainsExactly[list2] is an operator form that yields True when the object to which it is applied contains exactly the same elements as list2.
ContainsNone
ContainsNone[list1,list2] yields True if list1 contains none of the elements in list2.
ContainsNone[list2] is an operator form that yields True when the object to which it is applied contains none of the elements of list2.
ContainsOnly
ContainsOnly[list1,list2] yields True if list1 contains only elements that appear in list2.
ContainsOnly[list2] is an operator form that yields True when the object to which it is applied contains only elements that appear in list2.
ContentDetectorFunction
ContentDetectorFunction[…] represents a function generated by TrainImageContentDetector or TrainTextContentDetector that localizes and classifies contents in a piece of text or an image.
ContentFieldOptions
ContentFieldOptions is an option for CreateSearchIndex and related functions that allows options to be specified for handling different fields in content that is being indexed.
ContentLocationFunction
ContentLocationFunction is an option to CreateSearchIndex and related functions that specifies how to determine locations to be used for hyperlinks and related constructs in the resulting index.
ContentObject
ContentObject["string"] gives a content object whose content is string.
ContentObject[File[…]] gives a content object whose content is stored in the specified file.
ContentObject[<|name1->val1,name2->val2,…|>] gives a content object with a sequence of fields with names namei and values vali.
ContentPadding
ContentPadding is an option for objects that can be displayed with frames that specifies whether the vertical margins should shrink wrap tightly around the contents.
ContentSelectable
ContentSelectable is an option to constructs such as Inset, Graphics, and GraphicsGroup that specifies whether and how content within them should be selectable.
ContentSize
ContentSize is an option for Manipulate and other functions that specifies the size of the content area to use.
Context
Context[] gives the current context.
Context[symbol] gives the context in which a symbol appears.
Context["symbol"] gives the context in which the symbol named "symbol" appears if it exists.
Contexts
Contexts[] gives a list of all contexts.
Contexts["string"] gives a list of the contexts that match the string.
ContextToFileName
ContextToFileName["context"] gives the string specifying the file name that is by convention associated with a particular context.
Continue
Continue[] goes to the next iteration of the nearest enclosing Do, For, Until or While in a procedural program.
ContinuedFraction
ContinuedFraction[x,n] generates a list of the first n terms in the continued fraction representation of x.
ContinuedFraction[x] generates a list of all terms that can be obtained given the precision of x.
ContinuedFractionK
ContinuedFractionK[f,g,{i,imin,imax}] represents the continued fraction Κi=iminimaxf/g.
ContinuedFractionK[g,{i,imin,imax}] represents the continued fraction Κi=iminimax1/g.
ContinuousAction
ContinuousAction is an option for Manipulate, Slider, and related functions that specifies whether action should be taken continuously while controls are being moved.
ContinuousMarkovProcess
ContinuousMarkovProcess[i0,q] represents a continuous-time finite-state Markov process with transition rate matrix q and initial state i0.
ContinuousMarkovProcess[p0,q] represents a Markov process with initial state probability vector p0.
ContinuousMarkovProcess[…,m,μ] represents a Markov process with transition matrix m and transition rates μ.
ContinuousMarkovProcess[…,g] represents a Markov process transition rate matrix from the graph g.
ContinuousTask
ContinuousTask[expr] represents a task in which expr is continuously reevaluated.
ContinuousTask[expr,end] represents a task in which expr is continuously reevaluated until the time specified by end.
ContinuousTask[expr,tspan] represents a task in which expr is continuously reevaluated over the time span tspan.
ContinuousTimeModelQ
ContinuousTimeModelQ[lsys] gives True if lsys is a continuous-time systems model, and False otherwise.
ContinuousWaveletData
ContinuousWaveletData[{{oct1,voc1}->coef1,…},wave] yields a continuous wavelet data object with wavelet coefficients coefi corresponding to octave and voice {octi,voci} and wavelet wave.
ContinuousWaveletTransform
ContinuousWaveletTransform[{x1,x2,…}] gives the continuous wavelet transform of a list of values xi.
ContinuousWaveletTransform[data,wave] gives the continuous wavelet transform using the wavelet wave.
ContinuousWaveletTransform[data,wave,{noct,nvoc}] gives the continuous wavelet transform using noct octaves with nvoc voices per octave.
ContinuousWaveletTransform[sound,…] gives the continuous wavelet transform of sampled sound.
ContourDetect
ContourDetect[image] gives a binary image in which white pixels correspond to the zeros and zero crossings in image.
ContourDetect[image,delta] treats values in image that are smaller in absolute value than delta as zero.
ContourDetect[array,…] gives a binary sparse array in which 1 corresponds to zeros and zero crossings in array.
ContourGraphics
ContourGraphics[array] is a representation of a contour plot.
ContourLabels
ContourLabels is an option for contour plots that specifies how to label contours.
ContourLines
ContourLines is an option for contour plots that specifies whether to draw explicit contour lines.
ContourPlot
ContourPlot[f,{x,xmin,xmax},{y,ymin,ymax}] generates a contour plot of f as a function of x and y.
ContourPlot[f==g,{x,xmin,xmax},{y,ymin,ymax}] plots contour lines for which f=g.
ContourPlot[{f1==g1,f2==g2,…},{x,xmin,xmax},{y,ymin,ymax}] plots several contour lines.
ContourPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
ContourPlot3D
ContourPlot3D[f,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] produces a three-dimensional contour plot of f as a function of x, y, and z.
ContourPlot3D[f==g,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots the contour surface for which f=g.
ContourPlot3D[…,{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg.
Contours
Contours is an option for contour plots that specifies the contours to draw.
ContourShading
ContourShading is an option for contour plots that specifies how the regions between contour lines should be shaded.
ContourStyle
ContourStyle is an option for contour plots that specifies the style in which contour lines or surfaces should be drawn.
ContraharmonicMean
ContraharmonicMean[list] gives the contraharmonic mean of the values in list.
ContraharmonicMean[list,p] gives the order p Lehmer contraharmonic mean.
ContrastiveLossLayer
ContrastiveLossLayer[] represents a loss layer that computes a loss based on a distance metric and a target that specifies whether the distance should be minimized or maximized.
ContrastiveLossLayer[margin] specifies a distance above which the loss is zero for True targets.
Control
Control[{u,dom}] represents an interactive control for the variable u in the domain dom, with the type of control chosen to be appropriate for the domain specified.
Control[{{u,uinit},dom}] represents a control with initial value uinit.
ControlActive
ControlActive[act,norm] evaluates to act if a control that affects act is actively being used, and to norm otherwise.
ControllabilityGramian
ControllabilityGramian[ssm] gives the controllability Gramian of the state-space model ssm.
ControllabilityMatrix
ControllabilityMatrix[ssm] gives the controllability matrix of the state-space model ssm.
ControllableDecomposition
ControllableDecomposition[sys] yields the controllable subsystem of the state-space model sys.
ControllableDecomposition[sys,{z1,…}] specifies the new state variables zi.
ControllableModelQ
ControllableModelQ[sys] yields True if the state-space model sys is controllable, and False otherwise.
ControllableModelQ[{sys,sub}] yields True if the subsystem sub is controllable.
ConvectionPDETerm
ConvectionPDETerm[vars,β] represents a convection term β·∇{x1,…,xn}u with convection coefficient β and model variables vars.
ConvectionPDETerm[vars,β,pars] uses model parameters pars.
Convergents
Convergents[list] gives a list of the convergents corresponding to the continued fraction terms list.
Convergents[x,n] gives the first n convergents for a number x.
Convergents[x] gives if possible all convergents leading to the number x.
ConversionOptions
ConversionOptions is an option to Import and Export used to pass special options to a particular format.
ConversionRules
ConversionRules is an option for Cell that can be set to a list of rules specifying how the contents of the cell are to be converted to external formats.
ConvexHullMesh
ConvexHullMesh[{p1,p2,…}] gives a BoundaryMeshRegion representing the convex hull from the points p1, p2, ….
ConvexHullMesh[mreg] gives the convex hull of the mesh region mreg.
ConvexHullRegion
ConvexHullRegion[{p1,p2,…}] gives the convex hull from the points p1, p2, ….
ConvexHullRegion[reg] gives the convex hull of the region reg.
ConvexOptimization
ConvexOptimization[f,cons,vars] finds values of variables vars that minimize the convex objective function f subject to convex constraints cons.
ConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned.
ConvexPolygonQ
ConvexPolygonQ[poly] gives True if the polygon poly is convex, and False otherwise.
ConvexPolyhedronQ
ConvexPolyhedronQ[poly] gives True if the polyhedron poly is convex, and False otherwise.
ConvexRegionQ
ConvexRegionQ[reg] gives True if reg is a convex region and False otherwise.
ConvolutionLayer
ConvolutionLayer[n,s] represents a trainable convolutional net layer having n output channels and using kernels of size s to compute the convolution.
ConvolutionLayer[n,{s}] represents a layer performing one-dimensional convolutions with kernels of size s.
ConvolutionLayer[n,{h,w}] represents a layer performing two-dimensional convolutions with kernels of size h×w.
ConvolutionLayer[n,{h,w,d}] represents a three-dimensional convolutions with kernels of size h×w×d.
ConvolutionLayer[n,kernel,opts] includes options for padding and other parameters.
Convolve
Convolve[f,g,x,y] gives the convolution with respect to x of the expressions f and g.
Convolve[f,g,{x1,x2,…},{y1,y2,…}] gives the multidimensional convolution.
ConwayGroupCo1
ConwayGroupCo1[] represents the sporadic simple Conway group Co1.
ConwayGroupCo2
ConwayGroupCo2[] represents the sporadic simple Conway group Co2.
ConwayGroupCo3
ConwayGroupCo3[] represents the sporadic simple Conway group Co3.
CookieFunction
CookieFunction is an option for URLRead, HTTPRequest, and related functions that gives a function to apply to each cookie received when an HTTP response is received.
CoordinateBounds
CoordinateBounds[coords] gives a list {{xmin,xmax},{ymin,ymax},…} of the bounds in each dimension of the region defined by coords.
CoordinateBounds[coords,δ] pads the ranges of coordinates by ±δ in each dimension.
CoordinateBounds[coords,Scaled[s]] pads by the scaled amount s in each dimension.
CoordinateBounds[coords,{p1,p2,…}] pads by p1, p2, … in successive dimensions.
CoordinateBounds[coords,{{p1min,p1max},{p2min,p2max},…}] gives {{xmin-p1min,xmax+p1max},{ymin-p2min,ymax+p2max},…}
CoordinateBoundsArray
CoordinateBoundsArray[{{xmin,xmax},{ymin,ymax},…}] generates an array of {x,y,…} coordinates with integer steps in each dimension.
CoordinateBoundsArray[{xrange,yrange,…},d] uses step d in each dimension.
CoordinateBoundsArray[{xrange,yrange,…},{dx,dy,…}] uses steps dx, dy, … in successive dimensions.
CoordinateBoundsArray[{xrange,yrange,…},Into[n]] divides into n equal steps in each dimension.
CoordinateBoundsArray[{xrange,yrange,…},steps,offsets] specifies offsets to use for each coordinate point.
CoordinateBoundsArray[{xrange,yrange,…},steps,offsets,k] expands the array by k elements in every direction.
CoordinateChartData
CoordinateChartData[chart,property] gives the value of the specified property for chart.
CoordinateChartData[chart,property,{x1,x2,…,xn}] gives the value of the specified property for chart evaluated at the point {x1,x2,…,xn}.
CoordinatesToolOptions
CoordinatesToolOptions is an option for Graphics that gives values of options associated with the Get Coordinates tool.
CoordinateTransform
CoordinateTransform[t,pt] performs the coordinate transformation t on the point pt.
CoordinateTransform[t,{pt1,pt2,…}] transforms several points.
CoordinateTransformData
CoordinateTransformData[t,property] gives the value of the specified property for the coordinate transformation t.
CoordinateTransformData[t,property,{x1,x2,…,xn}] gives the value of the property evaluated at the point {x1,x2,…,xn}.
CoplanarPoints
CoplanarPoints[{p1,p2,p3,p4,…,pn}] tests whether the points p1,p2,p3,p4,…,pn are coplanar.
CoprimeQ
CoprimeQ[n1,n2] yields True if n1 and n2 are relatively prime, and yields False otherwise.
CoprimeQ[n1,n2,…] yields True if all pairs of the ni are relatively prime, and yields False otherwise.
Coproduct
Coproduct[x,y,…] displays as x∐y∐ ….
CopulaDistribution
CopulaDistribution[ker,{dist1,dist2,…}] represents a copula distribution with kernel distribution ker and marginal distributions dist1, dist2, … .
CopyDatabin
CopyDatabin[bin] creates a copy of a databin.
CopyDatabin[bin,options] creates a copy with the specified options.
CopyDirectory
CopyDirectory[dir1,dir2] copies the directory dir1 to dir2.
CopyToClipboard
CopyToClipboard[expr] replaces the contents of the clipboard with expr.
CoreNilpotentDecomposition
CoreNilpotentDecomposition[m] yields the core-nilpotent decomposition of a square matrix m.
CoreNilpotentDecomposition[m,format] returns the core-nilpotent decomposition according to the specified format.
CornerFilter
CornerFilter[image] computes a measure for the presence of a corner for each pixel in image and returns the result as an intensity image.
CornerFilter[image,r] detects corners at a pixel range r.
CornerNeighbors
CornerNeighbors is an option for various array and image processing functions that specifies whether diagonally adjacent corners should be considered neighbors of particular elements.
CorrelationDistance
CorrelationDistance[u,v] gives the correlation coefficient distance between vectors u and v.
CorrelationFunction
CorrelationFunction[data,hspec] estimates the correlation function at lags hspec from data.
CorrelationFunction[proc,hspec] represents the correlation function at lags hspec for the random process proc.
CorrelationFunction[proc,s,t] represents the correlation function at times s and t for the random process proc.
CorrelationTest
CorrelationTest[{{x1,y1},{x2,y2},…}] tests whether the correlation coefficient for a bivariate population is zero.
CorrelationTest[{{x1,y1},{x2,y2},…},ρ0] tests whether the correlation coefficient is ρ0.
CorrelationTest[{{x1,y1},{x2,y2},…},{{u1,v1},{u2,v2},…}] tests whether the correlation coefficients for two populations are equal.
CorrelationTest[…,"property"] returns the value of "property".
Cos
Cos[z] gives the cosine of z.
Cosh
Cosh[z] gives the hyperbolic cosine of z.
CoshIntegral
CoshIntegral[z] gives the hyperbolic cosine integral Chi(z).
CosineDistance
CosineDistance[u,v] gives the angular cosine distance between vectors u and v.
CosineWindow
CosineWindow[x] represents a cosine window function of x.
CosineWindow[x,α] uses the exponent α.
CosIntegral
CosIntegral[z] gives the cosine integral function Ci(z).
Cot
Cot[z] gives the cotangent of z.
Coth
Coth[z] gives the hyperbolic cotangent of z.
CoulombF
CoulombF[l,η,r] gives the regular Coulomb wavefunction Fl(η,r).
CoulombG
CoulombG[l,η,r] gives the irregular Coulomb wavefunction Gl(η,r).
CoulombH1
CoulombH1[l,η,r] gives the outgoing irregular Coulomb wavefunction Hl(+)(η,r).
CoulombH2
CoulombH2[l,η,r] gives the incoming irregular Coulomb wavefunction Hl(-)(η,r).
Count
Count[list,pattern] gives the number of elements in list that match pattern.
Count[expr,pattern,levelspec] gives the total number of subexpressions matching pattern that appear at the levels in expr specified by levelspec.
Count[pattern] represents an operator form of Count that can be applied to an expression.
CountDistinct
CountDistinct[list] gives the number of distinct elements that appear in list.
CountDistinct[list,test] applies test to pairs of elements to determine whether they should be considered equivalent.
CountDistinctBy
CountDistinctBy[{e1,e2,…},f] gives the number of distinct values of f[ei] that occur.
CountDistinctBy[f] represents an operator form of CountDistinctBy that can be applied to an expression.
CounterAssignments
CounterAssignments is an option for selections that sets the value of a specified counter.
CounterFunction
CounterFunction is an option for counters that specifies the symbols used to display the value of the counter.
CounterIncrements
CounterIncrements is an option for selections that specifies whether the value of a specified counter is incremented by one.
CountRoots
CountRoots[f,x] gives the number of real roots of the univariate function f in x.
CountRoots[f,{x,a,b}] gives the number of roots between a and b.
CountryData
CountryData["tag",property] gives the value of the specified property for the country, country-like entity, or group of countries specified by "tag".
CountryData["tag",{property,…,dates}] gives time series for certain economic and other properties.
Counts
Counts[list] gives an association whose keys are the distinct elements of list, and whose values give the number of times those elements appear in list.
Counts[list,elems] gives an association whose keys are the distinct elements in elems, and whose values give the number of times those elements appear in list.
CountsBy
CountsBy[{e1,e2,…},f] gives an association whose keys are the distinct values of the f[ei], and whose values give the number of times these f[ei] values appear.
CountsBy[f] represents an operator form of CountsBy that can be applied to an expression.
CovarianceEstimatorFunction
CovarianceEstimatorFunction is an option for generalized linear model fitting functions that specifies the estimator for the parameter covariance matrix.
CovarianceFunction
CovarianceFunction[data,hspec] estimates the covariance function at lags hspec from data.
CovarianceFunction[proc,hspec] represents the covariance function at lags hspec for the random process proc.
CovarianceFunction[proc,s,t] represents the covariance function at times s and t for the random process proc.
CoxianDistribution
CoxianDistribution[{α1,…,αm-1},{λ1,…,λm}] represent an m-phase Coxian distribution with phase probabilities αi and rates λi.
CoxIngersollRossProcess
CoxIngersollRossProcess[μ,σ,θ,x0] represents a Cox–Ingersoll–Ross process with long‐term mean μ, volatility σ, speed of adjustment θ, and initial condition x0.
CoxModel
CoxModel[…] represents the symbolic proportional hazards model obtained from CoxModelFit.
CoxModelFit
CoxModelFit[{e1,…,en}] constructs a model of the baseline hazard h0(t) for events times ei.
CoxModelFit[{{{ξ11,…,ξ1p},…,{ξn 1,…,ξnp}},{e1,…,en}},{f1,…,fm},{x1,…,xp}] constructs a Cox model of the form h0(t) exp(β1 f1+…+βm fm), where the fi depend on the xk.
CramerVonMisesTest
CramerVonMisesTest[data] tests whether data is normally distributed using the Cramér–von Mises test.
CramerVonMisesTest[data,dist] tests whether data is distributed according to dist using the Cramér–von Mises test.
CramerVonMisesTest[data,dist,"property"] returns the value of "property".
CreateArchive
CreateArchive[source] creates a compressed archive in the current directory from source.
CreateArchive[source,path] creates a compressed archive in the directory or file specified by path.
CreateChannel
CreateChannel[] creates a new channel for channel communication, with a generated name.
CreateChannel["path"] creates a channel with the specified path relative to the home area of the currently authenticated user.
CreateChannel[object] creates a channel based on the given ChannelObject specification.
CreateCompilerEnvironment
CreateCompilerEnvironment[] creates a compiler environment that can be used in FunctionCompile and related functions.
CreateDatabin
CreateDatabin[] creates a databin in the Wolfram Data Drop and returns the corresponding Databin object.
CreateDatabin[options] creates a databin with the specified options.
CreateDataStructure
CreateDataStructure["type",arg1,arg2,…] creates a data structure with the specified type.
CreateDirectory
CreateDirectory["dir"] creates a directory with name dir.
CreateDirectory[] creates a directory in the default area for temporary directories on your computer system.
CreateFile
CreateFile["file"] creates a file with name file.
CreateFile[] creates a file in the default area for temporary files on your computer system.
CreateIntermediateDirectories
CreateIntermediateDirectories is an option for CreateDirectory and related functions that specifies whether to create intermediate directories in a directory path specified.
CreateLicenseEntitlement
CreateLicenseEntitlement[settings] creates an on-demand license entitlement using settings.
CreateLicenseEntitlement[] creates an on-demand license entitlement using the default settings.
CreateManagedLibraryExpression
CreateManagedLibraryExpression[mname,f] creates a managed library expression by applying f to a positive integer ID associated with a registered manager with name mname.
CreatePacletArchive
CreatePacletArchive[source] creates a paclet archive file from source.
CreatePacletArchive[source,destdir] creates a paclet archive file from source and places it in destdir.
CreatePermissionsGroup
CreatePermissionsGroup["name"] creates a permissions group with the specified name.
CreatePermissionsGroup["name",{user1,user2,…}] creates a permissions group consisting of the specified initial users.
CreateScheduledTask
CreateScheduledTask[expr] creates a local scheduled task that will repeatedly evaluate expr once per second.
CreateScheduledTask[expr,time] creates a task that will repeatedly evaluate expr every time seconds.
CreateScheduledTask[expr,{time}] creates a task that will evaluate expr once after time seconds.
CreateScheduledTask[expr,{time,count}] creates a task that will try evaluating expr once every time seconds up to count times total.
CreateScheduledTask[expr,timespec,start] creates a task that will evaluate expr according to timespec starting at start time.
CreateSearchIndex
CreateSearchIndex[dir] creates a search index from all files in the directory dir and its subdirectories.
CreateSearchIndex[{source1,source2,…}] creates a search index from all sources sourcei.
CreateSearchIndex[sources,"name"] gives the search index the specified name.
CreateSearchIndex[] creates an empty search index, which can be added to with AddToSearchIndex.
CreateTemporary
CreateTemporary[] creates a temporary file with a unique name in the default temporary directory and returns the name of the file.
CreateUUID
CreateUUID[] creates a random, universally unique UUID string.
CreateUUID["base"] appends a UUID string to the specified base string.
CriterionFunction
CriterionFunction is an option in functions such as ClusterClassify that specifies the criterion to use to select a method.
CriticalityFailureImportance
CriticalityFailureImportance[rdist,t] gives the criticality failure importances for all components in the ReliabilityDistribution rdist at time t.
CriticalityFailureImportance[fdist,t] gives the criticality failure importances for all components in the FailureDistribution fdist at time t.
CriticalitySuccessImportance
CriticalitySuccessImportance[rdist,t] gives the criticality success importances for all components in the ReliabilityDistribution rdist at time t.
CriticalitySuccessImportance[fdist,t] gives the criticality success importances for all components in the FailureDistribution fdist at time t.
CriticalSection
CriticalSection[var,expr] acquires the lock var for parallel computation, evaluates expr, then releases the lock var.
CriticalSection[{var1,var2,…},expr] locks all variables vari simultaneously.
Cross
Cross[a,b] gives the vector cross product of a and b.
CrossEntropyLossLayer
CrossEntropyLossLayer["Index"] represents a net layer that computes the cross-entropy loss by comparing input class probability vectors with indices representing the target class.
CrossEntropyLossLayer["Probabilities"] represents a net layer that computes the cross-entropy loss by comparing input class probability vectors with target class probability vectors.
CrossEntropyLossLayer["Binary"] represents a net layer that computes the binary cross-entropy loss by comparing input probability scalars with target probability scalars, where each probability represents a binary choice.
CrossingCount
CrossingCount[contour,p] gives a count of the number of times a ray starting from the point p crosses the closed curve contour.
CrossingDetect
CrossingDetect[image] gives a binary image in which white pixels correspond to the zero crossings in image.
CrossingDetect[image,delta] treats values in image that are smaller in absolute value than delta as zero.
CrossingDetect[array,…] gives a binary sparse array in which 1 corresponds to zero crossings in array.
CrossingPolygon
CrossingPolygon[{p1,p2,…,pn}] gives a Polygon representing all points for which a ray from the point in any direction in the plane crosses the line segments {p1,p2},…,{pn-1,pn},{pn,p1} an odd number of times.
CrossingPolygon[{{p11,p12,…},{p21,p22,…},…}] gives a Polygon from the line segments {p11,p12},…,{p21,p22},….
Csc
Csc[z] gives the cosecant of z.
Csch
Csch[z] gives the hyperbolic cosecant of z.
CSGRegion
CSGRegion[{reg1,reg2,…}] represents the solid region corresponding to the union of solid regions reg1,reg2,….
CSGRegion["op",{reg1,reg2,…}] represents the solid region corresponding to the Boolean combination "op" of regions reg1,reg2,….
CSGRegion["op",{…,wi[regi],…}] represents the solid region defined by regions regi transformed by a geometric transformation wi.
CSGRegionQ
CSGRegionQ[reg] yields True if the region reg is a valid CSGRegion object and False otherwise.
CSGRegionTree
CSGRegionTree[reg] gives the tree expression representing the CSG region reg.
CTCLossLayer
CTCLossLayer[] represents a net layer that computes the connectionist temporal classification loss by comparing a sequence of class probability vectors with a sequence of indices representing the target classes.
Cube
Cube[] represents a regular cube centered at the origin with unit edge length.
Cube[l] represents a cube with edge length l.
Cube[{θ,ϕ},…] represents a cube rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
Cube[{x,y,z},…] represents a cube centered at {x,y,z}.
CubeRoot
CubeRoot[x] gives the real-valued cube root of x.
Cubics
Cubics is an option for functions that involve solving algebraic equations, that specifies whether explicit forms for solutions to cubic equations should be given.
Cuboid
Cuboid[pmin] represents a unit hypercube with its lower corner at pmin.
Cuboid[pmin,pmax] represents an axis-aligned filled cuboid with lower corner pmin and upper corner pmax.
Cumulant
Cumulant[data,r] gives the rth cumulant κr of data.
Cumulant[data,{r1,…,rm} ] gives the multivariate cumulant of order {r1,…,rm} κr1, …, rm of data.
Cumulant[dist,r] gives the rth cumulant of the distribution dist.
Cumulant[r] represents the rth formal cumulant.
CumulantGeneratingFunction
CumulantGeneratingFunction[dist,t] gives the cumulant-generating function for the distribution dist as a function of the variable t.
CumulantGeneratingFunction[dist,{t1,t2,…}] gives the cumulant-generating function for the multivariate distribution dist as a function of the variables t1, t2, … .
Cup
Cup[x,y,…] displays as x⌣y⌣….
CupCap
CupCap[x,y,…] displays as x≍y≍….
Curl
Curl[{f1,f2},{x1,x2}] gives the curl ∂f2/∂x1-∂f1/∂x2.
Curl[{f1,f2,f3},{x1,x2,x3}] gives the curl ( ∂f3/∂x2-∂f2/∂x3,∂f1/∂x3-∂f3/∂x1,∂f2/∂x1-∂f1/∂x2).
Curl[f,{x1,…,xn}] gives the curl of the n×n×…×n array f with respect to the n-dimensional vector {x1,…,xn}.
Curl[f,x,chart] gives the curl in the coordinates chart.
CurrencyConvert
CurrencyConvert[quantity,target] attempts to convert the specified currency quantity to the specified target currency.
CurrencyConvert[quantity,target,date] converts to the target currency for the historical date specification.
CurrentDate
CurrentDate[gran] gives the current date of the specified granularity type gran.
CurrentDate[date,gran] gives the date of the given granularity that includes the specified date.
CurrentDate[] gives the instant corresponding to the current date.
CurrentImage
CurrentImage[] returns the current image captured from a connected camera.
CurrentImage[n] returns n sequential image frames as a list.
Curry
Curry[f,n] represents an operator form of the function f of n arguments so that Curry[f,n][x1]…[xn] is equivalent to f[x1,…,xn].
Curry[f] represents an operator form of the function f of two arguments so that Curry[f][y][x] is equivalent to f[x,y].
Curry[f,{i1,…,in}] represents an operator form of the function f of n arguments so that Curry[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].
Curry[f,k->{i1,…,in}] represents a k-arguments operator form of the function f of n arguments so that Curry[f,k->{i1,…,in}][x1]…[xk] is equivalent to f[xi1,…,xin], with k≥Max[{i1,…,in}].
CurryApplied
CurryApplied[f,n] represents an operator form of the function f of n arguments so that CurryApplied[f,n][x1]…[xn] is equivalent to f[x1,…,xn].
CurryApplied[n] represents an operator form of CurryApplied that can be applied to a function to represent an operator form with n arguments.
CurryApplied[f,{i1,…,in}] represents an operator form of the function f of n arguments so that CurryApplied[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].
CurryApplied[f,k->{i1,…,in}] represents an operator form that takes k arguments.
CurvatureFlowFilter
CurvatureFlowFilter[image] applies a mean curvature flow filter to image.
CurvatureFlowFilter[image,t] specifies the amount of curvature flow time t to be applied.
CurvatureFlowFilter[image,t,k] applies the curvature flow with a modified conductance term parametrized by k.
CurveClosed
CurveClosed is an option for JoinedCurve that specifies whether individual curve components should be closed curves.
Cyan
Cyan represents the color cyan in graphics or style specifications.
CycleGraph
CycleGraph[n] gives the cycle graph with n vertices Cn.
CycleIndexPolynomial
CycleIndexPolynomial[perm,{x1,…,xn}] constructs the cycle index monomial of the permutation perm in the variables xi.
CycleIndexPolynomial[group,{x1,…,xn}] constructs the cycle index polynomial of group in the variables xi.
Cycles
Cycles[{cyc1,cyc2,…}] represents a permutation with disjoint cycles cyci.
CyclicGroup
CyclicGroup[n] represents the cyclic group of degree n.
Cyclotomic
Cyclotomic[n,x] gives the nth cyclotomic polynomial in x.
Cylinder
Cylinder[{{x1,y1,z1},{x2,y2,z2}},r] represents a cylinder of radius r around the line from (x1,y1,z1) to (x2,y2,z2).
Cylinder[{{x1,y1,z1},{x2,y2,z2}}] represents a cylinder of radius 1.
CylindricalDecomposition
CylindricalDecomposition[expr,{x1,x2,…}] finds a decomposition of the region represented by the statement expr into cylindrical parts whose directions correspond to the successive xi.
CylindricalDecomposition[expr,{x1,x2,…},op] finds a decomposition of the result of applying the topological operation op to the region represented by the statement expr.
CylindricalDecomposition[expr,{x1,x2,…},"Function"] represents the result as CylindricalDecompositionFunction[…][x1,x2,…] that can be efficiently used in further computation.
CylindricalDecompositionFunction
CylindricalDecompositionFunction[data][x1,x2,…] represents a cylindrical algebraic formula in x1,x2,….
D
D[f,x] gives the partial derivative ∂f/∂x.
D[f,{x,n}] gives the multiple derivative ∂nf/∂xn.
D[f,x,y,…] gives the partial derivative ⋯ (∂/∂y)(∂/∂x) f.
D[f,{x,n},{y,m},…] gives the multiple partial derivative ⋯ (∂m/∂ym)(∂n/∂xn) f.
D[f,{{x1,x2,…}}] for a scalar f gives the vector derivative (∂f/∂x1,∂f/∂x2,…).
D[f,{array}] gives an array derivative.
DagumDistribution
DagumDistribution[p,a,b] represents a Dagum distribution with shape parameters p and a and scale parameter b.
DamData
DamData[entity,property] gives the value of the specified property for the dam entity.
DamData[{entity1,entity2,…},property] gives a list of property values for the specified dam entities.
DamData[entity,property,annotation] gives the specified annotation associated with the given property.
DamerauLevenshteinDistance
DamerauLevenshteinDistance[u,v] gives the Damerau–Levenshtein distance between strings or vectors u and v.
DamerauLevenshteinDistance[u,v] gives the Damerau–Levenshtein distance between strings, vectors or biomolecular sequences u and v.
DampingFactor
DampingFactor is an option for FindRoot, which can be used to control convergence behavior. DampingFactor -> n uses a damping factor of n in Newton's method.
Darker
Darker[color] represents a darker version of the specified color.
Darker[color,f] represents a version of the specified color darkened by a fraction f.
Darker[image,…] gives a darker version of an image.
Darker[video,…] gives a version of a video with darker frames.
Dashed
Dashed is a graphics directive specifying that lines that follow should be drawn dashed.
Dashing
Dashing[{r1,r2,…}] is a two-dimensional graphics directive specifying that lines that follow are to be drawn dashed, with successive segments of lengths r1, r2, … (repeated cyclically). The ri are given as a fraction of the total width of the graph.
Dashing[r] is equivalent to Dashing[{r,r}].
Dashing[{r1,r2,…},offset] offsets the dashes by offset.
Dashing[{r1,r2,…},offset,capform] sets the CapForm for individual dashes to capform.
DatabaseConnect
DatabaseConnect[db] activates a connection to the database db.
DatabaseDisconnect
DatabaseDisconnect[db] deactivates a connection to the database db.
DatabaseReference
DatabaseReference[File["filename"]] represents a reference to a local file-based SQL database.
DatabaseReference[URL["url"]] represents a reference to a server-based SQL database.
DatabaseReference[assoc] represents a fully specified reference to any SQL database.
Databin
Databin["id"] represents a databin in the Wolfram Data Drop.
Databin["id",n] represents the first n entries in a databin.
Databin["id",-n] represents the most recent n entries in a databin.
Databin["id",{m,n}] represents entries m through n in a databin, with negative numbers counting from the end.
Databin["id",{m,n,s}] represents entries m through n with step s.
Databin["id",time] represents entries going back for the quantity of time specified by time.
Databin["id",date] represents the entries in a databin from the specified date to now.
Databin["id",{date1,date2}] represents the entries in a databin from date1 to date2.
Databin["id",range,{key1,key2,…}] represents only elements with keys keyi within each entry in a databin.
DatabinAdd
DatabinAdd[bin,data] adds the specified data to a databin.
DatabinRemove
DatabinRemove[bin,i] removes the ithentry from a databin.
DatabinRemove[bin,uuid] removes the entry with the specified UUID from a databin.
DatabinRemove[bin,{i,j}] removes the span of entries with indices from i through j.
Databins
Databins[] gives a list of databins associated with the currently connected user.
DatabinSubmit
DatabinSubmit[bin,data] submits the specified data to be added to the databin bin asynchronously.
DatabinUpload
DatabinUpload[bin,{entry1,entry2,…}] bulk uploads all the entries entryi to a databin.
DatabinUpload[bin,EventSeries[…]] bulk uploads all entries in an event series to a databin.
DataDistribution
DataDistribution[ddist,…] represents a probability distribution of type ddist, estimated from a set of data.
DataRange
DataRange is an option for functions such as ListPlot and ListDensityPlot that specifies what range of actual coordinates the data should be assumed to occupy.
DataReversed
DataReversed is an option for ArrayPlot and related functions that specifies whether data should be plotted in reverse order.
Dataset
Dataset[data] represents a structured dataset based on a hierarchy of lists and associations.
DatasetTheme
DatasetTheme is an option for Dataset that specifies an overall theme for a dataset and its elements.
DataStructure
DataStructure["type",data] represents a data structure.
DataStructureQ
DataStructureQ[ds] yields True if ds is a valid data structure and False otherwise.
DataStructureQ[ds,type] yields True if ds is a valid data structure of the specified type and False otherwise.
Date
Date[] gives the current local date and time in the form {year,month,day,hour,minute,second}.
DateBounds
DateBounds[{date1,date2,…}] gives the earliest and latest of the datei.
DateBounds[tseries] gives the first and last dates in the time series tseries.
DateBounds[bin] gives the first and last time stamps in the databin bin.
DateBounds[interval] gives the start and end dates of the date interval interval.
DateBounds[interval,gran] gives the endpoints of interval in the specified granularity gran.
Dated
Dated[obj,year] represents the object obj associated with a particular year.
Dated[obj,date] represents the object obj associated with a date.
Dated[obj,All] represents the object obj for all dates where information is available about it.
DateDifference
DateDifference[date1,date2] gives the number of days from date1 to date2.
DateDifference[date1,date2,"unit"] gives the difference between date1 and date2 in the specified unit.
DateDifference[date1,date2,{"unit1","unit2",…}] gives the difference as a list with elements corresponding to the successive "uniti".
DatedUnit
DatedUnit[unit,date] represents the specified unit at a specific date.
DateFunction
DateFunction is an option for DateListPlot and TemporalData that specifies how dates given as input should be interpreted.
DateHistogram
DateHistogram[{date1,date2,…}] plots a histogram of the dates datei.
DateHistogram[{date1,date2,…},bspec] plots a histogram with bin width specification bspec.
DateHistogram[{date1,date2,…},bspec,hspec] plots a histogram with bin heights computed according to the specification hspec.
DateHistogram[{data1,data2,…}] plots histograms for multiple datasets datai.
DateInterval
DateInterval[{start,end}] represents the continuous interval of time between start and end.
DateInterval[{start,end},gran] represents an interval of dates with calendar granularity gran.
DateInterval[{{start1,end1},{start2,end2},…}] represents the union of intervals start1 to end1, start2 to end2, ….
DateInterval[gdate] gives the date interval from the initial to final instants of the granular date object gdate.
DateList
DateList[] gives the current local date and time in the form {year,month,day,hour,minute,second}.
DateList[date] gives a date list corresponding to the given date specification.
DateListLogPlot
DateListLogPlot[{{date1,y1},{date2,y2},…}] makes a log plot with values yi at a sequence of dates.
DateListLogPlot[{y1,y2,…},datespec] makes a log plot with dates at equal intervals specified by datespec.
DateListLogPlot[tseries] plots the time series tseries.
DateListLogPlot[{data1,data2,…}] plots data from all the datai.
DateListLogPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.
DateListPlot
DateListPlot[{{date1,y1},{date2,y2},…,{daten,yn}}] plots points with values yi at a sequence of dates.
DateListPlot[{y1,y2,…,yn},datespec] plots points with dates at equal intervals specified by datespec.
DateListPlot[tseries] plots the time series tseries.
DateListPlot[{data1,data2,…}] plots data from all the datai.
DateListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.
DateListStepPlot
DateListStepPlot[{{date1,y1},{date2,y2},…}] plots the values yi in steps at a sequence of dates.
DateListStepPlot[{y1,y2,…},datespec] plots the values yi in steps with dates at equal intervals specified by datespec.
DateListStepPlot[tseries] plots the time series tseries.
DateListStepPlot[{data1,data2,…}] plots data from all the datai.
DateListStepPlot[…,step] plots using steps specified by step.
DateListStepPlot[{…,w[datai],…}] plots data datai with features defined by the symbolic wrapper w.
DateObject
DateObject[] gives the current local date.
DateObject[date] gives a date object corresponding to the given date specification.
DateObject[rdate,gran] gives the date object of calendar granularity gran that includes the reference date rdate.
DateObjectQ
DateObjectQ[expr] gives True if expr is a DateObject with valid arguments, and False otherwise.
DateOverlapsQ
DateOverlapsQ[date1,date2] returns True if the calendar dates date1 and date2 overlap, and False otherwise.
DatePattern
DatePattern[{"e1","e2",…}] represents the characters of a date with elements of type "ei" in StringExpression.
DatePattern[{"e1","e2",…},sep] allows separators that match the string expression sep.
DatePlus
DatePlus[date,n] gives the date n days after date.
DatePlus[date,{n,step}] gives the date n calendar steps after date.
DatePlus[date,{{n1,step1},{n2,step2},…}] gives a date offset by ni steps of each specified size.
DatePlus[n] gives the date n days after the current date.
DatePlus[offset] gives the date with the specified offset from the current date.
DateRange
DateRange[date1,date2] gives all dates in the range from date1 to date2.
DateRange[date1,date2,increment] gives the dates in the range from date1 to date2 that are increment apart.
DateReduction
DateReduction is an option for DateHistogram that specifies the length for cyclic periods of time.
DateScale
DateScale[] represents the canonical mapping of continuous dates and times to a quantitative scale.
DateSelect
DateSelect[list,crit] picks out all dates datei of a list for which crit[datei] is True.
DateSelect[int,crit] returns all dates within the DateInterval int for which crit[datei] is True.
DateSelect[crit] represents an operator form of DateSelect that can be applied to an expression.
DateString
DateString[] gives a string representing the complete current local date and time.
DateString[date] gives a string corresponding to the given date specification.
DateString[{"elem1","elem2",…}] concatenates the specified elements in the order given.
DateString[date,fmt] gives elements specified by the date format fmt for the date or time specification date.
DateTicksFormat
DateTicksFormat is an option for DateListPlot which specifies how date tick labels should be formatted.
DateValue
DateValue["elem"] gives the specified element of the current date and time.
DateValue[{elem1,elem2,…}] gives a list of the specified elements of the current date and time.
DateValue[date,elem] gives the specified element of the specified date.
DateValue[date,elem,form] gives the result in the specified form.
DateWithinQ
DateWithinQ[date1,date2] returns True if the calendar date date2 is entirely contained within date1, and False otherwise.
DaubechiesWavelet
DaubechiesWavelet[] represents a Daubechies wavelet of order 2.
DaubechiesWavelet[n] represents a Daubechies wavelet of order n.
DavisDistribution
DavisDistribution[b,n,μ] represents a Davis distribution with scale parameter b, shape parameter n, and location parameter μ.
DawsonF
DawsonF[z] gives the Dawson integral F(z).
DayCount
DayCount[date1,date2] gives the number of days from date1 to date2.
DayCount[date1,date2,daytype] gives the number of days of the specified daytype from date1 to date2.
DayCountConvention
DayCountConvention is an option that specifies the day count convention used by DateDifference.
DayHemisphere
DayHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth that is currently in daylight.
DayHemisphere[datespec] represents the daylight half of the Earth for the specified date.
DaylightQ
DaylightQ[] gives True if it is currently daylight from the user's location.
DaylightQ[datespec] gives True if it is daylight from the user's location on the specified datespec.
DaylightQ[locationspec] gives True if it is currently daylight from the specified locationspec.
DaylightQ[locationspec,datespec] gives True if it is daylight from the specified locationspec on the specified datespec.
DaylightQ[{{location1,date1},{location2,date2},…}] gives True if it is daylight from the specified locations and dates.
DaylightQ[locationspec,datespec,inclusionspec] gives True if it is daylight from the specified locationspec on the specified datespec taking inclusionspec into account.
DayMatchQ
DayMatchQ[date,daytype] returns True if the date matches the daytype specification and returns False otherwise.
DayName
DayName[] gives the current day of the week.
DayName[date] gives the day of the week for the given date.
DayNightTerminator
DayNightTerminator[] is a one-dimensional GeoGraphics primitive that represents the separation line between the halves of the Earth currently in daytime and nighttime.
DayNightTerminator[datespec] represents the separation line between day and night for the specified date.
DayPlus
DayPlus[date,n] gives the date n days away from date.
DayPlus[date,n,daytype] gives the date that is n days of daytype away from date.
DayRange
DayRange[date1,date2] gives the dates in the range from date1 to date2.
DayRange[date1,date2,daytype] gives the dates in the range from date1 to date2 that are of the specified daytype.
DayRound
DayRound[date,daytype] rounds date to the nearest day of daytype, using the next-day rounding convention.
DayRound[date,daytype,rounding] rounds date to the nearest day of daytype, using rounding.
DeBruijnGraph
DeBruijnGraph[m,n] gives the n-dimensional De Bruijn graph with m symbols.
DeBruijnGraph[m,n,type] gives the De Bruijn graph with connectivity given by type.
DeBruijnSequence
DeBruijnSequence[list,n] gives a de Bruijn sequence on the elements in list taken n at a time.
DeBruijnSequence[k,n] gives a de Bruijn sequence on the elements 0,…,k-1.
DeBruijnSequence["string",n] gives a de Bruijn sequence on the characters in "string".
Decapitalize
Decapitalize[string] yields a string in which the first character has been made lowercase.
DecimalForm
DecimalForm[expr] prints with approximate real numbers in expr always given in decimal form, without scientific notation.
DecimalForm[expr,n] prints with approximate real numbers given in decimal form to n-digit precision.
DecimalForm[expr,{n,f}] prints with approximate real numbers having n digits, with f digits to the right of the decimal point.
DeclarePackage
DeclarePackage["context`",{"name1","name2",…}] declares that Needs["context`"] should automatically be executed if a symbol with any of the specified names is ever used.
Decompose
Decompose[poly,x] decomposes a polynomial, if possible, into a composition of simpler polynomials.
DeconvolutionLayer
DeconvolutionLayer[n,sz] represents a trainable deconvolutional net layer having n output channels and using kernels of size sz to compute the deconvolution.
DeconvolutionLayer[n,{s}] represents a layer performing one-dimensional deconvolutions with kernels of size s.
DeconvolutionLayer[n,{h,w}] represents a layer performing two-dimensional deconvolutions with kernels of size h×w.
DeconvolutionLayer[n,kernel,opts] includes options for initial kernels and other parameters.
Decrement
x-- decreases the value of x by 1, returning the old value of x.
Decrypt
Decrypt["password",enc] attempts to decrypt the encrypted object enc using the specified password.
Decrypt[keyspec,enc] attempts to decrypt using the cryptographic key specification keyspec.
Decrypt[obj] interactively requests a password with which to try to decrypt obj.
DecryptFile
DecryptFile["password",file] generates a decrypted version of a file, using the specified password.
DecryptFile["password",source,target] generates a decrypted version of source, putting the result in target.
DecryptFile[keyspec,source,…] decrypts using the cryptographic key specification keyspec.
DedekindEta
DedekindEta[τ] gives the Dedekind eta modular elliptic function η(τ).
DeepSpaceProbeData
DeepSpaceProbeData[entity,property] gives the value of the specified property for the deep space probe entity.
DeepSpaceProbeData[{entity1,entity2,…},property] gives a list of property values for the specified deep space probe entities.
DeepSpaceProbeData[entity,property,annotation] gives the specified annotation associated with the given property.
DefaultAxesStyle
DefaultAxesStyle is a low-level option for graphics functions that specifies the default style to use in displaying axes and axes-like constructs.
DefaultColor
DefaultColor is an option for graphics functions that specifies the default color to use for lines, points, etc.
DefaultDuration
DefaultDuration is an option to Animate and related functions that specifies the default total duration of the animation in seconds.
DefaultElement
DefaultElement is an option for Grid and related constructs which specifies what to insert when a new element is interactively created.
DefaultFaceGridsStyle
DefaultFaceGridsStyle is a low-level option for 3D graphics functions that specifies the default style to use in rendering face grids.
DefaultFieldHintStyle
DefaultFieldHintStyle is a low-level option for InputField that specifies the default style to use for displaying the field hint.
DefaultFontProperties
DefaultFontProperties is a global option that allows overriding properties of specified font families.
DefaultFrameStyle
DefaultFrameStyle is a low-level option for graphics and related constructs that specifies the default style to use in displaying their frames.
DefaultFrameTicksStyle
DefaultFrameTicksStyle is a low-level option for 2D graphics functions that specifies the default style to use in rendering frame ticks.
DefaultGridLinesStyle
DefaultGridLinesStyle is a low-level option for 2D graphics functions that specifies the default style to use in rendering grid lines.
DefaultNaturalLanguage
DefaultNaturalLanguage is an option for character selections that specifies the language used when checking the spelling of a word in a human natural language selection.
DefaultOptions
DefaultOptions is a style option that allows default options to be specified for particular formatting and related constructs.
DefaultPrintPrecision
DefaultPrintPrecision is an option for NumberForm, DecimalForm and related functions that specifies the default number of digits of precision with which to print machine numbers.
DefaultStyleDefinitions
DefaultStyleDefinitions is a global option that specifies the default stylesheet for all new notebooks.
DefaultTicksStyle
DefaultTicksStyle is a low-level option for graphics functions that specifies the default style to use in rendering ticks.
DefaultTooltipStyle
DefaultTooltipStyle is a low-level option for tooltips that specifies the default style to use in displaying their elements.
DefaultValues
DefaultValues[f] gives a list of transformation rules corresponding to default values of f.
DefaultValues["symbol"] gives a list of transformation rules corresponding to all default values defined for the symbol named "symbol" if it exists.
Defer
Defer[expr] yields an object that displays as the unevaluated form of expr, but that is evaluated if it is explicitly given as Wolfram Language input.
DefineInputStreamMethod
DefineInputStreamMethod["name",{fname1->function1,fname2->function2,… }] defines a custom input stream method with the specified name, allowing the Wolfram Language to call the stream functions fnamei for opening and reading from an input stream.
DefineOutputStreamMethod
DefineOutputStreamMethod["name",{fname1->function1,fname2->function2,… }] defines a custom output stream method with the specified name, allowing the Wolfram Language to call the stream functions for opening and writing to an output stream.
DefineResourceFunction
DefineResourceFunction[f] defines a resource function that can be applied to arguments to give the same result as f[…].
DefineResourceFunction[f,name] uses name as the name of the resource function.
Definition
Definition[symbol] prints as the definitions given for a symbol.
Definition["symbol"] prints as the definitions given for the symbol named "symbol" if it exists.
Definition[patt] prints as the definitions given for the symbols whose names textually match the arbitrary string pattern patt.
Definition[{spec1,spec2,…}] prints as the definitions given for the symbols that are equal to or or whose names match any of the speci.
Degree
Degree gives the number of radians in one degree. It has a numerical value of π/180.
DegreeCentrality
DegreeCentrality[g] gives a list of vertex degrees for the vertices in the underlying simple graph of g.
DegreeCentrality[g,"In"] gives a list of vertex in-degrees.
DegreeCentrality[g,"Out"] gives a list of vertex out-degrees.
DegreeCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
DegreeGraphDistribution
DegreeGraphDistribution[dlist] represents a degree graph distribution with vertex degree dlist.
DEigensystem
DEigensystem[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues and eigenfunctions for the linear differential operator ℒ over the region Ω.
DEigensystem[eqns,u,t,{x,y,…}∈Ω,n] gives the eigenvalues and eigenfunctions for solutions u of the time-dependent differential equations eqns.
DEigenvalues
DEigenvalues[ℒ[u[x,y,…],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues for the linear differential operator ℒ over the region Ω.
DEigenvalues[eqns,u,t,{x,y,…}∈Ω,n] gives the eigenvalues for solutions u of the time-dependent differential equations eqns.
Del
Del[x] displays as ∇x.
DelaunayMesh
DelaunayMesh[{p1,p2,…}] gives a MeshRegion representing the Delaunay mesh from the points p1, p2, ….
Delayed
Delayed[expr] represents an expression whose evaluation is delayed until its value is externally requested.
Delayed[expr,fmt] specifies that the result from evaluating expr should be given in format fmt.
Delayed[expr,{fmt,rform}] specifies that the result should be given as a response of the form rform.
Delete
Delete[expr,n] deletes the element at position n in expr. If n is negative, the position is counted from the end.
Delete[expr,{i,j,…}] deletes the part at position {i,j,…}.
Delete[expr,{{i1,j1,…},{i2,j2,…},…}] deletes parts at several positions.
Delete[pos] represents an operator form of Delete that can be applied to an expression.
DeleteAnomalies
DeleteAnomalies[{example1,example2,…}] gives a list in which examplei that are considered anomalous have been dropped.
DeleteAnomalies[fun,data] drops anomalies in data using the given AnomalyDetectorFunction[…] or LearnedDistribution[…].
DeleteBorderComponents
DeleteBorderComponents[image] replaces connected components adjacent to the border in a binary image image with background pixels.
DeleteBorderComponents[m] replaces components adjacent to the border in a label matrix m with 0.
DeleteCases
DeleteCases[expr,pattern] removes all elements of expr that match pattern.
DeleteCases[expr,pattern,levelspec] removes all parts of expr on levels specified by levelspec that match pattern.
DeleteCases[expr,pattern,levelspec,n] removes the first n parts of expr that match pattern.
DeleteCases[pattern] represents an operator form of DeleteCases that can be applied to an expression.
DeleteChannel
DeleteChannel[channel] deletes the specified channel from the channel broker server.
DeleteChannel[{channel1,channel2,…}] deletes all the channeli.
DeleteChannel[All] deletes all channels owned by the currently authenticated user.
DeleteContents
DeleteContents is an option for DeleteDirectory that specifies whether the contents of directories should automatically be deleted.
DeleteDirectory
DeleteDirectory["dir"] deletes the specified directory.
DeleteDuplicates
DeleteDuplicates[data] deletes all duplicates from data.
DeleteDuplicates[data,test] applies test to pairs of elements to determine whether they should be considered duplicates.
DeleteDuplicatesBy
DeleteDuplicatesBy[data,f] deletes those ei in data that yield duplicates in the list {f[e1],f[e2],…}.
DeleteDuplicatesBy[f] represents an operator form of DeleteDuplicatesBy that can be applied to an expression.
DeleteFile
DeleteFile["file"] deletes a file.
DeleteFile[{"file1","file2",…}] deletes a list of files.
DeleteMissing
DeleteMissing[list] drops elements with head Missing from a list.
DeleteMissing[assoc] drops elements whose values have head Missing from the association assoc.
DeleteMissing[expr,n] applies DeleteMissing to any lists or associations that occur within the first n levels of expr.
DeleteMissing[expr,n,d] considers an element at level n to be missing if Missing occurs within the first d levels of the element.
DeleteObject
DeleteObject[obj] deletes the object obj.
DeleteObject[{obj1,obj2,…}] deletes all the obji.
DeletePermissionsKey
DeletePermissionsKey[key] deletes a permissions key, rendering it invalid.
DeletePermissionsKey[{key1,key2,…}] deletes several permissions keys.
DeleteSearchIndex
DeleteSearchIndex[obj] deletes the search index represented by the search index object obj.
DeleteSearchIndex["name"] deletes the search index with the specified name in the SearchIndices[] list.
DeleteSmallComponents
DeleteSmallComponents[image] replaces small connected components in a binary image image with background pixels.
DeleteSmallComponents[m] replaces positive integers in a label matrix m with 0 if their tally is small.
DeleteSmallComponents[…,n] replaces components consisting of n or fewer elements.
DeleteStopwords
DeleteStopwords[list] deletes stopwords from a list of words.
DeleteStopwords["string"] deletes stopwords from a string.
DeleteStopwords[{string1,string2,…}] deletes stopwords from a list of strings.
DelimitedSequence
DelimitedSequence[form] represents a delimited sequence of elements of the specified form in Interpreter and related functions.
DelimitedSequence[form,sep] assumes a separator that matches sep.
DelimitedSequence[form,{left,sep,right}] assumes left and right delimiters matching left and right, respectively.
Delimiter
Delimiter represents a delimiter to be displayed in objects such as PopupMenu, Manipulate, and FormObject.
DelimiterMatching
DelimiterMatching is an option for selections that specifies whether an opening delimiter will match only its respective closing delimiter or any closing delimiter.
Delimiters
Delimiters is an option to various functions that specifies what delimiters to use or look for.
DeliveryFunction
DeliveryFunction is an option that specifies how material such as documents generated by DocumentGenerator should be delivered.
Dendrogram
Dendrogram[{e1,e2,…}] constructs a dendrogram from the hierarchical clustering of the elements e1, e2, ….
Dendrogram[{e1->v1,e2->v2,…}] represents ei with vi in the constructed dendrogram.
Dendrogram[{e1,e2,…}->{v1,v2,…}] represents ei with vi in the constructed dendrogram.
Dendrogram[<|label1->e1,label2->e2,…|>] represents ei using labels labeli in the constructed dendrogram.
Dendrogram[data,orientation] constructs an oriented dendrogram according to orientation.
Dendrogram[tree] constructs the dendrogram corresponding to weighted tree tree.
Denominator
Denominator[expr] gives the denominator of expr.
DensityGraphics
DensityGraphics[array] is a representation of a density plot.
DensityHistogram
DensityHistogram[{{x1,y1},{x2,y2},…}] plots a density histogram of the values {xi,yi}.
DensityHistogram[{{x1,y1},{x2,y2},…},bspec] plots a density histogram with bins specified by bspec.
DensityHistogram[{{x1,y1},{x2,y2},…},bspec,hspec] plots a density histogram with bin densities computed according to the specification hspec.
DensityPlot
DensityPlot[f,{x,xmin,xmax},{y,ymin,ymax}] makes a density plot of f as a function of x and y.
DensityPlot[f,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
DensityPlot3D
DensityPlot3D[f,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] makes a density plot of f as a function of x, y, and z.
DensityPlot3D[f,{x,y,z}∈reg] takes the variables to be in the geometric region reg.
DependentVariables
DependentVariables is an option for NDSolve and other functions that specifies the list of all objects that should be considered as dependent variables in equations that have been supplied.
Depth
Depth[expr] gives the maximum number of indices needed to specify any part of expr, plus 1.
DepthFirstScan
DepthFirstScan[g,s,{event1->f1,event2->f2,…}] performs a depth-first scan of the graph g starting at the vertex s and evaluates fi whenever "eventi" occurs.
DepthFirstScan[g,{event1->f1,event2->f2,…}] performs a depth-first scan of the whole graph g.
DepthFirstScan[{v->w,…},…] uses rules v->w to specify the graph g.
Derivative
f' represents the derivative of a function f of one argument.
Derivative[n1,n2,…][f] is the general form, representing a function obtained from f by differentiating n1 times with respect to the first argument, n2 times with respect to the second argument, and so on.
DerivativeFilter
DerivativeFilter[data,{n1,n2,…}] computes the nith derivative of data at level i.
DerivativeFilter[data,{n1,n2,…},σ] computes the derivative at a Gaussian scale of standard deviation σ.
DerivativeFilter[data,{der1,der2,…},…] computes several derivatives der1, der2, ….
DerivativePDETerm
DerivativePDETerm[vars,γ] represents a load derivative term ∇{x1,…,xn}·(γ) with load derivative coefficient γ and model variables vars.
DerivativePDETerm[vars,γ,pars] uses model parameters pars.
DerivedKey
DerivedKey[assoc] represents a derived key generated by GenerateDerivedKey.
DescriptorStateSpace
DescriptorStateSpace is an option to StateSpaceModel and StateSpaceTransform that specifies whether to use descriptor or standard representation.
DesignMatrix
DesignMatrix[{{x11,x12,…,y1},{x21,x22,…,y2},…},{f1,f2,…},{x1,x2,…}] constructs the design matrix for the linear model β0+β1 f1+β2 f2+….
Det
Det[m] gives the determinant of the square matrix m.
DeviceClose
DeviceClose[device] closes the connection to a device and frees related resources.
DeviceConfigure
DeviceConfigure[device,config] configures the specified device according to config.
DeviceExecute
DeviceExecute[device,"command"] executes the specified command on a device.
DeviceExecute[device,"command",params] executes the command with the parameters params.
DeviceExecuteAsynchronous
DeviceExecuteAsynchronous[device,"command",fun] initiates asynchronous execution of the specified command on a device, calling the handler function fun when an event occurs.
DeviceExecuteAsynchronous[device,"command",params,fun] executes the command with the parameters params.
DeviceObject
DeviceObject[…] represents a device that can be accessed in a Wolfram Language session.
DeviceOpen
DeviceOpen["devclass"] opens a connection to the first available device in the class specified by "devclass".
DeviceOpen["devclass",spec] opens a connection to the particular device defined by spec.
DeviceOpen[device] opens a connection to an existing device specified by a DeviceObject.
DeviceRead
DeviceRead[devobj] reads a single default item from the open device corresponding to the specified DeviceObject.
DeviceRead["devclass"] reads from the default device in the class "devclass".
DeviceRead[device,param] reads the parameter param from the specified device.
DeviceRead[device,{param1,param2,…}] reads the list of parameters parami from the specified device.
DeviceReadBuffer
DeviceReadBuffer[device] reads the complete contents of the buffer on a device.
DeviceReadBuffer[device,n] reads n elements from the buffer.
DeviceReadBuffer[device,crit] reads elements from the buffer until the device-specific criterion crit is met.
DeviceReadBuffer[device,crit,param] reads elements associated with the parameter param.
DeviceReadBuffer[device,crit,{param1,param2,…}] reads elements associated with the parami.
DeviceReadLatest
DeviceReadLatest[device] returns the most recently collected default item from a device.
DeviceReadLatest[device,n] returns a list of the n most recently collected items.
DeviceReadLatest[device,n,param] returns the n most recently collected values of param.
DeviceReadLatest[device,n,{param1,param2,…}] returns a list of the most recently collected values of the parami.
DeviceReadList
DeviceReadList[device,n] reads from the specified device n times, returning a list of the results.
DeviceReadList[device,n,param] reads the parameter param.
DeviceReadList[device,n,{param1,param2,…}] reads the list of parameters parami.
DeviceReadTimeSeries
DeviceReadTimeSeries[device,{t,dt}] repeatedly reads default items from the specified device at interval dt for a total time t, returning a time series of the resulting values.
DeviceReadTimeSeries[device,{t,dt},param] repeatedly reads the parameter param and returns a time series of its values.
DeviceReadTimeSeries[device,{t,dt},{param1,param2,…}] repeatedly reads the parami and returns a time series of their values.
Devices
Devices[] gives a list of registered devices on a particular system.
Devices[form] gives a list of devices in classes whose names match the string pattern form.
Devices[{form1,form2,…}] gives a list of devices in classes whose names match any of the formi.
DeviceStreams
DeviceStreams[device] gives a list of all open streams associated with a device.
DeviceStreams[device,patt] gives a list of streams whose names match the string pattern patt.
DeviceStreams[device,{patt1,patt2,…}] gives a list of streams whose names match any of the patti.
DeviceWrite
DeviceWrite[device,val] writes the value val to the specified device.
DeviceWrite[device,{val1,val2,…}] writes the sequence of values vali to the specified device.
DeviceWrite[device,param->val] writes val as the value of the parameter param.
DeviceWrite[device,{param1->val1,param2->val2,…}] writes values of several parameters.
DeviceWriteBuffer
DeviceWriteBuffer[device,vals] fills the buffer on a device with the values vals.
DeviceWriteBuffer[device,param->vals] fills the buffer associated with the parameter param with the values vals.
DeviceWriteBuffer[device,{param1->vals1,param2->vals2,…}] fills the buffers associated with the parami with the corresponding values valsi .
DGaussianWavelet
DGaussianWavelet[] represents a derivative of Gaussian wavelet of derivative order 2.
DGaussianWavelet[n] represents a derivative of Gaussian wavelet of derivative order n.
DiagonalizableMatrixQ
DiagonalizableMatrixQ[m] gives True if m is diagonalizable, and False otherwise.
Dialog
Dialog[] initiates a dialog.
Dialog[expr] initiates a dialog with expr as the current value of %.
Diamond
Diamond[x,y,…] displays as x⋄y⋄….
DiceDissimilarity
DiceDissimilarity[x,y] gives the Dice dissimilarity between Boolean vectors x and y.
DictionaryLookup
DictionaryLookup[patt] finds all words in an English dictionary that match the string pattern patt.
DictionaryLookup[patt,n] gives only the first n words found.
DictionaryLookup[{"lang",patt}] finds words in the language specified by lang.
DictionaryWordQ
DictionaryWordQ["word"] tests whether "word" is a recognized dictionary word.
DifferenceQuotient
DifferenceQuotient[f,{x,h}] gives the difference quotient (f(x+h)-f(x))/h.
DifferenceQuotient[f,{x,n,h}] gives a multiple difference quotient with step h.
DifferenceQuotient[f,{x1,n1,h1},{x2,n2,h2},…] computes the partial difference quotient with respect to x1,x2,….
DifferenceRoot
DifferenceRoot[lde][k] gives the holonomic sequence h(k), specified by the linear difference equation lde[h,k].
DifferenceRoot[lde] represents a pure holonomic sequence h.
DifferenceRootReduce
DifferenceRootReduce[expr,n] attempts to reduce expr to a single DifferenceRoot object as a function of n.
DifferentialD
DifferentialD[x] displays as x.
DifferentialRoot
DifferentialRoot[lde][x] gives the holonomic function h(x), specified by the linear differential equation lde[h,x].
DifferentialRoot[lde] represents a pure holonomic function h.
DifferentialRootReduce
DifferentialRootReduce[expr,x] attempts to reduce expr to a single DifferentialRoot object as a function of x.
DifferentialRootReduce[expr,{x,x0}] takes the initial conditions to be specified at x=x0.
DifferentiatorFilter
DifferentiatorFilter[data,ωc] applies a differentiator filter with a cutoff frequency ωc to an array of data.
DifferentiatorFilter[data,ωc,n] uses a filter kernel of length n.
DifferentiatorFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.
DiffusionPDETerm
DiffusionPDETerm[vars] represents a diffusion term ∇{x1,…,xn}·(-∇{x1,…,xn}u) with model variables vars.
DiffusionPDETerm[vars,c] represents a diffusion term ∇{x1,…,xn}·(-c∇{x1,…,xn}u) with diffusion coefficient c.
DiffusionPDETerm[vars,c,pars] uses model parameters pars.
DigitalSignature
DigitalSignature[assoc] represents a digital signature object.
DigitBlock
DigitBlock is an option for NumberForm and related functions that specifies the maximum length of blocks of digits between breaks.
DigitCharacter
DigitCharacter represents a digit character 0–9 in StringExpression.
DigitCount
DigitCount[n,b,d] gives the number of d digits in the base-b representation of n.
DigitCount[n,b,d,len] gives the number of d digits in the base-b representation of the last len digits of n.
DigitCount[n,b] gives a list of the numbers of 1, 2, …, b-1, 0 digits in the base-b representation of n.
DigitCount[n] gives a list of the numbers of 1, 2, …, 9, 0 digits in the base-10 representation of n.
DigitQ
DigitQ[string] yields True if all the characters in the string are digits in the range 0 through 9, and yields False otherwise.
DihedralAngle
DihedralAngle[{p1,p2},{v,w}] gives the angle between two half-planes bounded by the line through p1 and p2 and extended in the direction v and w.
DihedralGroup
DihedralGroup[n] represents the dihedral group of order 2n.
Dilation
Dilation[image,ker] gives the morphological dilation of image with respect to the structuring element ker.
Dilation[image,r] gives the dilation with respect to a range-r square.
Dilation[data,…] applies dilation to an array of data.
DimensionalCombinations
DimensionalCombinations[{pq1,pq2,…}] returns the possible combinations of the list of physical quantities pqi that are dimensionless.
DimensionalCombinations[{pq1,pq2,…},dim] returns the possible combinations of the list of physical quantities pqi that match the dimensions of physical quantity dim.
DimensionalMeshComponents
DimensionalMeshComponents[mr] gives a list {r0,r1,…} of regions such that rd has dimension d for a mesh region mr.
DimensionReduce
DimensionReduce[{example1,example2,…}] projects the examples examplei to a lower-dimensional approximating manifold.
DimensionReduce[examples,n] projects onto an approximating manifold in n-dimensional space.
DimensionReducerFunction
DimensionReducerFunction[…] represents a function generated by DimensionReduction that projects data onto a lower-dimensional approximating manifold.
DimensionReduction
DimensionReduction[{example1,example2,…}] generates a DimensionReducerFunction[…] that projects from the space defined by the examplei to a lower-dimensional approximating manifold.
DimensionReduction[examples,n] generates a DimensionReducerFunction[…] for an n-dimensional approximating manifold.
DimensionReduction[examples,n,props] generates the specified properties of the dimensionality reduction.
Dimensions
Dimensions[expr] gives a list of the dimensions of expr.
Dimensions[expr,n] gives a list of the dimensions of expr down to level n.
DiracComb
DiracComb[x] represents the Dirac comb function (x) giving a delta function at every integer point.
DiracComb[x1,x2,…] represents the multidimensional Dirac comb function (x1,x2,…).
DiracDelta
DiracDelta[x] represents the Dirac delta function δ(x).
DiracDelta[x1,x2,…] represents the multidimensional Dirac delta function δ(x1,x2,…).
DirectedEdge
DirectedEdge[u,v] or uv represents a directed edge from u to v.
DirectedEdge[u,v,t] or u&tv represents a directed edge from u to v with tag t.
DirectedEdges
DirectedEdges is an option for Graph, GraphPlot, and related functions that specifies whether edges should be taken to be directed.
DirectedGraph
DirectedGraph[g] gives a directed graph from the undirected graph g.
DirectedGraph[g,conv] gives a directed graph using the conversion conv.
DirectedGraph[{v->w,…},…] uses rules v->w to specify the graph g.
DirectedGraphQ
DirectedGraphQ[g] yields True if the graph g is a directed graph and False otherwise.
DirectedInfinity
DirectedInfinity[] represents an infinite numerical quantity whose direction in the complex plane is unknown.
DirectedInfinity[z] represents an infinite numerical quantity that is a positive real multiple of the complex number z.
Direction
Direction is an option for Limit and related functions that specifies the direction in which the limit is taken.
DirectionalLight
DirectionalLight[col,pt] is a three–dimensional graphics directive that specifies the directional light of color col from the point pt to the center of the bounding box to use in coloring 3D surfaces.
DirectionalLight[col,{pt1,pt2}] uses a directional light along the vector from pt1 to pt2.
Directive
Directive[g1,g2,…] represents a single graphics directive composed of the directives g1, g2, ….
Directory
Directory[] gives the current working directory.
DirectoryName
DirectoryName["name"] extracts the directory name from the specification for a file.
DirectoryQ
DirectoryQ["name"] gives True if the directory with the specified name exists, and gives False otherwise.
DirectoryStack
DirectoryStack[] gives the directory stack that represents the sequence of current directories used.
DirichletBeta
DirichletBeta[s] gives the Dirichlet beta function β(s).
DirichletCharacter
DirichletCharacter[k,j,n] gives the Dirichlet character χk,j(n) with modulus k and index j.
DirichletCondition
DirichletCondition[beqn,pred] represents a Dirichlet boundary condition given by equation beqn, satisfied on the part of the boundary of the region given to NDSolve and related functions where pred is True.
DirichletConvolve
DirichletConvolve[f,g,n,m] gives the Dirichlet convolution of the expressions f and g.
DirichletDistribution
DirichletDistribution[{α1,…,αk+1}] represents a Dirichlet distribution of dimension k with shape parameters αi.
DirichletEta
DirichletEta[s] gives the Dirichlet eta function η(s).
DirichletL
DirichletL[k,j,s] gives the Dirichlet L-function L(χ,s) for the Dirichlet character χ(n) with modulus k and index j.
DirichletLambda
DirichletLambda[s] gives the Dirichlet lambda function λ(s).
DirichletTransform
DirichletTransform[expr,n,s] gives the Dirichlet transform of expr with respect to n.
DirichletWindow
DirichletWindow[x] represents a Dirichlet window function of x.
DiscreteAsymptotic
DiscreteAsymptotic[expr,n->∞] gives an asymptotic approximation for expr as n tends to infinity over the integers.
DiscreteAsymptotic[expr,{n,∞,m}] gives an asymptotic series approximation for expr to order m.
DiscreteChirpZTransform
DiscreteChirpZTransform[list] gives the chirp Z transform of list.
DiscreteChirpZTransform[list,n] returns a length n chirp Z transform.
DiscreteChirpZTransform[list,n,w] uses a spiral path on the complex z plane defined by w.
DiscreteChirpZTransform[list,n,w,a] uses a as the complex starting point.
DiscreteChirpZTransform[list,{n1,n2,…},{w1,w2,…},{a1,a2,…}] gives the multidimensional chirp Z transform.
DiscreteConvolve
DiscreteConvolve[f,g,n,m] gives the convolution with respect to n of the expressions f and g.
DiscreteConvolve[f,g,{n1,n2,…},{m1,m2,…}] gives the multidimensional convolution.
DiscreteDelta
DiscreteDelta[n1,n2,…] gives the discrete delta function δ(n1,n2,…), equal to 1 if all the ni are zero, and 0 otherwise.
DiscreteHadamardTransform
DiscreteHadamardTransform[list] gives the discrete Hadamard transform of list.
DiscreteIndicator
DiscreteIndicator[x,x1,{u1,u2,…}] yields the discrete indicator function, equal to 1 if x=x1 and, otherwise, to 0 if x=ui for some i.
DiscreteLQEstimatorGains
DiscreteLQEstimatorGains[ssm,{w,v},τ] gives the optimal discrete-time estimator gain matrix with sampling period τ for the continuous-time StateSpaceModel ssm, with process and measurement noise covariance matrices w and v.
DiscreteLQEstimatorGains[{ssm,sensors},{w,v},τ] specifies sensors as the noisy measurements of ssm.
DiscreteLQEstimatorGains[{ssm,sensors,dinputs},{w,v},τ] specifies dinputs as the deterministic inputs of ssm.
DiscreteLQRegulatorGains
DiscreteLQRegulatorGains[sspec,wts,τ] gives the discrete-time state feedback gains with sampling period τ for the continuous-time system specification sspec that minimizes a cost function with weights wts.
DiscreteLQRegulatorGains[…,"prop"] gives the value of the property "prop".
DiscreteLyapunovSolve
DiscreteLyapunovSolve[a,c] finds the numeric solution x of the discrete matrix equation a.x.a-xc.
DiscreteLyapunovSolve[a,b,c] solves a.x.b-xc.
DiscreteLyapunovSolve[{a,d},c] solves a.x.a-d.x.dc.
DiscreteLyapunovSolve[{a,d},{b,e},c] solves a.x.b-d.x.ec.
DiscreteMarkovProcess
DiscreteMarkovProcess[i0,m] represents a discrete-time, finite-state Markov process with transition matrix m and initial state i0.
DiscreteMarkovProcess[p0,m] represents a Markov process with initial state probability vector p0.
DiscreteMarkovProcess[…,g] represents a Markov process with transition matrix from the graph g.
DiscretePlot
DiscretePlot[f,{n,nmax}] generates a plot of f as a function of n when n=1,…,nmax.
DiscretePlot[f,{n,nmin,nmax}] generates a plot when n runs from nmin to nmax.
DiscretePlot[f,{n,nmin,nmax,dn}] uses steps dn.
DiscretePlot[f,{n,{n1,…,nm}}] uses the successive values n1, …, nm.
DiscretePlot[{f1,f2,…},…] plots the values of all the fi.
DiscretePlot3D
DiscretePlot3D[f,{i,imin,imax},{j,jmin,jmax}] generates a plot of f when i runs from imin to imax and j runs from jmin to jmax.
DiscretePlot3D[f,{i,imin,imax,di},{j,jmin,jmax,dj}] uses steps di and dj.
DiscretePlot3D[f,{i,{i1,…,im}},{j,{j1,…,jn}}] uses successive i values i1, …, jm and j values j1, …, jn.
DiscretePlot3D[{f1,f2,…},…,…] plots the values of all the fk.
DiscreteRatio
DiscreteRatio[f,i] gives the discrete ratio f(i+1)/f(i).
DiscreteRatio[f,{i,n}] gives the multiple discrete ratio.
DiscreteRatio[f,{i,n,h}] gives the multiple discrete ratio with step h.
DiscreteRatio[f,i,j,…] computes the partial difference ratio with respect to i, j, ….
DiscreteTimeModelQ
DiscreteTimeModelQ[lsys] gives True if lsys is a discrete-time systems model, and False otherwise.
DiscreteUniformDistribution
DiscreteUniformDistribution[{imin,imax}] represents a discrete uniform distribution over the integers from imin to imax.
DiscreteUniformDistribution[{{imin,imax},{jmin,jmax},…}] represents a multivariate discrete uniform distribution over integers within the box {{imin,imax},{jmin,jmax},…}.
DiscreteVariables
DiscreteVariables is an option for NDSolve and other functions that specifies variables that only change at discrete times in a temporal integration.
DiscreteWaveletData
DiscreteWaveletData[{wind1->coef1,…},wave,wtrans] yields a discrete wavelet data object with wavelet coefficients coefi corresponding to wavelet index windi, wavelet wave, and wavelet transform wtrans.
DiscreteWaveletData[{wind1->coef1,…},wave,wtrans,{d1,…}] yields a discrete wavelet data object assuming data dimensions {d1,…}.
DiscreteWaveletPacketTransform
DiscreteWaveletPacketTransform[data] gives the discrete wavelet packet transform (DWPT) of an array of data.
DiscreteWaveletPacketTransform[data,wave] gives the discrete wavelet packet transform using the wavelet wave.
DiscreteWaveletPacketTransform[data,wave,r] gives the discrete wavelet packet transform using r levels of refinement.
DiscreteWaveletTransform
DiscreteWaveletTransform[data] gives the discrete wavelet transform (DWT) of an array of data.
DiscreteWaveletTransform[data,wave] gives the discrete wavelet transform using the wavelet wave.
DiscreteWaveletTransform[data,wave,r] gives the discrete wavelet transform using r levels of refinement.
DiscretizeGraphics
DiscretizeGraphics[g] discretizes a 2D or 3D graphic g into a MeshRegion.
DiscretizeGraphics[g,patt] discretizes only the elements in g that match the pattern patt.
DiscretizeRegion
DiscretizeRegion[reg] discretizes a region reg into a MeshRegion.
DiscretizeRegion[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.
Discriminant
Discriminant[poly,var] computes the discriminant of the polynomial poly with respect to the variable var.
Discriminant[poly,var,Modulus->p] computes the discriminant modulo p.
DisjointQ
DisjointQ[list1,list2] yields True if list1 and list2 do not share any common elements, and False otherwise.
Disjunction
Disjunction[expr,{a1,a2,…}] gives the disjunction of expr over all choices of the Boolean variables ai.
Disk
Disk[{x,y},r] represents a disk of radius r centered at {x,y}.
Disk[{x,y}] gives a disk of radius 1.
Disk[{x,y},{rx,ry}] gives an axis-aligned elliptical disk with semiaxes lengths rx and ry.
Disk[{x,y},…,{θ1,θ2}] gives a sector of a disk from angle θ1 to θ2.
Disk[{{x1,y1},{x2,y2},…},…] gives multiple identical disks centered at the given coordinates.
DiskSegment
DiskSegment[{x,y},r,{θ1,θ2}] represents the disk segment from angle θ1 to θ2 in a disk centered at {x,y} of radius r.
DiskSegment[{x,y},{rx,ry},{θ1,θ2}] represents the ellipse segment from angle θ1 to θ2 in an axis-aligned ellipse with semiaxes lengths rx and ry.
Dispatch
Dispatch[{lhs1->rhs1,lhs2->rhs2,…}] generates an optimized dispatch table representation of a list of rules. The object produced by Dispatch can be used to give the rules in expr/.rules.
DispersionEstimatorFunction
DispersionEstimatorFunction is an option for generalized linear model fitting functions that specifies the estimator for the dispersion parameter.
Display
Display[channel,graphics] writes graphics or sound to the specified output channel in PostScript format.
Display[channel,graphics,"format"] writes graphics or sound in the specified format.
Display[channel,expr,"format"] writes boxes, cells, or notebook expressions in the specified format.
DisplayAllSteps
DisplayAllSteps is an option to Animate and related functions that specifies whether all frames should be displayed in an animation, even if to do so would slow the animation down.
DisplayEndPacket
DisplayEndPacket[] is a WSTP packet that indicates the end of a series of expressions relating to a postscript graphic.
DisplayFunction
DisplayFunction is an option for graphics and sound functions that specifies a function to apply to graphics and sound objects before returning them.
DisplayPacket
DisplayPacket[] is a WSTP packet that indicates the beginning of a series of expressions related to a PostScript graphic.
DisplayString
DisplayString[graphics] generates a string giving graphics or sound in PostScript format.
DisplayString[graphics,"format"] generates a string giving graphics or sound in the specified format.
DisplayString[expr,"format"] generates a string giving boxes, cells, or notebook expressions in the specified format.
DistanceFunction
DistanceFunction is an option for functions such as Nearest that specifies the distance value to assume between any two specified points.
DistanceMatrix
DistanceMatrix[{u1,u2,…}] gives the matrix of distances between each pair of elements ui, uj.
DistanceMatrix[{u1,u2,…},{v1,v2,…}] gives the matrix of distances between each pair of elements ui, vj.
DistanceTransform
DistanceTransform[image] gives the distance transform of image, in which the value of each pixel is replaced by its distance to the nearest background pixel.
DistanceTransform[image,t] treats values above t as foreground.
Distribute
Distribute[f[x1,x2,…]] distributes f over Plus appearing in any of the xi.
Distribute[expr,g] distributes over g.
Distribute[expr,g,f] performs the distribution only if the head of expr is f.
Distributed
Distributed[x,dist] or xdist asserts that the random variable x is distributed according to the probability distribution dist.
Distributed[{x1,x2,…},dist] or {x1,x2,…}dist asserts that the random vector {x1,x2,…} is distributed according to the multivariate probability distribution dist.
DistributedContexts
DistributedContexts is an option for various parallel computing functions that specifies which definitions for symbols appearing in an expression should be distributed to all parallel kernels.
DistributeDefinitions
DistributeDefinitions[s1,s2,…] distributes all definitions for the symbols si to all parallel kernels.
DistributeDefinitions["context`"] distributes definitions for all symbols in the specified context.
DistributionChart
DistributionChart[{data1,data2,…}] makes a distribution chart with a distribution symbol for each datai.
DistributionChart[{…,wi[datai,…],…,wj[dataj,…],…}] makes a distribution chart with symbol features defined by the symbolic wrappers wk.
DistributionChart[{{data1,data2,…},…}] makes a distribution chart from multiple groups of datasets {data1,data2,…}.
DistributionFitTest
DistributionFitTest[data] tests whether data is normally distributed.
DistributionFitTest[data,dist] tests whether data is distributed according to dist.
DistributionFitTest[data,dist,"property"] returns the value of "property".
DistributionParameterAssumptions
DistributionParameterAssumptions[dist] gives a logical expression for assumptions on parameters in the symbolic distribution dist.
DistributionParameterQ
DistributionParameterQ[dist] yields True if dist is a valid distribution, and yields False otherwise.
Dithering
Dithering is an option for ColorQuantize that specifies whether or not to apply dithering while quantizing the pixel values.
Div
Div[{f1,…,fn},{x1,…,xn}] gives the divergence ∂f1/∂x1+…+∂fn/∂xn.
Div[{f1,…,fn},{x1,…,xn},chart] gives the divergence in the coordinates chart.
Divide
x/y or Divide[x,y] is equivalent to x y^-1.
DivideBy
x/=c divides x by c and returns the new value of x.
Dividers
Dividers is an option for Grid and related constructs that specifies where and how to draw divider lines.
DivideSides
DivideSides[rel,x] divides each side of the equation or inequality rel by x.
DivideSides[rel1,rel2] divides the corresponding sides of two equations or inequalities.
DivideSides[rel] divides each side of rel by the right-hand side, producing a 1 right-hand side.
Divisible
Divisible[n,m] yields True if n is divisible by m, and yields False if it is not.
Divisors
Divisors[n] gives a list of the integers that divide n.
DivisorSigma
DivisorSigma[k,n] gives the divisor function σk(n).
DivisorSum
DivisorSum[n,form] represents the sum of form[i] for all i that divide n.
DivisorSum[n,form,cond] includes only those divisors for which cond[i] gives True.
DMSList
DMSList[θ] converts an angle θ given in decimal degrees to a DMS list {degree,minute,second}.
DMSList["dms"] converts a DMS string to a DMS list {degree,minute,second}.
DMSList["latlon"] converts a latitude-longitude string to a pair of DMS lists.
DMSList[GeoPosition[…]] converts GeoPosition data to a pair or array of pairs of DMS lists.
DMSString
DMSString[θ] converts an angle θ given in decimal degrees to a degrees-minutes-seconds string.
DMSString[{ϕ,λ}] converts latitude and longitude given in decimal degrees to a DMS latitude-longitude string.
DMSString[{d,m,s}] converts a DMS list to a DMS string.
Do
Do[expr,n] evaluates expr n times.
Do[expr,{i,imax}] evaluates expr with the variable i successively taking on the values 1 through imax (in steps of 1).
Do[expr,{i,imin,imax}] starts with i=imin.
Do[expr,{i,imin,imax,di}] uses steps di.
Do[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….
Do[expr,{i,imin,imax},{j,jmin,jmax},…] evaluates expr looping over different values of j etc. for each i.
DocumentGenerator
DocumentGenerator[template,timespec] represents a document generator with template template to be evaluated on the schedule defined by timespec.
DocumentGenerator[template,driver,timespec] takes parameters for filling the template from driver.
DocumentGeneratorInformation
DocumentGeneratorInformation[cloudobj] returns the properties of the DocumentGenerator cloudobj.
DocumentGeneratorInformation[cloudobj,property] returns the value of the property property.
DocumentWeightingRules
DocumentWeightingRules is an option for TextSearch and related functions that allows the specification of weights for documents based on the values of fields in the search index.
Dodecahedron
Dodecahedron[] represents a regular dodecahedron centered at the origin with unit edge length.
Dodecahedron[l] represents a dodecahedron with edge length l.
Dodecahedron[{θ,ϕ},…] represents a dodecahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
Dodecahedron[{x,y,z},…] represents a dodecahedron centered at {x,y,z}.
DominantColors
DominantColors[image] returns dominant colors in image.
DominantColors[image,n] returns at most n dominant colors in image.
DominantColors[image,n,prop] returns the specified property prop for the regions that belong to the same dominant color.
DominantColors[image,n,prop,format] returns the output in the specified format.
DominantColors[{image1,image2,…},…] returns dominant colors in each imagei.
DominatorTreeGraph
DominatorTreeGraph[g,r] gives the dominator tree of the directed graph g from the root vertex r.
DominatorVertexList
DominatorVertexList[g,r] gives the list of dominators of the directed graph g from the root vertex r.
DOSTextFormat
DOSTextFormat is an option for OpenRead, OpenWrite, and OpenAppend that specifies whether files should be opened in text mode. With DOSTextFormat -> True, Mathematica uses the normal text format for the type of computer on which Mathematica is running. Text mode typically entails translation of a text file's line-ending characters into the newline character "\n". With DOSTextFormat -> False, files are opened in "binary mode", in which no such translation is performed. On some systems, there is no difference between text mode and binary mode.
Dot
a.b.c or Dot[a,b,c] gives products of vectors, matrices, and tensors.
DotDashed
DotDashed is a graphics directive specifying that lines that follow should be drawn dot-dashed.
DotEqual
DotEqual[x,y,…] displays as x≐y≐….
DotLayer
DotLayer[] represents a net layer that takes the dot product of two or more arrays.
DotLayer[{spec1,spec2,…}] uses given transpose specifications for the respective inputs.
DotPlusLayer
DotPlusLayer[n] is equivalent to LinearLayer[n] and should no longer be used.
Dotted
Dotted is a graphics directive specifying that lines that follow should be drawn dotted.
DoubleBracketingBar
DoubleBracketingBar[x,y,…] displays as x,y,….
DoubleDownArrow
DoubleDownArrow[x,y,…] displays as x⇓�.
DoubleLeftArrow
DoubleLeftArrow[x,y,…] displays as x⇐y⇐….
DoubleLeftRightArrow
DoubleLeftRightArrow[x,y,…] displays as x⇔y⇔….
DoubleLeftTee
DoubleLeftTee[x,y] displays as x⫤y.
DoubleLongLeftArrow
DoubleLongLeftArrow[x,y,…] displays as x⟸y⟸….
DoubleLongLeftRightArrow
DoubleLongLeftRightArrow[x,y,…] displays as x⟺y⟺….
DoubleLongRightArrow
DoubleLongRightArrow[x,y,…] displays as x⟹y⟹….
DoubleRightArrow
DoubleRightArrow[x,y,…] displays as x⇒y⇒….
DoubleRightTee
DoubleRightTee[x,y] displays as x⊨y.
DoubleUpArrow
DoubleUpArrow[x,y,…] displays as x⇑y⇑….
DoubleUpDownArrow
DoubleUpDownArrow[x,y,…] displays as x⇕y⇕….
DoubleVerticalBar
DoubleVerticalBar[x,y,…] displays as x∥y∥….
DoublyInfinite
DoublyInfinite is an option for LerchPhi. With DoublyInfinite -> True, the summation is taken from -Infinity to Infinity. With DoublyInfinite -> False, the summation is taken from zero to Infinity.
DownArrow
DownArrow[x,y,…] displays as x↓y↓….
DownArrowBar
DownArrowBar[x,y,…] displays as x⤓y⤓….
DownArrowUpArrow
DownArrowUpArrow[x,y,…] displays as x⇵y⇵….
DownLeftRightVector
DownLeftRightVector[x,y,…] displays as x⥐y⥐….
DownLeftTeeVector
DownLeftTeeVector[x,y,…] displays as x⥞y⥞….
DownLeftVector
DownLeftVector[x,y,…] displays as x↽y↽….
DownLeftVectorBar
DownLeftVectorBar[x,y,…] displays as x⥖y⥖….
DownRightTeeVector
DownRightTeeVector[x,y,…] displays as x⥟y⥟….
DownRightVector
DownRightVector[x,y,…] displays as x⇁y⇁….
DownRightVectorBar
DownRightVectorBar[x,y,…] displays as x⥗y⥗….
Downsample
Downsample[array,n] returns a downsampled version of the array by sampling every nth element.
Downsample[array,n,offset] starts sampling from the element at position offset.
Downsample[image,…] downsamples an image.
DownTee
DownTee[x,y] displays as x⊤y.
DownTeeArrow
DownTeeArrow[x,y,…] displays as x↧y↧….
DownValues
DownValues[f] gives a list of transformation rules corresponding to all downvalues (values for f[…]) defined for the symbol f.
DownValues["symbol"] gives a list of transformation rules corresponding to all downvalues defined for the symbol named "symbol" if it exists.
DrazinInverse
DrazinInverse[m] finds the Drazin generalized inverse mD of a square matrix m.
DropoutLayer
DropoutLayer[] represents a net layer that sets its input elements to zero with probability 0.5 during training.
DropoutLayer[p] sets its input elements to zero with probability p during training.
DSolve
DSolve[eqn] solves a differential equation eqn.
DSolve[eqn,u,x] solves a differential equation for the function u, with independent variable x.
DSolve[eqn,u,{x,xmin,xmax}] solves a differential equation for x between xmin and xmax.
DSolve[{eqn1,eqn2,…},{u1,u2,…},…] solves a list of differential equations.
DSolve[eqn,u,{x1,x2,…}] solves a partial differential equation.
DSolve[eqn,u,{x1,x2,…}∈Ω] solves the partial differential equation eqn over the region Ω.
DSolveValue
DSolveValue[eqn,expr,x] gives the value of expr determined by a symbolic solution to the ordinary differential equation eqn with independent variable x.
DSolveValue[eqn,expr,{x,xmin,xmax}] uses a symbolic solution for x between xmin and xmax.
DSolveValue[{eqn1,eqn2,…},expr,…] uses a symbolic solution for a list of differential equations.
DSolveValue[eqn,expr,{x1,x2,…}] uses a solution for the partial differential equation eqn.
DSolveValue[eqn,expr,{x1,x2,…}∈Ω] uses a solution of the partial differential equation eqn over the region Ω.
DualPlanarGraph
DualPlanarGraph[g] gives the dual of the planar graph g.
DualPolyhedron
DualPolyhedron[poly] gives the dual polyhedron of the polyhedron poly.
DumpGet
DumpGet[ "filename"] reads in a file saved with DumpSave.
DumpSave
DumpSave["file.mx",symbol] writes definitions associated with a symbol to a file in internal Wolfram System format.
DumpSave["file.mx","context`"] writes out definitions associated with all symbols in the specified context.
DumpSave["file.mx",{object1,object2,…}] writes out definitions for several symbols or contexts.
DumpSave["package`",objects] chooses the name of the output file based on the computer system used.
DuplicateFreeQ
DuplicateFreeQ[list] gives True if list has no duplicates, and False otherwise.
DuplicateFreeQ[list,test] applies test to pairs of elements to determine whether they should be considered duplicates.
Duration
Duration[expr] returns the duration of expr.
Duration[expr,unit] returns the result in the specified unit.
E
E is the exponential constant (base of natural logarithms), with numerical value ≃2.71828.
EarthImpactData
EarthImpactData[entity,property] gives the value of the specified property for the earth impact crater entity.
EarthImpactData[{entity1,entity2,…},property] gives a list of property values for the specified earth impact crater names.
EarthImpactData[entity,property,annotation] gives the specified annotation associated with the given property.
EarthquakeData
EarthquakeData[loc] gives all earthquake properties for the location corresponding to loc.
EarthquakeData[loc,mag] restricts earthquakes returned to the magnitude range mag.
EarthquakeData[loc,mag,{start,end}] gives earthquake data within the magnitude range mag during the time interval start to end.
EarthquakeData[loc,mag,{start,end},property] gives a time series for the specific earthquake property for earthquakes within the magnitude range mag during the time interval start to end.
EarthquakeData[entity,property] returns data for a specific earthquake.
EccentricityCentrality
EccentricityCentrality[g] gives a list of eccentricity centralities for the vertices in the graph g.
EccentricityCentrality[{v->w,…}] uses rules v->w to specify the graph g.
Echo
Echo[expr] prints expr and returns expr.
Echo[expr,label] prints expr prepending label and returns expr.
Echo[expr,label,f] prints f[expr] prepending label and returns expr.
EchoEvaluation
EchoEvaluation[expr] prints expr before evaluation, then prints the result after evaluation and returns that result.
EchoEvaluation[expr,label] prepends label when printing expr before and after evaluation.
EchoEvaluation[expr,label1->label2] prepends label1 before evaluation and label2 after evaluation.
EchoEvaluation[expr,labels,f] prints expr before evaluation, then evaluates expr to the result res and prints f[res].
EchoEvaluation[expr,labels,g->f] prints g[expr] before evaluating expr and then f[res] after evaluation.
EchoFunction
EchoFunction[f][expr] prints f[expr] and returns expr.
EchoFunction[label,f][expr] prints f[expr] prepending label and returns expr.
EchoLabel
EchoLabel[label][expr] prints expr prepending label and returns expr.
EchoTiming
EchoTiming[expr] evaluates expr, prints the time in seconds used and returns the result of the evaluation.
EchoTiming[expr,label] prints the timing, prepending label.
EclipseType
EclipseType is an option for SolarEclipse and LunarEclipse that specifies the type of eclipse being queried for.
EdgeAdd
EdgeAdd[g,e] makes a graph by adding the edge e to the graph g.
EdgeAdd[g,{e1,e2,…}] adds a collection of edges to g.
EdgeAdd[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeBetweennessCentrality
EdgeBetweennessCentrality[g] gives a list of betweenness centralities for the edges in the graph g.
EdgeBetweennessCentrality[{v->w,…}] uses rules v->w to specify the graph g.
EdgeCapacity
EdgeCapacity is an option and annotation for Graph and related functions that specifies an edge capacity.
EdgeChromaticNumber
EdgeChromaticNumber[g] gives the chromatic number for the edges of the graph g.
EdgeConnectivity
EdgeConnectivity[g] gives the edge connectivity of the graph g.
EdgeConnectivity[g,s,t] gives the s-t edge connectivity of the graph g.
EdgeConnectivity[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeContract
EdgeContract[g,e] contracts the edge e of the graph g.
EdgeContract[g,{e1,e2,…}] contracts a collection of edges e1,e2,….
EdgeContract[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeCost
EdgeCost is an option and annotation for Graph and related functions that specifies an edge cost.
EdgeCount
EdgeCount[g] gives a count of the number of edges in the graph g.
EdgeCount[g,patt] gives a count of the number of edges that match the pattern patt.
EdgeCount[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeCoverQ
EdgeCoverQ[g,elist] yields True if the edge list elist is an edge cover of the graph g and False otherwise.
EdgeCycleMatrix
EdgeCycleMatrix[g] gives the edge cycle matrix of a graph g.
EdgeCycleMatrix[{v->w,…}] uses rules v->w to specify the graph g.
EdgeDelete
EdgeDelete[g,e] makes a graph by deleting the edge e from the graph g.
EdgeDelete[g,{e1,e2,…}] deletes a collection of edges from g.
EdgeDelete[g,patt] deletes all edges that match the pattern patt.
EdgeDelete[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeDetect
EdgeDetect[image] finds edges in image and returns the result as a binary image.
EdgeDetect[image,r] finds edges at the scale of the specified pixel range r.
EdgeDetect[image,r,t] uses a threshold t for selecting image edges.
EdgeForm
EdgeForm[g] is a graphics directive that specifies that edges of polygons and other filled graphics objects are to be drawn using the graphics directive or list of directives g.
EdgeIndex
EdgeIndex[g,e] gives the integer index for the edge e in the graph g.
EdgeIndex[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeLabeling
EdgeLabeling is an option for GraphPlot and related functions that specifies whether labeling specified for edges should be displayed by default.
EdgeLabels
EdgeLabels is an option and annotation for Graph and related functions that specifies what labels and label positions should be used for edges.
EdgeLabelStyle
EdgeLabelStyle is an option and property for Graph and related functions that specifies the style to use for edge labels.
EdgeList
EdgeList[g] gives the list of edges for the graph g.
EdgeList[g,patt] gives a list of edges that match the pattern patt.
EdgeList[{v->w,…},…] uses rules v->w to specify the graph g.
EdgeQ
EdgeQ[g,e] yields True if e is an edge in the graph g and False otherwise.
EdgeRenderingFunction
EdgeRenderingFunction is an option for GraphPlot and related functions that gives a function to generate the graphics primitives to use in rendering each edge.
EdgeRules
EdgeRules[g] gives the list of edge rules for the graph g.
EdgeRules[{v->w,…}] uses rules v->w to specify the graph g.
EdgeShapeFunction
EdgeShapeFunction is an option and annotation for Graph and related functions that specifies a function to use to generate primitives for rendering each edge.
EdgeStyle
EdgeStyle is an option and annotation for Graph and related functions that specifies what style to use for edges.
EdgeTaggedGraph
EdgeTaggedGraph[{e1,e2,…}] yields a graph with edges ej tagged with unique tags.
EdgeTaggedGraph[{e1,e2,…}->{t1,t2,…}] yields a graph with edges ej tagged with tj.
EdgeTaggedGraph[{v1,v2,…},{e1,e2,…}->{t1,t2,…}] yields a graph with vertices vi and edges ej tagged with tj.
EdgeTaggedGraph[{…,wi[vi],…},{…,wj[ej],…}->{t1,t2,…}] yields a graph with vertex and edge annotations defined by the symbolic wrappers wk.
EdgeTaggedGraphQ
EdgeTaggedGraphQ[g] yields True if the graph g has edges tagged and False otherwise.
EdgeTags
EdgeTags[g] gives the list of tags for all edges in the graph g.
EdgeTags[g,{u,v}] gives the list of tags for edges between u and v.
EdgeTransitiveGraphQ
EdgeTransitiveGraphQ[g] yields True if the graph g is a edge-transitive graph and False otherwise.
EdgeValueRange
EdgeValueRange is an option for GeoGraphValuePlot that specifies the range of edge values to include in a plot.
EdgeValueSizes
EdgeValueSizes is an option for GeoGraphValuePlot that specifies the thicknesses used to show edge values in a plot.
EdgeWeight
EdgeWeight is an option and annotation for Graph and related functions that specifies an edge weight.
EdgeWeightedGraphQ
EdgeWeightedGraphQ[g] yields True if the graph g is an edge-weighted graph and False otherwise.
EditDistance
EditDistance[u,v] gives the edit or Levenshtein distance between strings or vectors u and v.
EditDistance[u,v] gives the edit or Levenshtein distance between strings, vectors or biomolecular sequences u and v.
EffectiveInterest
EffectiveInterest[r,q] gives the effective interest rate corresponding to interest specification r, compounded at time intervals q.
Eigensystem
Eigensystem[m] gives a list {values,vectors} of the eigenvalues and eigenvectors of the square matrix m.
Eigensystem[{m,a}] gives the generalized eigenvalues and eigenvectors of m with respect to a.
Eigensystem[m,k] gives the eigenvalues and eigenvectors for the first k eigenvalues of m.
Eigensystem[{m,a},k] gives the first k generalized eigenvalues and eigenvectors.
Eigenvalues
Eigenvalues[m] gives a list of the eigenvalues of the square matrix m.
Eigenvalues[{m,a}] gives the generalized eigenvalues of m with respect to a.
Eigenvalues[m,k] gives the first k eigenvalues of m.
Eigenvalues[{m,a},k] gives the first k generalized eigenvalues.
EigenvectorCentrality
EigenvectorCentrality[g] gives a list of eigenvector centralities for the vertices in the graph g.
EigenvectorCentrality[g,"In"] gives a list of in-centralities for a directed graph g.
EigenvectorCentrality[g,"Out"] gives a list of out-centralities for a directed graph g.
EigenvectorCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
Eigenvectors
Eigenvectors[m] gives a list of the eigenvectors of the square matrix m.
Eigenvectors[{m,a}] gives the generalized eigenvectors of m with respect to a.
Eigenvectors[m,k] gives the first k eigenvectors of m.
Eigenvectors[{m,a},k] gives the first k generalized eigenvectors.
Element
Element[x,dom] or x∈dom asserts that x is an element of the domain dom.
Element[x,reg] or x∈reg asserts that x is an element of the region reg.
Element[x1|x2|…,dom] asserts that all the xi are elements of dom.
Element[patt,dom] asserts that any expression matching the pattern patt is an element of dom.
ElementwiseLayer
ElementwiseLayer[f] represents a net layer that applies a unary function f to every element of the input array.
ElementwiseLayer["name"] applies the function specified by "name".
ElidedForms
ElidedForms is an option to TextString and related functions that specifies which expressions should be elided.
Eliminate
Eliminate[eqns,vars] eliminates variables between a set of simultaneous equations.
Ellipsoid
Ellipsoid[p,{r1,…}] represents an axis-aligned ellipsoid centered at the point p and with semiaxes lengths ri.
Ellipsoid[p,Σ] represents an ellipsoid centered at p and weight matrix Σ.
EllipticE
EllipticE[m] gives the complete elliptic integral E(m).
EllipticE[ϕ,m] gives the elliptic integral of the second kind E(ϕm).
EllipticExp
EllipticExp[u,{a,b}] is the inverse for EllipticLog. It produces a list {x,y} such that u==EllipticLog[{x,y},{a,b}].
EllipticExpPrime
EllipticExpPrime[u,{a,b}] gives the derivative of EllipticExp[u,{a,b}] with respect to u.
EllipticF
EllipticF[ϕ,m] gives the elliptic integral of the first kind F(ϕm).
EllipticFilterModel
EllipticFilterModel[n] designs a lowpass elliptic filter of order n.
EllipticFilterModel[{n,ωc}] uses the cutoff frequency ωc.
EllipticFilterModel[{"type",spec}] designs an elliptic filter of the specified type "type", using the spec.
EllipticFilterModel[{"type",spec},var] expresses the model in terms of the variable var.
EllipticK
EllipticK[m] gives the complete elliptic integral of the first kind K(m).
EllipticLog
EllipticLog[{x,y},{a,b}] gives the generalized logarithm associated with the elliptic curve y2=x3+a x2+b x.
EllipticNomeQ
EllipticNomeQ[m] gives the nome q corresponding to the parameter m in an elliptic function.
EllipticPi
EllipticPi[n,m] gives the complete elliptic integral of the third kind Π(nm).
EllipticPi[n,ϕ,m] gives the incomplete elliptic integral Π(n;ϕm).
EllipticReducedHalfPeriods
EllipticReducedHalfPeriods[{u, v}] gives a reduced pair of half periods {w, w'} corresponding to the same lattice as that of {u, v}.
EllipticTheta
EllipticTheta[a,u,q] gives the theta function ϑa(u,q) (a=1,…,4).
EllipticTheta[a,q] gives the theta constant ϑa(q)ϑa(0,q).
EmbedCode
EmbedCode[obj] generates the code necessary to embed the object obj on a webpage.
EmbedCode[obj,"dest"] generates code for an external environment or language of type "dest".
EmbedCode[obj,"dest",dir] saves the generated code as files in the directory dir.
EmbedCode[obj,"dest",loc] saves the generated code as a file archive in the file location loc.
EmbeddedHTML
EmbeddedHTML["string"] is an object that formats as a web frame containing the HTML content "string".
EmbeddedHTML[URL["url"]] formats as a rendering of the webpage corresponding to the specified URL.
EmbeddedHTML[CloudObject[…]] formats as a web rendering of the specified cloud object.
EmbeddedService
EmbeddedService[service] is an object that formats as a web frame containing content from the specified external service.
EmbeddedSQLEntityClass
EmbeddedSQLEntityClass[string,props] represents a verbatim SQL query to be interpreted as an entity class with properties given by props.
EmbeddedSQLEntityClass[template,props,args] represents an SQL query string template with arguments provided by args.
EmbeddedSQLExpression
EmbeddedSQLExpression[string] represents an SQL expression to be evaluated verbatim within an EntityFunction object.
EmbeddedSQLExpression[template,args] represents an SQL expression string template with arguments provided by args.
EmbeddingLayer
EmbeddingLayer[size,n] represents a trainable net layer that embeds integers between 1 and n into a continuous vector space of dimension size.
EmbeddingLayer[size] leaves the n to be inferred from context.
EmitSound
EmitSound[snd] emits the sound snd when evaluated.
EmitSound[{snd1,snd2,…}] emits each of the sounds sndi in sequence.
EmpiricalDistribution
EmpiricalDistribution[{x1,x2,…}] represents an empirical distribution based on the data values xi.
EmpiricalDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate empirical distribution based on the data values {xi,yi,…}.
EmpiricalDistribution[{w1,w2,…}->{d1,d2,…}] represents an empirical distribution where data values di occur with weights wi.
EmptyGraphQ
EmptyGraphQ[g] yields True if g is an empty graph and False otherwise.
EmptyRegion
EmptyRegion[n] represents the empty subset of n.
EmptySpaceF
EmptySpaceF[pdata,r] estimates the empty space function F(r) for point data pdata at radius r.
EmptySpaceF[pproc,r] computes F(r) for point process pproc.
EmptySpaceF[bdata,r] computes F(r) for binned data bdata.
EmptySpaceF[pspec] generates the function F that can be applied repeatedly to different radii r.
Enabled
Enabled is an option for objects such as Slider that specifies whether the objects should be enabled for interactive manipulation.
Enclose
Enclose[expr] attempts to evaluate expr and return the result, but stops if it catches an error and returns a failure object.
Enclose[expr,f] applies f to any failure object generated.
Enclose[expr,"prop"] gives the property prop of any failure object generated.
Enclose[expr,handler,form] only catches errors with explicitly specified tags matching form.
Encode
Encode["source","dest"] writes an encoded version of the file source to the file dest.
<<dest decodes the file before reading its contents.
Encode["source","dest","key"] produces an encoded file that must be read in using Get["dest","key"].
Encrypt
Encrypt["password",expr] encrypts expr using the specified password, to give an encrypted object.
Encrypt[keyspec,expr] encrypts expr using the cryptographic key specification keyspec.
Encrypt[expr] interactively requests a password with which to encrypt expr.
EncryptedObject
EncryptedObject[assoc] represents encrypted data generated by Encrypt.
EncryptFile
EncryptFile["password",file] generates an encrypted version of a file, using the specified password.
EncryptFile["password",source,target] generates an encrypted version of source, putting the result in target.
EncryptFile[keyspec,source,…] encrypts using the cryptographic key specification keyspec.
End
End[] returns the present context, and reverts to the previous one.
EndAdd
EndAdd[ ] returns the present context, and reverts to the previous one, prepending the present context to $ContextPath.
EndDialogPacket
EndDialogPacket[integer] is a WSTP packet indicating the end of the Dialog subsession referenced by integer.
EndOfBuffer
EndOfBuffer is a symbol that represents the end of currently available data in the buffer for a process or stream.
EndOfFile
EndOfFile is a symbol returned by Read when it reaches the end of a file.
EndOfLine
EndOfLine represents the end of a line in a string for purposes of matching in StringExpression.
EndOfString
EndOfString represents the end of a string for purposes of matching in StringExpression.
EndPackage
EndPackage[] restores $Context and $ContextPath to their values before the preceding BeginPackage, and prepends the current context to the list $ContextPath.
EngineeringForm
EngineeringForm[expr] prints with all real numbers in expr given in engineering notation.
EngineeringForm[expr,n] prints with numbers given to n‐digit precision.
EnterExpressionPacket
EnterExpressionPacket[expr] is a WSTP packet that requests the evaluation of expr.
EnterTextPacket
EnterTextPacket[string] is a WSTP packet that requests the parsing and evaluation of string as an expression.
Entity
Entity["type",name] represents an entity of the specified type, identified by name.
Entity[cspec,name] represents an entity from the computed class, specified by cspec.
EntityClass
EntityClass[type,name] represents a class of entities of the specified type identified by name.
EntityClass[type,{property1->vspec1,property2->vspec2,…}] represents an implicitly defined entity class containing entities of the specified type for which the properties propertyi conform to the value selector vspeci.
EntityClass[cspec,psel] represents an entity class with members specified by cspec, selected by the property selector psel.
EntityClassList
EntityClassList["type"] gives a list of entity classes for the specified type of entity.
EntityCopies
EntityCopies[entity,n] represents n copies of entity.
EntityFunction
EntityFunction[x,body] is a function with a single formal parameter x, to be used in EntityValue and related functions.
EntityFunction[{x1,x2,…},body] is an EntityFunction with a list of formal parameters.
EntityGroup
EntityGroup[{entity1,entity2,…}] represents a group of entities.
EntityInstance
EntityInstance[entity,qual->val] represents an entity whose qualifier qual has value val.
EntityInstance[entity,{qual1->val1,qual2->val2,…}] represents an entity whose qualifiers quali have values vali.
EntityInstance[entity,quantity] represents an entity qualified by quantity.
EntityList
EntityList[class] gives a list of entities in the specified entity class.
EntityList["type"] gives a list of entities of the specified type.
EntityList[class,simplify] gives a list of entities; simplify determines whether to reduce entities to the simplest possible type.
EntityPrefetch
EntityPrefetch["type"] fetches cacheable values associated with all entities of the specified type.
EntityPrefetch[EntityProperty["type","prop"]] fetches all values for the specified property.
EntityProperties
EntityProperties[type] lists properties associated with entity type type.
EntityProperty
EntityProperty[type,pname] represents a property identified by pname for use in EntityValue.
EntityProperty[class,pname] represents a property introduced by the computed entity class class.
EntityProperty[type,pname,{qual1->val1,qual2->val2, …}] represents a property modified by the qualifier rules quali->vali.
EntityPropertyClass
EntityPropertyClass[type,pcname] represents a class of properties identified by the name pcname.
EntityRegister
EntityRegister[estore] registers the entities in the entity store estore so that they can be accessed directly using Entity.
EntityStore
EntityStore["type"] represents an empty entity store for entities of type "type".
EntityStore["type"->data] represents an entity store for entities of type "type" with properties and values defined by data.
EntityStore[{tspec1,tspec2,…}] represents an entity store for entities of multiple types.
EntityStore[RelationalDatabase[…]] constructs an entity store from the schema of an external database.
EntityStore[{tspec1,tspec2,...},dbspec] constructs an entity store by mapping table names in the database specified by dbspec to types as specified by the tspeci.
EntityStores
EntityStores[] gives a list of all registered entity stores that are accessed when Entity is used.
EntityTypeName
EntityTypeName[entity] gives the name of the entity type of entity.
EntityTypeName[{entity1,…,entityn}] gives the name of the entity type for entity1 through entityn.
EntityUnregister
EntityUnregister["type"] unregisters all entities in the first entity store that defines entities of the specified type.
EntityUnregister[store] unregisters all entities in the specified entity store.
EntityValue
EntityValue[entity,property] gives the value of the specified property for the given entity.
EntityValue[{entity1,entity2,…},property] gives the list of values of the specified property for each of the entityi.
EntityValue[class,property] gives the list of values of the specified property for all entities in the specified class.
EntityValue[entity,{property1,property2,…}] gives the list of values of the propertyi for the specified entity.
EntityValue[ents,{property1,property2,…}] gives the list of values of the propertyi for each of the entities represented by ents.
Entropy
Entropy[list] gives the base information entropy of the values in list.
Entropy[k,list] gives the base k information entropy.
Environment
Environment["var"] gives the value of an operating system environment variable.
Epilog
Epilog is an option for graphics functions that gives a list of graphics primitives to be rendered after the main part of the graphics is rendered.
EpilogFunction
EpilogFunction is an option for DocumentGenerator allowing arbitrary code to be executed after a document is generated.
Equal
lhs==rhs returns True if lhs and rhs are identical.
EqualTilde
EqualTilde[x,y,…] displays as x≂y≂….
EqualTo
EqualTo[y] is an operator form that yields x==y when applied to an expression x.
EquatedTo
EquatedTo is an option for Roots, which specifies an expression to use in place of the variable in the solution.
Equilibrium
Equilibrium[x,y,…] displays as x⇌y⇌….
EquirippleFilterKernel
EquirippleFilterKernel[{{{ωL1,ωR1},{ωL2,ωR2},…},{a1,a2,…}},n] creates a finite impulse response (FIR) filter kernel of length n with an equiripple amplitude response, given the specified left and right band edge frequencies {ωLi,ωRi} and amplitudes ai.
EquirippleFilterKernel[{{{ωL1,ωR1},{ωL2,ωR2},…},{a1,a2,…},{w1,…}},n] uses relative weights wi for each frequency band.
EquirippleFilterKernel[{"type",{{{ωL1,ωR1},…},…}},n] creates a filter of the specified "type".
Equivalent
Equivalent[e1,e2,…] represents the logical equivalence e1⇔e2⇔…, giving True when all of the ei are the same.
Erf
Erf[z] gives the error function erf(z).
Erf[z0,z1] gives the generalized error function erf(z1)-erf(z0).
Erfc
Erfc[z] gives the complementary error function erfc(z).
Erfi
Erfi[z] gives the imaginary error function erf(iz)/i.
ErlangB
ErlangB[c,a] computes the Erlang B loss probability for an M/M/c/c queue.
ErlangC
ErlangC[c,a] computes the Erlang C probability for nonzero waiting time in an M/M/c queue.
ErlangDistribution
ErlangDistribution[k,λ] represents the Erlang distribution with shape parameter k and rate λ.
Erosion
Erosion[image,ker] gives the morphological erosion of image with respect to the structuring element ker.
Erosion[image,r] gives the erosion with respect to a range-r square.
Erosion[data,…] applies erosion to an array of data.
EscapeRadius
EscapeRadius is an option to MandelbrotSetPlot that specifies the criterion to use to decide that a point is not in the Mandelbrot set.
EstimatedBackground
EstimatedBackground[data] estimates the background of data.
EstimatedBackground[data,σ] tries to preserve peaks up to scale σ.
EstimatedDistribution
EstimatedDistribution[data,dist] estimates the parametric distribution dist from data.
EstimatedDistribution[data,dist,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….
EstimatedDistribution[data,dist,idist] estimates distribution dist with starting values taken from the instantiated distribution idist.
EstimatedPointProcess
EstimatedPointProcess[pdata,pproc] estimates the parametric point process pproc from point data pdata.
EstimatedPointProcess[pdata,pproc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….
EstimatedProcess
EstimatedProcess[data,proc] estimates the parametric process proc from data.
EstimatedProcess[data,proc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….
EstimatedProcess[data,proc,iproc] estimates process proc with starting values taken from the instantiated process iproc.
EstimatedVariogramModel
EstimatedVariogramModel[{loc1->val1,loc2->val2,…}] estimates the best variogram function from values vali given at locations loci.
EstimatedVariogramModel[{loc1,loc2,…}->{val1,val2,…}] generates the same result.
EstimatedVariogramModel[…,"model"] estimates the best parameters of the variogram function specified by "model".
EstimatedVariogramModel[…,{"model",params}] estimates the non-numeric parameters in params.
EstimatorGains
EstimatorGains[ssm,{p1,p2,…,pn}] gives the estimator gain matrix for the StateSpaceModel ssm, such that the poles of the estimator are pi.
EstimatorGains[{ssm,{out1,…}},…] specifies the measured outputs outi to use.
EstimatorRegulator
EstimatorRegulator[sspec,{l,κ}] gives the output feedback controller with estimator and regulator gains l and κ for the system specification sspec.
EstimatorRegulator[…,"prop"] gives the value of the property "prop".
EuclideanDistance
EuclideanDistance[u,v] gives the Euclidean distance between vectors u and v.
EulerAngles
EulerAngles[r] gives Euler angles {α,β,γ} corresponding to the rotation matrix r.
EulerAngles[r,{a,b,c}] gives Euler angles {α,β,γ} with rotation order {a,b,c}.
EulerCharacteristic
EulerCharacteristic[poly] gives the Euler characteristic of a poly.
EulerE
EulerE[n] gives the Euler number En.
EulerE[n,x] gives the Euler polynomial En(x).
EulerGamma
EulerGamma is Euler’s constant γ, with numerical value ≃0.577216.
EulerianGraphQ
EulerianGraphQ[g] yields True if the graph g is Eulerian, and False otherwise.
EulerMatrix
EulerMatrix[{α,β,γ}] gives the Euler 3D rotation matrix formed by rotating by α around the current z axis, then by β around the current y axis, and then by γ around the current z axis.
EulerMatrix[{α,β,γ},{a,b,c}] gives the Euler 3D rotation matrix corresponding, first rotating by α around the current a axis, then by β around the current b axis, and finally by γ around the current c axis.
EulerPhi
EulerPhi[n] gives the Euler totient function ϕ(n).
Evaluate
Evaluate[expr] causes expr to be evaluated even if it appears as the argument of a function whose attributes specify that it should be held unevaluated.
EvaluatePacket
EvaluatePacket[expr] is a WSTP packet requesting evaluation of expr.
EvaluateScheduledTask
EvaluateScheduledTask[expr] triggers immediate local execution of the specified task object.
EvaluationData
EvaluationData[expr] gives an association containing the result of evaluating expr and metadata about the process of doing so.
EvaluationEnvironment
EvaluationEnvironment is an option for functions such as InitializationValue and InitializationObjects that specifies the environment in which an initialization is intended to be used.
EvaluationMonitor
EvaluationMonitor is an option for various numerical computation and plotting functions that gives an expression to evaluate whenever functions derived from the input are evaluated numerically.
EvaluationObject
EvaluationObject[expr,…] represents an expression submitted for evaluation on any available parallel kernel.
EvenQ
EvenQ[expr] gives True if expr is an even integer, and False otherwise.
EventSeries
EventSeries[{{t1,v1},{t2,v2}…}] represents a series of events given as time-value pairs {ti,vi}.
EventSeries[{v1,v2,…},tspec] represents a series of events with values vi at times specified by tspec.
ExactBlackmanWindow
ExactBlackmanWindow[x] represents an exact Blackman window function of x.
ExactNumberQ
ExactNumberQ[expr] returns True if expr is an exact real or complex number, and returns False otherwise.
ExactRootIsolation
ExactRootIsolation is an option for Root, which specifies whether exact isolating intervals rather than numeric approximations should be used to identify algebraic numbers.
ExampleData
ExampleData["type"] gives a list of names of examples of the specified type.
ExampleData[{"type","name"}] gives the default form of the named example of the specified type.
ExampleData[{"type","name"},"elem"] gives the specified element or property of an example.
Except
Except[c] is a pattern object which represents any expression except one that matches c.
Except[c,p] represents any expression that matches p but not c.
ExcludedContexts
ExcludedContexts is an option for FullDefinition, Manipulate and related symbols that gives contexts whose symbols will not have the definitions recursively saved.
ExcludedForms
ExcludedForms is an option that gives a list of patterns for expressions that should be excluded from an operation performed by a particular function.
ExcludedLines
ExcludedLines is an option for SemanticImport and related functions that specifies which lines should be ignored for further processing.
ExcludedPhysicalQuantities
ExcludedPhysicalQuantities is an option for FormulaLookup that specifies physical quantities that should be not used by the formulas returned.
ExcludePods
ExcludePods is an option to WolframAlpha that specifies pod IDs to exclude from the results.
Exclusions
Exclusions is an option that specifies where to exclude in regions used by functions like Plot, Plot3D, and NIntegrate.
ExclusionsStyle
ExclusionsStyle is an option to plotting functions that specifies how to render subregions excluded according to Exclusions.
Exists
Exists[x,expr] represents the statement that there exists a value of x for which expr is True.
Exists[x,cond,expr] states that there exists an x satisfying the condition cond for which expr is True.
Exists[{x1,x2,…},expr] states that there exist values for all the xi for which expr is True.
Exit
Exit[] terminates a Wolfram Language kernel session.
ExoplanetData
ExoplanetData[entity,property] gives the value of the specified property for the exoplanet entity.
ExoplanetData[{entity1,entity2,…},property] gives a list of property values for the specified exoplanet entities.
ExoplanetData[entity,property,annotation] gives the specified annotation associated with the given property.
Exp
Exp[z] gives the exponential of z.
Expand
Expand[expr] expands out products and positive integer powers in expr.
Expand[expr,patt] leaves unexpanded any parts of expr that are free of the pattern patt.
ExpandAll
ExpandAll[expr] expands out all products and integer powers in any part of expr.
ExpandAll[expr,patt] avoids expanding parts of expr that do not contain terms matching the pattern patt.
ExpandDenominator
ExpandDenominator[expr] expands out products and powers that appear as denominators in expr.
ExpandFileName
ExpandFileName["name"] textually expands name to have the form of an absolute file name for your operating system.
ExpandNumerator
ExpandNumerator[expr] expands out products and powers that appear in the numerator of expr.
Expectation
Expectation[expr,xdist] gives the expectation of expr under the assumption that x follows the probability distribution dist.
Expectation[expr,xdata] gives the expectation of expr under the assumption that x follows the probability distribution given by data.
Expectation[expr,{x1,x2,…}dist] gives the expectation of expr under the assumption that {x1,x2,…} follows the multivariate distribution dist.
Expectation[expr,{x1dist1,x2dist2,…}] gives the expectation of expr under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, ….
Expectation[exprpred,…] gives the conditional expectation of expr given pred.
ExpectedValue
ExpectedValue[f,list] gives the expected value of the pure function f with respect to the values in list.
ExpectedValue[f,list,x] gives the expected value of the function f of x with respect to the values of list.
ExpectedValue[f,dist] gives the expected value of the pure function f with respect to the symbolic distribution dist.
ExpectedValue[f,dist,x] gives the expected value of the function f of x with respect to the symbolic distribution dist.
ExpGammaDistribution
ExpGammaDistribution[κ,θ,μ] represents an exp-gamma distribution with shape parameter κ, scale parameter θ, and location parameter μ.
ExpIntegralE
ExpIntegralE[n,z] gives the exponential integral function En(z).
Offload
Use Offload[expr_] to keep expr from evaluation on Kernel
ExpIntegralEi
ExpIntegralEi[z] gives the exponential integral function Ei(z).
ExpirationDate
ExpirationDate is an option for various functions that specifies when a persistent value should be treated as expired.
Exponent
Exponent[expr,form] gives the maximum power with which form appears in the expanded form of expr.
Exponent[expr,form,h] applies h to the set of exponents with which form appears in expr.
ExponentFunction
ExponentFunction is an option for NumberForm and related functions that determines the exponent to use in printing approximate real numbers.
ExponentialDistribution
ExponentialDistribution[λ] represents an exponential distribution with scale inversely proportional to parameter λ.
ExponentialFamily
ExponentialFamily is an option for GeneralizedLinearModelFit that specifies the exponential family for the model.
ExponentialMovingAverage
ExponentialMovingAverage[list, α] gives the exponential moving average of list with smoothing constant α.
ExponentialPowerDistribution
ExponentialPowerDistribution[κ,μ,σ] represents an exponential power distribution with shape parameter κ, location parameter μ, and scale parameter σ.
ExponentialPowerDistribution[κ] represents an exponential power distribution with location parameter 0 and scale parameter 1.
ExponentStep
ExponentStep is an option for NumberForm and related functions that determines in what steps exponents are taken to increase when scientific notation is used.
Export
Export["dest.ext",expr] exports data to a file, converting it to the format corresponding to the file extension ext.
Export[dest,expr,"fmt"] exports data in the specified format "fmt".
Export[dest,exprs,elements] exports data by treating exprs as elements.
Export[dest,exprs,elements,options] uses the specified options.
ExportByteArray
ExportByteArray[expr,"format"] generates a ByteArray object corresponding to expr exported in the specified format.
ExportByteArray[exprs,elems] generates a ByteArray object by treating exprs as elements specified by elems.
ExportForm
ExportForm[expr,"fmt"] specifies that expr should be exported in the specified format in functions like CloudDeploy and in external results from APIFunction and FormFunction.
ExportForm[expr,{"fmt","type"}] specifies that when expr is exported, it should be tagged as having the specified MIME type.
ExportString
ExportString[expr,"format"] generates a string corresponding to expr exported in the specified format.
ExportString[rules,{"format","Rules"}] gives explicit rules for different elements of the data to be exported.
ExportString[exprs,elems] generates a string by treating exprs as elements specified by elems.
Expression
Expression is a symbol that represents an ordinary Wolfram Language expression in Read and related functions.
ExpressionGraph
ExpressionGraph[expr] gives the tree graph with different levels at different depths.
ExpressionGraph[expr,n] gives the tree graph only down to level n.
ExpressionGraph[expr,n,form] gives a tree graph in which subexpressions that match form are leaves.
ExpressionTree
ExpressionTree[expr] gives a Tree object from the structure of the expression expr.
ExpressionTree[expr,struct] gives a Tree object from the expression expr with data and subtrees as specified by struct.
ExpToTrig
ExpToTrig[expr] converts exponentials in expr to trigonometric functions.
ExtendedEntityClass
ExtendedEntityClass[class,"name"->f] represents an entity class derived from class by adding a new computed property "name" whose value for each entity is obtained by applying the entity function f.
ExtendedEntityClass[class,{name1->f1,name2->f2,…}] adds the properties namei defined by the functions fi.
ExtendedGCD
ExtendedGCD[n1,n2,…] gives the extended greatest common divisor of the integers ni.
Extension
Extension is an option for various polynomial and algebraic functions that specifies generators for the algebraic number field to be used.
ExtentElementFunction
ExtentElementFunction is an option to DiscretePlot and DiscretePlot3D that gives a function to use to generate the primitives for rendering each extent element.
ExtentMarkers
ExtentMarkers is an option to DiscretePlot and DiscretePlot3D that specifies markers to draw at extent boundaries.
ExtentSize
ExtentSize is an option to DiscretePlot and DiscretePlot3D that specifies how far to extend out from each plot point.
ExternalBundle
ExternalBundle[{name1->obj1,name2->obj2,…}] represents a bundle of resources to be externally deployed as named URLs, functions, etc.
ExternalBundle[{name11->{name1->…,…},…}] represents a nested bundle of resources.
ExternalDataCharacterEncoding
ExternalDataCharacterEncoding is a global option that specifies the character encoding used in reading and writing plain text data outside of the Wolfram System.
ExternalEvaluate
ExternalEvaluate["sys","cmd"] evaluates the command cmd in the external evaluator sys, returning an expression corresponding to the output.
ExternalEvaluate[{"sys",opts},"cmd"] uses the options opts for the external evaluator.
ExternalEvaluate[assoc,"cmd"] evaluates cmd using the external evaluator specified by assoc.
ExternalEvaluate[session,"cmd"] evaluates cmd in the specified running ExternalSessionObject.
ExternalEvaluate[sys->"type",…] returns output converted to the specified type.
ExternalEvaluate[spec,obj] evaluates the content of the specified ExternalObject, ExternalOperation, File, URL or CloudObject.
ExternalEvaluate[spec,assoc] evaluates the command specified by assoc.
ExternalEvaluate[spec,{cmd1,cmd2,…}] evaluates the list of commands cmdi.
ExternalEvaluate[DatabaseReference[ref],"cmd"] evaluates cmd using the database specified by ref.
ExternalEvaluate[spec] represents an operator form of ExternalEvaluate that can be applied to a command or object.
ExternalFunction
ExternalFunction[sys,"f"] represents an external function named "f" defined in the external evaluator sys.
ExternalFunction[session,"f"] represents an external function "f" in the specified ExternalSessionObject.
ExternalFunction[sys,"code"] represents an external function defined by the code fragment "code".
ExternalFunction[obj,"method"] represents a method bound to the ExternalObject.
ExternalIdentifier
ExternalIdentifier["type",id] represents a resource identified by id in the external identifier system "type".
ExternalIdentifier["type",id,meta] includes the metadata given by the association meta to this instance of the external identifier object.
ExternalObject
ExternalObject[…] represents an external object bound to an ExternalSessionObject.
ExternalOptions
ExternalOptions is an option for EmbedCode and related functions that gives options specific to the external environment or language used.
ExternalSessionObject
ExternalSessionObject[…] represents an external session started by StartExternalSession for use with ExternalEvaluate.
ExternalSessions
ExternalSessions[] gives the list of currently active external evaluator sessions.
ExternalSessions[sys] gives the list of sessions associated with the system sys.
ExternalStorageBase
ExternalStorageBase is an option for various external storage functions that specifies which external storage service to use.
ExternalStorageDownload
ExternalStorageDownload[location] downloads content from the specified location.
ExternalStorageDownload[location,dest] downloads content from the specified location to a local destination file or directory dest.
ExternalStorageDownload[location->dest] downloads content from the specified locations to a local destination file or directory dest.
ExternalStorageDownload[{location1,location2,…},dest] downloads content from the specified locations to local destination dest.
ExternalStorageDownload[{location1,location2,…}->dest] downloads content from the specified locations to local destination dest.
ExternalStorageDownload[{location1->dest1,location2->dest2,…}] downloads content from the specified locations to local destinations.
ExternalStorageGet
ExternalStorageGet[ExternalStorageObject[…]] reads in an expression stored at an external storage specified by the ExternalStorageObject.
ExternalStorageGet[location] reads in an expression stored at location in an external storage specified by $ExternalStorageBase.
ExternalStorageObject
ExternalStorageObject[location] represents a file stored in an external location.
ExternalStorageObject[assoc] represents a file stored in an external service specified by the components of the association assoc.
ExternalStorageObject[location,assoc] represents a file stored in an external location with additional elements given by assoc.
ExternalStoragePut
ExternalStoragePut[expr] writes expr to an external storage specified by $ExternalStorageBase.
ExternalStoragePut[expr,path] writes expr to a specific path in an external storage specified by $ExternalStorageBase.
ExternalStoragePut[expr,ExternalStorageObject[...]] writes expr to the service and path represented by an ExternalStorageObject.
ExternalStorageUpload
ExternalStorageUpload[file] uploads file to an external storage specified by $ExternalStorageBase.
ExternalStorageUpload[file,dest] uploads file to a specific destination dest for external storage services that support it.
ExternalStorageUpload[file->dest] uploads file to a specific destination dest for external storage services that support it.
ExternalStorageUpload[{file1,file2,…},dest] uploads a list of files to a specific destination dest for external storage services that support it.
ExternalStorageUpload[{file1,file2,…}->dest] uploads a list of files to a specific destination dest for external storage services that support it.
ExternalStorageUpload[{file1->dest1,file2->dest2,…}] uploads a list of files to specific destinations for external storage services that support it.
ExternalTypeSignature
ExternalTypeSignature is an option for EmbedCode that gives rules specifying the mapping to external types in an embedded code.
ExternalValue
ExternalValue[sys,"sym"] gives the value of "sym" in external evaluator sys.
ExternalValue[session,"sym"] gives the value of "sym" in the specified external session.
Extract
Extract[expr,pos] extracts the part of expr at the position specified by pos.
Extract[expr,{pos1,pos2,…}] extracts a list of parts of expr.
Extract[expr,pos,h] extracts parts of expr, wrapping each of them with head h before evaluation.
Extract[pos] represents an operator form of Extract that can be applied to an expression.
ExtractArchive
ExtractArchive[source] expands an archive file, saving its content into the current directory.
ExtractArchive[source,dir] saves the content of an archive file into directory dir.
ExtractArchive[source,dir,pattern] extracts only files whose names match pattern.
ExtractLayer
ExtractLayer[] represents a net layer that takes an array and a position specification as inputs and extracts the specified parts from the array.
ExtractPacletArchive
ExtractPacletArchive[file] extracts the contents of the paclet archive file into the directory in which file resides.
ExtractPacletArchive[file,destdir] extracts the contents of the paclet archive file into destdir.
ExtremeValueDistribution
ExtremeValueDistribution[α,β] represents an extreme value distribution with location parameter α and scale parameter β.
ExtremeValueDistribution[] represents an extreme value distribution with location parameter 0 and scale parameter 1.
FaceAlign
FaceAlign[image] attempts to find faces in image and align them.
FaceAlign[image,fref] gives aligned faces according to the face reference fref.
FaceAlign[image,fref,size] gives aligned faces of the specified size.
FaceAlign[{image1,image2,…},…] gives a list of aligned faces for all imagei.
FaceForm
FaceForm[g] is a graphics directive which specifies that faces of polygons and other filled graphics objects are to be drawn using the graphics directive or list of directives g.
FaceForm[g,gback] specifies that the front faces of three-dimensional polygons should be drawn with directives g, and the backs with directives gback.
FaceGrids
FaceGrids is an option for three-dimensional graphics functions that specifies grid lines to draw on the faces of the bounding box.
FaceGridsStyle
FaceGridsStyle is an option for 3D graphics functions that specifies how face grids should be rendered.
FaceRecognize
FaceRecognize[{example1->name1,example2->name2,…}] generates a ClassifierFunction[…] based on the face examples and names given.
FaceRecognize[{example1,example2,…}->{name1,name2,…}] also generates a ClassifierFunction[…] based on the examples and names given.
FaceRecognize[<|name1->{example11,…},name2->{example21,…},…|>] uses an association of names with their examples.
FaceRecognize[training,image] attempts to find faces present in an image and classify them with the given training set.
FaceRecognize[training,image,prop] returns the specified property prop.
FacialFeatures
FacialFeatures[image] returns a minimal summary of facial features for all detected faces in image.
FacialFeatures[image,features] returns the specified facial features.
FacialFeatures[video,…] finds faces in frames of video.
Factor
Factor[poly] factors a polynomial over the integers.
Factor[poly,Modulus->p] factors a polynomial modulo the prime p.
Factor[poly,Extension->{a1,a2,…}] factors a polynomial allowing coefficients that are rational combinations of the algebraic numbers ai.
Factorial
n! gives the factorial of n.
Factorial2
n!! gives the double factorial of n.
FactorialMoment
FactorialMoment[data,r] gives the order r factorial moment μ&_r of data.
FactorialMoment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate factorial moment μ&_r1, …, rm of data.
FactorialMoment[dist,…] gives the factorial moment of the distribution dist.
FactorialMoment[r] represents the order r formal factorial moment.
FactorialMomentGeneratingFunction
FactorialMomentGeneratingFunction[dist,t] gives the factorial moment-generating function for the distribution dist as a function of the variable t.
FactorialMomentGeneratingFunction[dist,{t1,t2,…}] gives the factorial moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, ….
FactorialPower
FactorialPower[x,n] gives the factorial power x(n).
FactorialPower[x,n,h] gives the step-h factorial power x(n,h).
FactorInteger
FactorInteger[n] gives a list of the prime factors of the integer n, together with their exponents.
FactorInteger[n,k] does partial factorization, pulling out at most k distinct factors.
FactorList
FactorList[poly] gives a list of the factors of a polynomial, together with their exponents.
FactorSquareFree
FactorSquareFree[poly] pulls out any multiple factors in a polynomial.
FactorSquareFreeList
FactorSquareFreeList[poly] gives a list of square‐free factors of a polynomial, together with their exponents.
FactorTerms
FactorTerms[poly] pulls out any overall numerical factor in poly.
FactorTerms[poly,x] pulls out any overall factor in poly that does not depend on x.
FactorTerms[poly,{x1,x2,…}] pulls out any overall factor in poly that does not depend on any of the xi.
FactorTermsList
FactorTermsList[poly] gives a list in which the first element is the overall numerical factor in poly, and the second element is the polynomial with the overall factor removed.
FactorTermsList[poly,{x1,x2,…}] gives a list of factors of poly. The first element in the list is the overall numerical factor. The second element is a factor that does not depend on any of the xi. Subsequent elements are factors which depend on progressively more of the xi.
Failure
Failure["tag",assoc] represents a failure of a type indicated by tag, with details given by the association assoc.
FailureAction
FailureAction is an option to Query and related functions that determines what should happen when a failure or message is generated.
FailureDistribution
FailureDistribution[bexpr,{{x1,dist1},{x2,dist2},…}] represents the failure distribution for a system with events xi having reliability distribution disti where the top event occurs when the Boolean expression bexpr is True and event xi has occurred when xi is True.
FailureQ
FailureQ[expr] gives True if expr has head Failure or is equal to $Failed or $Aborted.
False
False is the symbol for the Boolean value false.
FareySequence
FareySequence[n] generates the Farey sequence of order n.
FareySequence[n,k] gives the kth element of the Farey sequence of order n.
FeatureDistance
FeatureDistance[example1,example2,extractor] gives the distance between example1 and example2 in the feature space defined by extractor.
FeatureDistance[extractor] represents an operator form of FeatureDistance that can be applied to a pair of examples.
FeatureExtract
FeatureExtract[{example1,example2,…}] extracts features for each of the examplei using a feature extractor trained on all the examplei.
FeatureExtract[examples,extractor] extracts features using the specified feature extractor method.
FeatureExtract[examples,{extractor1,extractor2,…}] extracts features by applying the extractori in sequence.
FeatureExtract[examples,spec->ext] uses the extractor methods specified by ext on parts of examples specified by spec.
FeatureExtract[examples,{spec1->ext1,spec2->ext2,…}] uses the extractor methods exti on parts of examples specified by the speci.
FeatureExtraction
FeatureExtraction[{example1,example2,…}] generates a FeatureExtractorFunction[…] trained from the examples given.
FeatureExtraction[examples,extractor] uses the specified feature extractor method.
FeatureExtraction[examples,{extractor1,extractor2,…}] applies the extractori in sequence to generate a feature extractor.
FeatureExtraction[examples,spec->ext] uses the extractor methods specified by ext on parts of examples specified by spec.
FeatureExtraction[examples,{spec1->ext1,spec2->ext2,…}] uses the extractor methods exti on parts of examples specified by the speci.
FeatureExtraction[examples,extractor,props] gives the feature extraction properties specified by props.
FeatureExtractor
FeatureExtractor is an option for functions such as Classify that specifies how features should be extracted.
FeatureExtractorFunction
FeatureExtractorFunction[…] represents a feature extractor function generated by FeatureExtraction.
FeatureNames
FeatureNames is an option for machine learning functions such as Classify or Predict that specifies names to use for elements of input data given.
FeatureNearest
FeatureNearest[{elem1,elem2,…},x] gives the list of elemi to which x is nearest in a computed feature space.
FeatureNearest[{elem1->v1,elem2->v2,…},x] gives the vi corresponding to the elemi to which x is nearest.
FeatureNearest[{elem1,elem2,…}->{v1,v2,…},x] gives the same result.
FeatureNearest[{elem1,elem2,…}->prop,x] gives the property prop for the elemi to which x is nearest.
FeatureNearest[data,{x1,x2,…}] effectively gives {FeatureNearest[data,x1],FeatureNearest[data,x2],…}.
FeatureNearest[data,x,n] gives the n nearest elemi to x.
FeatureNearest[data] generates a NearestFunction[…] that can be applied repeatedly to different x.
FeatureSpacePlot
FeatureSpacePlot[{example1,example2,…}] plots features extracted from the examplei as a scatter plot.
FeatureSpacePlot3D
FeatureSpacePlot3D[{example1,example2,…}] plots features extracted from the examplei as a scatter 3D plot.
FeatureTypes
FeatureTypes is an option for machine learning functions such as Classify or Predict that specifies what feature types to assume for elements of input data given.
FeedbackLinearize
FeedbackLinearize[asys] input-output linearizes the AffineStateSpaceModel asys by state transformation and feedback.
FeedbackLinearize[asys,{z,v}] specifies the new states z and the new control inputs v.
FeedbackLinearize[asys,{z,v},"prop"] computes the property "prop".
FeedbackSector
FeedbackSector is an option to NyquistPlot that specifies the sector limits of the nonlinearity in the feedback.
FeedbackSectorStyle
FeedbackSectorStyle is an option to NyquistPlot that specifies the style in which graphics of FeedbackSector should be drawn.
FeedbackType
FeedbackType is an option for some control system functions that specifies the feedback type.
FetalGrowthData
FetalGrowthData[age] returns the values for all properties of fetal development for the specified age of the fetus.
FetalGrowthData[age,property] returns the value for a property of fetal development for the specified age.
FetalGrowthData[age,index] returns the values for all properties of fetal development at the specified age and percentile.
FetalGrowthData[age,property,index] returns the value for a property at the specified age and percentile.
Fibonacci
Fibonacci[n] gives the Fibonacci number Fn.
Fibonacci[n,x] gives the Fibonacci polynomial Fn(x).
Fibonorial
Fibonorial[n] gives the fibonorial n!F.
FieldCompletionFunction
FieldCompletionFunction is an option for InputField that specifies a function to apply to the input field's contents to generate a list of completions.
FieldHint
FieldHint is an option for InputField that specifies contents to display when the input field is empty.
FieldHintStyle
FieldHintStyle is an option for InputField that specifies the style to use for displaying the field hint.
FieldMasked
FieldMasked is an option to InputField that determines whether to mask user input.
FieldSize
FieldSize is an option for InputField, PopupMenu, and related functions that specifies the size of the field allowed for input or contents.
File
File["path"] is a symbolic representation of a location in the local file system.
FileBaseName
FileBaseName["file"] gives the base name for a file without its extension.
FileByteCount
FileByteCount[file] gives the number of bytes in a file.
FileConvert
FileConvert[source->"dest.ext"] converts the contents of source to the format defined by the extension ext and writes the result to the file dest.ext.
FileConvert[source,"format"] writes the result to the filename defined by source, but with an extension defined by the specified format.
FileConvert[source->"dest.ext",format1->format2] takes the contents of source to be in the specified format "format1".
FileDate
FileDate["file"] gives the date and time at which a file was last modified.
FileDate["file","type"] gives information on the specified type of date associated with a file.
FileExistsQ
FileExistsQ["name"] gives True if the file with the specified name exists, and gives False otherwise.
FileExtension
FileExtension["file"] gives the file extension for a file name.
FileFormat
FileFormat[source] attempts to determine what Import format could be used to import the file corresponding to source.
FileFormat[source,{fmt1,fmt2,…}] returns the first "fmti" that can be used to import source.
FileFormatProperties
FileFormatProperties["fmt"] returns an association of properties for the specified format "fmt".
FileFormatProperties["fmt","prop"] returns the property "prop" for the format "fmt".
FileFormatProperties["fmt",{prop1,prop2,…}] returns multiple properties.
FileFormatQ
FileFormatQ[source,"fmt"] gives True if the file corresponding to source might be imported as format "fmt" and gives False otherwise.
FileFormatQ[source,{fmt1,fmt2,…}] gives True if source might be imported as one of "fmti".
FileHash
FileHash[file] gives an integer hash code for the contents of the specified file.
FileHash[file,"type"] gives an integer hash of the specified type.
FileHash[file,"type","format"] gives a hash code in the specified format.
FileHash[{file,range},…] gives the hash code for the specified range of bytes.
FileHash[{filespec1,filespec2,…},…] gives the hash codes for a list of files.
FileNameDepth
FileNameDepth["name"] gives the number of path elements in the file name "file".
FileNameDialogSettings
FileNameDialogSettings is a global option that specifies settings for the Insert File Path dialog box.
FileNameDrop
FileNameDrop["name",n] drops the first n path elements in the file name "name".
FileNameDrop["name",-n] drops the last n path elements in the file name "name".
FileNameDrop["name",{m,n}] drops elements m through n in the file name "name".
FileNameDrop["name"] drops the last path element in the file name "name".
FileNameForms
FileNameForms is an option that specifies the pattern for file names to be selected by a function.
FileNameJoin
FileNameJoin[{name1,name2,…}] joins the namei together into a file name suitable for your current operating system.
FileNameJoin[{CloudObject[…],name2,…}] joins the namei to the path in the specified cloud object.
FileNameJoin[{LocalObject[…],name2,…}] joins the namei to the path in the specified local object.
FileNameJoin[name1,name2, …] is equivalent to FileNameJoin[{name1,name2,…}].
FileNames
FileNames[] lists all files in the current working directory.
FileNames[form] lists all files in the current working directory whose names match the string pattern form.
FileNames[{form1,form2,…}] lists all files whose names match any of the formi.
FileNames[All,dir] lists all files in the directory dir.
FileNames[forms,{dir1,dir2,…}] lists files with names matching forms in any of the directories diri.
FileNames[forms,dirs,n] includes files that are in subdirectories up to n levels down.
FileNameSplit
FileNameSplit["name"] splits a file name into a list of parts.
FileNameTake
FileNameTake["name"] gives the last path element in the file name "name".
FileNameTake["name",n] gives the first n path elements in the file name "name".
FileNameTake["name",-n] gives the last n path elements in the file name "name".
FileNameTake["name",{m,n}] gives elements m through n in the file name "name".
FileNameToFormatList
FileNameToFormatList[] returns lists of file formats corresponding to all registered file name patterns.
FileNameToFormatList["file"] returns a list of file formats that matches the file name "file".
FilePrint
FilePrint["file"] prints out the raw textual contents of file.
FilePrint["file",n] prints out the first n raw textual lines of file.
FilePrint["file",-n] prints out the last n raw textual lines of file.
FilePrint["file",m;;n] prints out lines m through n of file.
FilePrint["file",m;;n;;s] prints out lines m through n of file in steps of s.
FileSize
FileSize[file] gives the size of a file as a quantity.
FileTemplate
FileTemplate["file"] yields a TemplateObject expression that represents a file template to be applied using functions like TemplateApply.
FileTemplate[src] uses File[…], URL[…], or CloudObject[…] as the specification for the file location.
FileTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.
FileTemplateApply
FileTemplateApply[template] applies a template, evaluating all template elements it contains, and then writes the result to a temporary file, whose name is returned.
FileTemplateApply[template,args] applies a template, using args to fill its slots, and then writes the result to a temporary file.
FileTemplateApply[template,output] applies a template, writing the results to the file represented by output.
FileTemplateApply[template,args,output] applies a template, using args to fill its slots, and then writes the result to the file represented by output.
FileType
FileType["file"] gives the type of a file, typically File, Directory, or None.
FilledCurve
FilledCurve[{segment1,segment2,…}] represents a filled curve consisting of segment1 followed by segment2 etc.
FilledCurve[{component1,component2,…}] represents a list of separate filled component curves component1, component2, etc.
FilledTorus
FilledTorus[{x,y,z},{rinner,router}] represents a filled torus centered at {x,y,z} with inner radius rinner and outer radius router.
Filling
Filling is an option for ListPlot, Plot, Plot3D, and related functions that specifies what filling to add under points, curves, and surfaces.
FillingStyle
FillingStyle is an option for ListPlot, Plot, Plot3D, and related functions that specifies the default style of filling to be used.
FillingTransform
FillingTransform[image] gives a version of image with all extended minima filled.
FillingTransform[image,marker] fills extended minima in regions where at least one corresponding element of marker is nonzero.
FillingTransform[image,h] fills only extended minima of depth h or less.
FilteredEntityClass
FilteredEntityClass[class,f] represents a class of entities where only entities for which the EntityFunction object f yields True are kept.
FilteredEntityClass[class,prop] represents a class of entities where only entities for which the property prop is True are kept.
FilterRules
FilterRules[rules,patt] filters the list rules by picking out only those rules whose left-hand sides match patt.
FilterRules[rules,{patt1,patt2,…}] picks out rules whose left-hand sides match any of the patti.
FinancialBond
FinancialBond[params,ambientparams] gives the value of a financial bond instrument.
FinancialBond[params,ambientparams,prop] computes the specified property prop.
FinancialData
FinancialData["name"] gives the last known price or value for the financial entity specified by "name".
FinancialData["name",start] gives a list of dates and daily closing values for "name" from start until the current date.
FinancialData["name",{start,end}] gives a list of dates and daily closing values for dates from start to end.
FinancialData["name",{start,end,period}] gives a list of dates and prices for the specified periods lying between start and end.
FinancialData["name","prop"] gives the value of the specified property for the financial entity "name".
FinancialData["name","prop",{start,end,…}] gives a list of dates and values of a property for a sequence of dates or periods.
FinancialDerivative
FinancialDerivative[instrument,params,ambientparams] gives the value of the specified financial instrument.
FinancialDerivative[instrument,params,ambientparams,prop] computes the specified property prop.
FinancialIndicator
FinancialIndicator["ind",par1,par2,…] represents a financial indicator "ind" with parameters par1, par2, etc.
Find
Find[stream,"text"] finds the first line in an input stream that contains the specified string.
Find[stream,{"text1","text2",…}] finds the first line that contains any of the specified strings.
FindAnomalies
FindAnomalies[{example1,example2,…}] gives a list of the examplei that are considered anomalous with respect to the other examples.
FindAnomalies[examples,prop] gives the specified property related to the anomaly computation.
FindAnomalies[examples,{prop1,prop2,…}] gives the properties propi.
FindAnomalies[fun,data] finds anomalies in data using the given AnomalyDetectorFunction[…] or LearnedDistribution[…].
FindAnomalies[fun,data,props] gives properties related to the anomaly computation.
FindArgMax
FindArgMax[f,x] gives the position xmax of a local maximum of f.
FindArgMax[f,{x,x0}] gives the position xmax of a local maximum of f, found by a search starting from the point x=x0.
FindArgMax[f,{{x,x0},{y,y0},…}] gives the position {xmax,ymax,…} of a local maximum of a function of several variables.
FindArgMax[{f,cons},{{x,x0},{y,y0},…}] gives the position of a local maximum subject to the constraints cons.
FindArgMax[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindArgMin
FindArgMin[f,x] gives the position xmin of a local minimum of f.
FindArgMin[f,{x,x0}] gives the position xmin of a local minimum of f, found by a search starting from the point x=x0.
FindArgMin[f,{{x,x0},{y,y0},…}] gives the position {xmin,ymin,…} of a local minimum of a function of several variables.
FindArgMin[{f,cons},{{x,x0},{y,y0},…}] gives the position of a local minimum subject to the constraints cons.
FindArgMin[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindChannels
FindChannels[] gives a list of channels in your home area on the channel broker server.
FindChannels[None] gives a list of your unnamed channels.
FindChannels[All] gives a list of all channels owned by you.
FindChannels[form] gives a list of channels in your home area whose names match the string pattern form.
FindChannels["/�] gives a list of channels whose names match the string pattern "/abspath".
FindChannels["mqtts://…"] gives a list of channels whose names match the specified pattern representing a URL.
FindClique
FindClique[g] finds a largest clique in the graph g.
FindClique[g,n] finds a clique containing at most n vertices.
FindClique[g,{n}] finds a clique containing exactly n vertices.
FindClique[g,{nmin,nmax}] finds a clique containing between nmin and nmax vertices.
FindClique[g,nspec,s] finds at most s cliques.
FindClique[{g,v},…] finds cliques that include the vertex v only.
FindClique[{v->w,…},…] uses rules v->w to specify the graph g.
FindClusters
FindClusters[{e1,e2,…}] partitions the ei into clusters of similar elements.
FindClusters[{e1->v1,e2->v2,…}] returns the vi corresponding to the ei in each cluster.
FindClusters[data,n] partitions data into n clusters.
FindCookies
FindCookies[] gives a list of all currently set cookies.
FindCookies[domain] gives a list of cookies associated with the specified domain.
FindCookies[assoc] gives a list of cookies whose attributes match the specification in the association assoc.
FindCurvePath
FindCurvePath[{{x1,y1},{x2,y2},…}] gives an ordering of the {xi,yi} that corresponds to one or more smooth curves.
FindCycle
FindCycle[g] finds a cycle in the graph g.
FindCycle[g,k] finds a cycle of length at most k in the graph g.
FindCycle[g,{k}] finds a cycle of length exactly k.
FindCycle[g,{kmin,kmax}] finds a cycle of length between kmin and kmax.
FindCycle[g,kspec,s] finds at most s cycles.
FindCycle[{g,v},…] finds cycles that include the vertex v.
FindCycle[{v->w,…},…] uses rules v->w to specify the graph g.
FindDevices
FindDevices[] searches for available devices on your computer system.
FindDevices[form] gives a list of devices in classes whose names match the string pattern form.
FindDevices[{form1,form2,…}] gives a list of devices in classes whose names match any of the formi.
FindDevices[forms,n] returns at most n devices.
FindDistribution
FindDistribution[data] finds a simple functional form to fit the distribution of data.
FindDistribution[data,n] finds up to n best distributions.
FindDistribution[data,n,prop] returns up to n best distributions associated with property prop.
FindDistribution[data,n,{prop1,prop2,…}] returns up to n best distributions associated with properties prop1, prop2, etc.
FindDistributionParameters
FindDistributionParameters[data,dist] finds the parameter estimates for the distribution dist from data.
FindDistributionParameters[data,dist,{{p,p0},{q,q0},…}] finds the parameters p, q, … with starting values p0, q0, ….
FindDivisions
FindDivisions[{xmin,xmax},n] finds a list of about n "nice" numbers that divide the interval around xmin to xmax into equally spaced parts.
FindDivisions[{xmin,xmax,dx},n] makes the parts always have lengths that are integer multiples of dx.
FindDivisions[{xmin,xmax},{n1,n2,…}] finds successive subdivisions into about n1, n2, … parts.
FindDivisions[{xmin,xmax,{dx1,dx2,…}},{n1,n2,…}] uses spacings that are forced to be multiples of dx1, dx2, ….
FindEdgeColoring
FindEdgeColoring[g] finds a coloring with minimal size for the edges in the graph g.
FindEdgeColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the edges in the graph g.
FindEdgeCover
FindEdgeCover[g] finds an edge cover of the graph g with a minimum number of edges.
FindEdgeCover[{v->w,…}] uses rules v->w to specify the graph g.
FindEdgeCut
FindEdgeCut[g] finds a smallest edge cut of the graph g.
FindEdgeCut[g,s,t] finds a smallest s-t edge cut of the graph g.
FindEdgeCut[{v->w,…},…] uses rules v->w to specify the graph g.
FindEdgeIndependentPaths
FindEdgeIndependentPaths[g,s,t,k] finds at most k edge-independent paths from vertex s to vertex t in the graph g.
FindEdgeIndependentPaths[{v->w,…},…] uses rules v->w to specify the graph g.
FindEquationalProof
FindEquationalProof[thm,axms] tries to find an equational proof of the symbolic theorem thm using the axioms axms.
FindEquationalProof[thm,"theory"] tries to find a proof of thm using the specified named axiomatic theory.
FindEulerianCycle
FindEulerianCycle[g] finds an Eulerian cycle in the graph g.
FindEulerianCycle[g,k] finds at most k Eulerian cycles.
FindEulerianCycle[{v->w,…},…] uses rules v->w to specify the graph g.
FindExternalEvaluators
FindExternalEvaluators[] finds installed external evaluators that can be used with ExternalEvaluate, returning a dataset of the results found.
FindExternalEvaluators["sys"] finds only external evaluators for language or system sys.
FindFile
FindFile[name] finds the file with the specified name that would be loaded by Get[name] and related functions.
FindFit
FindFit[data,expr,pars,vars] finds numerical values of the parameters pars that make expr give a best fit to data as a function of vars.
FindFit[data,{expr,cons},pars,vars] finds a best fit subject to the parameter constraints cons.
FindFit[data,exprspec,pars,vars,"prop"] specifies what fit property prop should be returned.
FindFormula
FindFormula[data] finds a pure function that approximates data.
FindFormula[data,x] finds a symbolic function of the variable x that approximates data.
FindFormula[data,x,n] finds up to n functions that approximate data.
FindFormula[data,x,n,prop] returns up to n best functions associated with property prop.
FindFormula[data,x,n,{prop1,prop2,…}] returns up to n best functions associated with properties prop1, prop2, etc.
FindFundamentalCycles
FindFundamentalCycles[g] finds fundamental cycles of the graph g.
FindGeneratingFunction
FindGeneratingFunction[{a0,a1,…},x] attempts to find a simple generating function in x whose nth series coefficient is an.
FindGeneratingFunction[{{n0,a0},{n1,a1},…},x] attempts to find a simple generating function whose nith series coefficient is ai.
FindGeoLocation
FindGeoLocation[] attempts to find the current geo location of your computer.
FindGeoLocation["ip"] gives an estimate of the geo location associated with the IP address given.
FindGeoLocation["address"] attempts to find the geo location associated with the street address given.
FindGeoLocation[entity] gives the geo location associated with the specified entity.
FindGeometricConjectures
FindGeometricConjectures[scene] finds conjectures that appear to hold for the GeometricScene object scene and adds these conjectures to the scene object.
FindGeometricConjectures[{scene1,scene2,…}] finds conjectures that appear to hold for all instances scenei of a geometric scene and returns a combined scene with the conjectures added.
FindGeometricConjectures[scenes,patt] adds only conjectures that match the pattern patt.
FindGeometricConjectures[scenes,patt,n] adds only up to n conjectures.
FindGeometricTransform
FindGeometricTransform[pts1,pts2] finds a geometric transformation that aligns positions specified by pts2 with pts1, returning the alignment error together with the transformation function.
FindGeometricTransform[ref,{pts1,pts2,…}] finds geometric transformations that align each of the ptsi with ref.
FindGeometricTransform[{pts1,pts2,…}] finds geometric transformations that align each of the ptsi with pts1.
FindGraphCommunities
FindGraphCommunities[g] finds communities in the graph g.
FindGraphCommunities[{v->w,…}] uses rules v->w to specify the graph g.
FindGraphIsomorphism
FindGraphIsomorphism[g1,g2] finds an isomorphism that maps the graph g1 to g2 by renaming vertices.
FindGraphIsomorphism[g1,g2,n] finds at most n isomorphisms.
FindGraphIsomorphism[{v->w,…},…] uses rules v->w to specify the graph g.
FindGraphPartition
FindGraphPartition[g] gives a partition of vertices of the graph g.
FindGraphPartition[g,k] gives a partition of vertices into k approximately equal-size parts.
FindGraphPartition[g,{n1,…,nk}] gives a partition of vertices into parts with sizes n1, …, nk.
FindGraphPartition[g,{α1,…,αk}] gives a partition of vertices into parts with approximate size proportions α1, …, αk.
FindGraphPartition[{v->w,…},…] uses rules v->w to specify the graph g.
FindHamiltonianCycle
FindHamiltonianCycle[g] finds a Hamiltonian cycle in the graph g.
FindHamiltonianCycle[g,k] finds at most k Hamiltonian cycles.
FindHamiltonianCycle[{v->w,…},…] uses rules v->w to specify the graph g.
FindHamiltonianPath
FindHamiltonianPath[g] finds a Hamiltonian path in the graph g with the smallest total length.
FindHamiltonianPath[g,s,t] finds a Hamiltonian path with the smallest total length from s to t.
FindHiddenMarkovStates
FindHiddenMarkovStates[data,hmm] finds the most likely hidden states of the HiddenMarkovProcess hmm corresponding to the emissions data.
FindHiddenMarkovStates[data,hmm,crit] uses the given criterion crit to find the hidden states.
FindIndependentEdgeSet
FindIndependentEdgeSet[g] finds an independent edge set of the graph g with a maximum number of edges.
FindIndependentEdgeSet[{v->w,…}] uses rules v->w to specify the graph g.
FindIndependentVertexSet
FindIndependentVertexSet[g] finds an independent vertex set of the graph g with a maximum number of vertices.
FindIndependentVertexSet[g,n] finds an independent vertex set with at most n vertices.
FindIndependentVertexSet[g,{n}] finds an independent vertex set with exactly n vertices.
FindIndependentVertexSet[g,{nmin,nmax}] finds an independent vertex set containing between nmin and nmax vertices.
FindIndependentVertexSet[g,nspec,s] finds at most s independent vertex sets.
FindIndependentVertexSet[{g,v},…] finds independent sets that include the vertex v only.
FindIndependentVertexSet[{v->w,…},…] uses rules v->w to specify the graph g.
FindInstance
FindInstance[expr,vars] finds an instance of vars that makes the statement expr be True.
FindInstance[expr,vars,dom] finds an instance over the domain dom. Common choices of dom are Complexes, Reals, Integers, and Booleans.
FindInstance[expr,vars,dom,n] finds n instances.
FindIntegerNullVector
FindIntegerNullVector[{x1,x2,…,xn}] finds a list of integers ai such that a1 x1+a2 x2+⋯+an xn0.
FindIntegerNullVector[{x1,x2,…,xn},d] finds a list of integers ai with {a1,…,an}≤d such that a1 x1+a2 x2+⋯+an xn0.
FindIsomorphicSubgraph
FindIsomorphicSubgraph[g1,g2] finds a subgraph of g1 that is isomorphic to g2.
FindIsomorphicSubgraph[g1,g2,n] finds at most n subgraphs.
FindKClan
FindKClan[g,k] finds a largest k-clan in the graph g.
FindKClan[g,k,n] finds a k-clan containing at most n vertices.
FindKClan[g,k,{n}] finds a k-clan containing exactly n vertices.
FindKClan[g,k,{nmin,nmax}] finds a k-clan containing between nmin and nmax vertices.
FindKClan[g,k,nspec,s] finds at most s k-clans.
FindKClan[{g,v},k,…] finds k-clans that include the vertex v only.
FindKClan[{v->w,…},…] uses rules v->w to specify the graph g.
FindKClique
FindKClique[g,k] finds a largest k-clique in the graph g.
FindKClique[g,k,n] finds a k-clique containing at most n vertices.
FindKClique[g,k,{n}] finds a k-clique containing exactly n vertices.
FindKClique[g,k,{nmin,nmax}] finds a k-clique containing between nmin and nmax vertices.
FindKClique[g,k,nspec,s] finds at most s k-cliques.
FindKClique[{g,v},k,…] finds k-cliques that include the vertex v only.
FindKClique[{v->w,…},…] uses rules v->w to specify the graph g.
FindKClub
FindKClub[g,k] finds a largest k-club in the graph g.
FindKPlex
FindKPlex[g,k] finds a largest k-plex in the graph g.
FindKPlex[g,k,n] finds a k-plex containing at most n vertices.
FindKPlex[g,k,{n}] finds a k-plex containing exactly n vertices.
FindKPlex[g,k,{nmin,nmax}] finds a k-plex containing between nmin and nmax vertices.
FindKPlex[g,k,nspec,s] finds at most s k-plexes.
FindKPlex[{g,v},k,…] finds k-plexes that include the vertex v only.
FindKPlex[{v->w,…},…] uses rules v->w to specify the graph g.
FindLibrary
FindLibrary[lib] finds a dynamic library that can be loaded by LibraryFunctionLoad.
FindLinearRecurrence
FindLinearRecurrence[list] finds if possible the minimal linear recurrence that generates list.
FindLinearRecurrence[list,d] finds if possible the linear recurrence of maximum order d that generates list.
FindList
FindList["file","text"] gives a list of lines in the file that contain the specified string.
FindList["file",{"text1","text2",…}] gives a list of all lines that contain any of the specified strings.
FindList[{"file1",…},…] gives a list of lines containing the specified strings in any of the filei.
FindList[files,text,n] includes only the first n lines found.
FindMatchingColor
FindMatchingColor[image,color] returns a color similar to the color that is present in image.
FindMatchingColor[image,{color1,color2,…}] returns a list of colors matching each colori.
FindMatchingColor[{image1,image2,…},{color1,color2,…}] returns lists of matching colors for all imagei.
FindMaximum
FindMaximum[f,x] searches for a local maximum in f, starting from an automatically selected point.
FindMaximum[f,{x,x0}] searches for a local maximum in f, starting from the point x=x0.
FindMaximum[f,{{x,x0},{y,y0},…}] searches for a local maximum in a function of several variables.
FindMaximum[{f,cons},{{x,x0},{y,y0},…}] searches for a local maximum subject to the constraints cons.
FindMaximum[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindMaximumCut
FindMaximumCut[g] gives the maximum cut of the graph g.
FindMaximumFlow
FindMaximumFlow[g,s,t] finds the maximum flow between source vertex s and target vertex t in a graph g.
FindMaximumFlow[m,s,t] finds the maximum flow between vertex indices s and t in a graph with edge capacity matrix m.
FindMaximumFlow[data,{s1,…},{t1,…}] finds the maximum flow between multi-sources s1, … and multi-targets t1, ….
FindMaximumFlow[data,source,target,"property"] returns the value of "property".
FindMaximumFlow[{v->w,…},…] uses rules v->w to specify the graph g.
FindMaxValue
FindMaxValue[f,x] gives the value at a local maximum of f.
FindMaxValue[f,{x,x0}] gives the value at a local maximum of f, found by a search starting from the point x=x0.
FindMaxValue[f,{{x,x0},{y,y0},…}] gives the value at a local maximum of a function of several variables.
FindMaxValue[{f,cons},{{x,x0},{y,y0},…}] gives the value at a local maximum subject to the constraints cons.
FindMaxValue[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindMeshDefects
FindMeshDefects[mreg] finds defects in the mesh region mreg.
FindMeshDefects[mreg,{def1,…}] finds only the specified type of defects def1, ….
FindMeshDefects[mreg,defects,format] formats the results according to format specification.
FindMinimum
FindMinimum[f,x] searches for a local minimum in f, starting from an automatically selected point.
FindMinimum[f,{x,x0}] searches for a local minimum in f, starting from the point x=x0.
FindMinimum[f,{{x,x0},{y,y0},…}] searches for a local minimum in a function of several variables.
FindMinimum[{f,cons},{{x,x0},{y,y0},…}] searches for a local minimum subject to the constraints cons.
FindMinimum[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindMinimumCostFlow
FindMinimumCostFlow[g,{sd1,sd2,…}] finds the minimum cost flow in the graph g with sd1, sd2, … vertex supplies or demands.
FindMinimumCostFlow[g,s,t] finds the minimum cost maximum flow between source vertex s and target vertex t in a graph g.
FindMinimumCostFlow[g,s,t,d] finds the minimum cost flow between source s and target t, with the required flow d.
FindMinimumCostFlow[m,…] finds the minimum cost flow in a graph with cost matrix m.
FindMinimumCostFlow[data,…,"property"] returns the value of "property".
FindMinimumCostFlow[{v->w,…},…] uses rules v->w to specify the graph g.
FindMinimumCut
FindMinimumCut[g] gives the minimum cut of the graph g.
FindMinimumCut[{v->w,…}] uses rules v->w to specify the graph g.
FindMinValue
FindMinValue[f,x] gives the value at a local minimum of f.
FindMinValue[f,{x,x0}] gives the value at a local minimum of f, found by a search starting from the point x=x0.
FindMinValue[f,{{x,x0},{y,y0},…}] gives the value at a local minimum of a function of several variables.
FindMinValue[{f,cons},{{x,x0},{y,y0},…}] gives the value at a local minimum subject to the constraints cons.
FindMinValue[{f,cons},{x,y,…}] starts from a point within the region defined by the constraints.
FindMoleculeSubstructure
FindMoleculeSubstructure[mol,patt] finds a mapping between the atom indices in mol and an occurrence of patt in mol.
FindMoleculeSubstructure[mol,patt,All] finds all occurrences of patt in mol and returns all mappings.
FindMoleculeSubstructure[mol,patt,n] finds at most n mappings.
FindPath
FindPath[g,s,t] finds a path between vertex s and vertex t in the graph g.
FindPath[g,s,t,k] finds a path of length at most k between vertex s and vertex t in the graph g.
FindPath[g,s,t,{k}] finds a path of length exactly k.
FindPath[g,s,t,{kmin,kmax}] finds a path of length between kmin and kmax.
FindPath[g,s,t,kspec,n] finds at most n paths.
FindPath[{v->w,…},…] uses rules v->w to specify the graph g.
FindPeaks
FindPeaks[list] gives positions and values of the detected peaks in list.
FindPeaks[list,σ] finds peaks that survive Gaussian blurring up to scale σ.
FindPeaks[list,σ,s] finds peaks with minimum sharpness s.
FindPeaks[list,σ,s,t] finds only peaks with values greater than t.
FindPeaks[list,σ,{s,σs},{t,σt}] uses different scales for thresholding sharpness and value.
FindPermutation
FindPermutation[expr] gives a permutation that produces expr by permuting Sort[expr].
FindPermutation[expr1,expr2] gives a permutation that converts expr1 to expr2 for two expressions that differ only in the order of their arguments.
FindPlanarColoring
FindPlanarColoring[g] finds a coloring with minimal size for the faces of the planar graph g.
FindPlanarColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the faces in the graph g.
FindPointProcessParameters
FindPointProcessParameters[pdata,pproc] estimates the parameters of the point process pproc from point data pdata.
FindPointProcessParameters[pdata,pproc,{{p,p0},{q,q0},…}] estimates the parameters p, q, … with starting values p0, q0, ….
FindPostmanTour
FindPostmanTour[g] finds a Chinese postman tour in the graph g of minimal length.
FindPostmanTour[g,k] finds at most k Chinese postman tours.
FindPostmanTour[{v->w,…},…] uses rules v->w to specify the graph g.
FindProcessParameters
FindProcessParameters[data,proc] finds the parameter estimates for the process proc from data.
FindProcessParameters[data,proc,{{p,p0},{q,q0},…}] finds the parameters p, q, … with starting values p0, q0, … .
FindRegionTransform
FindRegionTransform[reg1,reg2] gives the transformation function that maps the region reg1 to the region reg2.
FindRepeat
FindRepeat[list] finds the minimal sublist or subarray that repeats to give list.
FindRepeat[list,n] requires that the sublist be repeated at least n times in list.
FindRepeat[list,{n1,n2,…}] requires ni to repeat at level i in list.
FindRepeat["string"] finds the minimal substring that repeats to give string.
FindRepeat["string",n] requires that the substring be repeated at least n times.
FindRoot
FindRoot[f,{x,x0}] searches for a numerical root of f, starting from the point x=x0.
FindRoot[lhs==rhs,{x,x0}] searches for a numerical solution to the equation lhs==rhs.
FindRoot[{f1,f2,…},{{x,x0},{y,y0},…}] searches for a simultaneous numerical root of all the fi.
FindRoot[{eqn1,eqn2,…},{{x,x0},{y,y0},…}] searches for a numerical solution to the simultaneous equations eqni.
FindSequenceFunction
FindSequenceFunction[{a1,a2,a3,…}] attempts to find a simple function that yields the sequence an when given successive integer arguments.
FindSequenceFunction[{{n1,a1},{n2,a2},…}] attempts to find a simple function that yields ai when given argument ni.
FindSequenceFunction[<|n1->a1,n2->a2,…|>] gives a function that yields ai when given argument ni.
FindSequenceFunction[{n1->a1,n2->a2,…}] gives a function that yields ai when given argument ni.
FindSequenceFunction[list,n] gives the function applied to n.
FindShortestPath
FindShortestPath[g,s,t] finds the shortest path from source vertex s to target vertex t in the graph g.
FindShortestPath[g,s,All] generates a ShortestPathFunction[…] that can be applied repeatedly to different t.
FindShortestPath[g,All,t] generates a ShortestPathFunction[…] that can be applied repeatedly to different s.
FindShortestPath[g,All,All] generates a ShortestPathFunction[…] that can be applied to different s and t.
FindShortestPath[{v->w,…},…] uses rules v->w to specify the graph g.
FindShortestTour
FindShortestTour[{v1,v2,…}] attempts to find an ordering of the vi that minimizes the total distance on a tour that visits all the vi once.
FindShortestTour[graph] attempts to find an ordering of the vertices in graph that minimizes the total length when visiting each vertex once.
FindShortestTour[{v1,v2,…},j,k] finds an ordering of the vi that minimizes the total distance on a path from vj to vk.
FindShortestTour[graph,s,t] finds an ordering of the vertices that minimizes the total length on a path from s to t.
FindShortestTour[{v->w,…},…] uses rules v->w to specify the graph g.
FindShortestTour[data->prop,…] gives the property prop for data.
FindSpanningTree
FindSpanningTree[{v1,v2,…,vn}] finds a spanning tree that minimizes the total distance between the vi.
FindSpanningTree[g] finds a spanning tree of the graph g that minimizes the total distances between vertices.
FindSpanningTree[{g,v},…] finds a spanning tree of the connected component of g that includes the vertex v.
FindSpanningTree[{v->w,…},…] uses rules v->w to specify the graph g.
FindSubgraphIsomorphism
FindSubgraphIsomorphism[g1,g2] finds a subgraph isomorphism that maps the graph g1 to a subgraph of g2 by renaming vertices.
FindSubgraphIsomorphism[g1,g2,n] finds at most n subgraph isomorphisms.
FindTextualAnswer
FindTextualAnswer[text,"question"] gives the substring of text that best appears to answer question.
FindTextualAnswer[text,"question",n] gives a list of up to n answers that appear most probable.
FindTextualAnswer[text,"question",n,prop] gives the specified property for each answer.
FindThreshold
FindThreshold[image] finds a global threshold value that partitions the intensity values in image into two intervals.
FindTransientRepeat
FindTransientRepeat[list,n] returns a pair of lists {transient,repeat} where the elements of repeat occur successively at least n times after the elements of the transient part of list.
FindTransientRepeat[string,n] returns a pair of strings {transient,repeat}.
FindVertexColoring
FindVertexColoring[g] finds a coloring with minimal size for the vertices in the graph g.
FindVertexColoring[g,{c1,c2,…}] finds a coloring {c1,c2,…,ck} for the vertices in the graph g.
FindVertexCover
FindVertexCover[g] finds a vertex cover of the graph g with a minimum number of vertices.
FindVertexCover[{v->w,…}] uses rules v->w to specify the graph g.
FindVertexCut
FindVertexCut[g] finds a smallest vertex cut of the graph g.
FindVertexCut[g,s,t] finds a smallest s-t vertex cut of the graph g.
FindVertexCut[{v->w,…},…] uses rules v->w to specify the graph g.
FindVertexIndependentPaths
FindVertexIndependentPaths[g,s,t,k] finds at most k vertex-independent paths from vertex s to vertex t in the graph g.
FindVertexIndependentPaths[{v->w,…},…] uses rules v->w to specify the graph g.
FiniteAbelianGroupCount
FiniteAbelianGroupCount[n] gives the number of finite Abelian groups of order n.
FiniteGroupCount
FiniteGroupCount[n] gives the number of finite groups of order n.
FiniteGroupData
FiniteGroupData[name,"property"] gives the value of the specified property for the finite group specified by name.
FiniteGroupData["class"] gives a list of finite groups in the specified class.
First
First[expr] gives the first element in expr.
First[expr,def] gives the first element if it exists, or def otherwise.
FirstCase
FirstCase[{e1,e2,…},pattern] gives the first ei to match pattern, or Missing["NotFound"] if none matching pattern is found.
FirstCase[{e1,…},pattern->rhs] gives the value of rhs corresponding to the first ei to match pattern.
FirstCase[expr,pattern,default] gives default if no element matching pattern is found.
FirstCase[expr,pattern,default,levelspec] finds only objects that appear on levels specified by levelspec.
FirstCase[pattern] represents an operator form of FirstCase that can be applied to an expression.
FirstPassageTimeDistribution
FirstPassageTimeDistribution[mproc,f] represents the distribution of times for the Markov process mproc to pass from the initial state to final states f for the first time.
FirstPosition
FirstPosition[expr,pattern] gives the position of the first element in expr that matches pattern, or Missing["NotFound"] if no such element is found.
FirstPosition[expr,pattern,default] gives default if no element matching pattern is found.
FirstPosition[expr,pattern,default,levelspec] finds only objects that appear on levels specified by levelspec.
FirstPosition[pattern] represents an operator form of FirstPosition that can be applied to an expression.
FischerGroupFi22
FischerGroupFi22[] represents the sporadic simple Fischer group Fi22.
FischerGroupFi23
FischerGroupFi23[] represents the sporadic simple Fischer group Fi23.
FischerGroupFi24Prime
FischerGroupFi24Prime[] represents the sporadic simple Fischer group Fi24′.
FisherHypergeometricDistribution
FisherHypergeometricDistribution[n,nsucc,ntot,w] represents a Fisher noncentral hypergeometric distribution.
FisherZDistribution
FisherZDistribution[n,m] represents a Fisher z distribution with n numerator and m denominator degrees of freedom.
Fit
Fit[data,{f1,…,fn},{x,y,…}] finds a fit a1f1+…+anfn to a list of data for functions f1,…,fn of variables {x,y,…}.
Fit[{m,v}] finds a fit vector a that minimizes ||m.a-v|| for a design matrix m.
Fit[…,"prop"] specifies what fit property prop should be returned.
FitRegularization
FitRegularization is an option for Fit and FindFit that specifies a regularization for fitting a model.
FittedModel
FittedModel[…] represents the symbolic fitted model obtained from functions like LinearModelFit.
FixedOrder
FixedOrder[p1,p2,…] is a grammar rules pattern object that represents a sequence of elements matching p1, p2, …, in the fixed order given.
FixedPoint
FixedPoint[f,expr] starts with expr, then applies f repeatedly until the result no longer changes.
FixedPoint[f,expr,n] stops after at most n steps.
FixedPointList
FixedPointList[f,expr] generates a list giving the results of applying f repeatedly, starting with expr, until the results no longer change.
FixedPointList[f,expr,n] stops after at most n steps.
Flat
Flat is an attribute that can be assigned to a symbol f to indicate that all expressions involving nested functions f should be flattened out. This property is accounted for in pattern matching.
Flatten
Flatten[list] flattens out nested lists.
Flatten[list,n] flattens to level n.
Flatten[list,n,h] flattens subexpressions with head h.
Flatten[list,{{s11,s12,…},{s21,s22,…},…}] flattens list by combining all levels sij to make each level i in the result.
FlattenAt
FlattenAt[list,n] flattens out a sublist that appears as the nth element of list. If n is negative, the position is counted from the end.
FlattenAt[expr,{i,j,…}] flattens out the part of expr at position {i,j,…}.
FlattenAt[expr,{{i1,j1,…},{i2,j2,…},…}] flattens out parts of expr at several positions.
FlattenAt[pos] represents an operator form of FlattenAt that can be applied to an expression.
FlattenLayer
FlattenLayer[] represents a net layer that flattens any input array into a vector.
FlattenLayer[n] represents a net layer that flattens its input to level n.
FlattenLayer[{{s11,s12,…},{s21,s22,…},…}] represents a net layer that flattens its input by combining all levels sij to make each level i in the result.
FlatTopWindow
FlatTopWindow[x] represents an exact flat top window function of x.
FlightData
FlightData[spec,options] returns a subset of properties for a flight or selection of flights with specifications spec.
FlightData[spec,prop,options] returns the value of the property prop for specifications spec.
FlightData[spec,prop,datespec,options] returns the value of the property prop for a specific time or time range datespec.
FlipView
FlipView[{expr1,expr2}] represents an object which flips between displaying expr1 and expr2 each time it is clicked.
FlipView[{expr1,expr2,…}] cyclically flips through successive expri.
FlipView[{expr1,expr2,…},i] makes expri be the object currently displayed.
Floor
Floor[x] gives the greatest integer less than or equal to x.
Floor[x,a] gives the greatest multiple of a less than or equal to x.
FlowPolynomial
FlowPolynomial[g,k] gives the flow polynomial of the graph g.
FlowPolynomial[{v->w,…},…] uses rules v->w to specify the graph g.
Fold
Fold[f,x,list] gives the last element of FoldList[f,x,list].
Fold[f,list] is equivalent to Fold[f,First[list],Rest[list]].
Fold[f] represents an operator form of Fold that can be applied to expressions.
FoldList
FoldList[f,x,{a,b,…}] gives {x,f[x,a],f[f[x,a],b],…}.
FoldList[f,{a,b,c,…}] gives {a,f[a,b],f[f[a,b],c],…}.
FoldList[f] represents an operator form of FoldList that can be applied to expressions.
FoldPair
FoldPair[f,y0,list] gives the last element of FoldPairList[f,y0,list].
FoldPair[f,y0,list,g] gives the last element of FoldPairList[f,y0,list,g].
FoldPair[f,{a0,a1,a2,…}] is equivalent to FoldPair[f,a0,{a1,a2,…}].
FoldPairList
FoldPairList[f,y0,{a1,a2,…}] gives the list of successive xi obtained by applying f to pairs of the form {yi-1,ai}, where at each step f returns {xi,yi}.
FoldPairList[f,y0,list,g] gives the list of successive values of g[{xi,yi}].
FoldPairList[f,{a0,a1,a2,…}] is equivalent to FoldPairList[f,a0,{a1,a2,…}].
FoldWhile
FoldWhile[f,x,{a1,a2,…},test] returns the first expression f[… f[f[x,a1],a2]…,ak] to which applying test does not yield True.
FoldWhile[f,list,test] is equivalent to FoldWhile[f,First[list],Rest[list],test].
FoldWhile[f,x,{a1,a2,…},test,m] supplies the most recent m results as arguments for test at each step.
FoldWhile[f,x,{a1,a2,…},test,All] supplies all results so far as arguments for test at each step.
FoldWhile[f,x,{a1,a2,…},test,m,n] returns the result after applying f an extra n times after test fails.
FoldWhile[f,x,{a1,a2,…},test,m,-n] returns the result found when f had been applied n fewer times.
FoldWhile[f,test] represents an operator form of FoldWhile that can be applied to expressions.
FoldWhileList
FoldWhileList[f,x,{a1,a2,…},test] returns {x,f[x,a1],f[f[x,a1],a2],…}, repeatedly applying f with subsequent values ai until applying test to the result does not yield True.
FoldWhileList[f,list,test] is equivalent to FoldWhileList[f,First[list],Rest[list],test].
FoldWhileList[f,x,{a1,a2,…},test,m] supplies the most recent m results as arguments for test at each step.
FoldWhileList[f,x,{a1,a2,…},test,All] supplies all results so far as arguments for test at each step.
FoldWhileList[f,x,{a1,a2,…},test,m,n] returns n additional results by applying f an extra n times after test fails.
FoldWhileList[f,x,{a1,a2,…},test,m,-n] returns n fewer results.
FoldWhileList[f,test] represents an operator form of FoldWhileList that can be applied to expressions.
FollowRedirects
FollowRedirects is an option for URLRead and related functions that specifies whether to follow HTTP redirects when retrieving a URL.
FontColor
FontColor is an option for Style, Cell, and related constructs that specifies the default color in which to render text.
FontFamily
FontFamily is an option for Style and Cell that specifies the font family in which text should be rendered.
FontSize
FontSize is an option for Style and Cell that specifies the default size in printer's points of the font in which to render text.
FontSlant
FontSlant is an option for Style, Cell, and related constructs that specifies how slanted characters in text should be.
FontSubstitutions
FontSubstitutions is a global option that gives a list of substitutions to try for font family names.
FontTracking
FontTracking is an option for Style and Cell that specifies how condensed or expanded you want the font in which text is rendered to be.
FontVariations
FontVariations is an option for Style, Cell, and related constructs that specifies what font variations should be used.
FontWeight
FontWeight is an option for Style, Cell, and related constructs that specifies how heavy the characters in a font should be.
For
For[start,test,incr,body] executes start, then repeatedly evaluates body and incr until test fails to give True.
ForAll
ForAll[x,expr] represents the statement that expr is True for all values of x.
ForAll[x,cond,expr] states that expr is True for all x satisfying the condition cond.
ForAll[{x1,x2,…},expr] states that expr is True for all values of all the xi.
ForceVersionInstall
ForceVersionInstall is an option to PacletInstall and PacletInstallSubmit that specifies whether an older version of a paclet is allowed to be installed if a newer version is already installed.
Format
Format[expr] prints as the formatted form of expr. Assigning values to Format[expr] defines print forms for expressions.
Format[expr,form] gives a format for the specified form of output.
FormatType
FormatType is an option for output streams, graphics, and functions such as Text that specifies the default format type to use when outputting expressions.
FormatValues
FormatValues[f] gives a list of transformation rules corresponding to all printing formats (values for Format[f[x,…],…], etc.) defined for the symbol f.
FormFunction
FormFunction[formspec,func] represents an active form that, when submitted, applies func to the values obtained from the form specified by formspec.
FormFunction[{name1->type1,…},func] represents an active form with fields named namei interpreted as types typei.
FormFunction[{{name1,label1}->type1,…},func] uses labeli as the label for the field named namei.
FormFunction[{namespec1->type1->default1,…},func] uses defaulti as the default for the field specified by namespeci.
FormFunction[formspec,func,fmt] specifies that in the cloud, the result from applying func should be returned in format fmt.
FormFunction[{formspec1,formspec2,…},func,…] represents a multipage form, in which the successive formspeci can be functions that are applied to the values obtained so far.
FormLayoutFunction
FormLayoutFunction is an option for FormObject and FormFunction that can be used to specify how to lay out a form.
FormObject
FormObject[{name1->type1,name2->type2,…}] represents a form with fields having names namei that take data of type typei.
FormObject[{{name1,label1}->type1,…}] uses labeli as the label for the field named namei.
FormObject[{name1->assoc1,…,objj,…}] uses full specification associ for a field, and objj as part of the layout of the form.
FormPage
FormPage[formspec,func] represents an active page that takes input from a form and generates results on the same page by applying func to the values obtained from the form whose structure is defined by formspec.
FormPage[{name1->type1,…},func] represents an active form page with fields named namei interpreted as types typei.
FormPage[{{name1,label1}->type1,…},func] uses labeli as the label for the field named namei.
FormPage[{namespec1->type1->default1,…},func] uses defaulti as the default for the field specified by namespeci.
FormPage[formspec,func,form] lays out the page according to the layout specification form.
FormPage[formspec,func,initform->resform] uses initform as the initial layout specification and resform as the layout specification for result pages.
FormProtectionMethod
FormProtectionMethod is an option for form generation functions that specifies what method to use for protecting the form against spam and other undesired submissions.
FormTheme
FormTheme is an option for FormObject and related functions that specifies an overall theme for a form and its elements.
FormulaData
FormulaData[name] gives the equations for the formula name.
FormulaData[name,{var1->quantity1,var2->quantity2,…}] solves or simplifies equations using the specified values quantityi for the variables vari.
FormulaData[name,"property"] gives the value of the specified property for the formula name.
FormulaLookup
FormulaLookup["query"] gives a list of the full names of formulas whose names are consistent with "query".
FormulaLookup["query",n] returns at most n results.
FormulaLookup["class"] returns the names of all formulas within that class.
FortranForm
FortranForm[expr] prints as a Fortran language version of expr.
Forward
Forward is a symbol that represents the forward direction for purposes of motion and animation.
ForwardBackward
ForwardBackward is a symbol that represents alternate forward and backward motion or animation.
ForwardCloudCredentials
ForwardCloudCredentials is an option for remote evaluation and submission functions that specifies whether Wolfram Cloud credentials from the local session should be copied into remote sessions.
Fourier
Fourier[list] finds the discrete Fourier transform of a list of complex numbers.
Fourier[list,{p1,p2,…}] returns the specified positions of the discrete Fourier transform.
FourierCoefficient
FourierCoefficient[expr,t,n] gives the nth coefficient in the Fourier series expansion of expr.
FourierCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier coefficient.
FourierCosCoefficient
FourierCosCoefficient[expr,t,n] gives the nth coefficient in the Fourier cosine series expansion of expr.
FourierCosCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier cosine coefficient.
FourierCosSeries
FourierCosSeries[expr,t,n] gives the nth-order Fourier cosine series expansion of expr in t.
FourierCosSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier cosine series of expr.
FourierCosTransform
FourierCosTransform[expr,t,ω] gives the symbolic Fourier cosine transform of expr.
FourierCosTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier cosine transform of expr.
FourierDCT
FourierDCT[list] finds the Fourier discrete cosine transform of a list of real numbers.
FourierDCT[list,m] finds the Fourier discrete cosine transform of type m.
FourierDCTFilter
FourierDCTFilter[image,t] reduces noise in image by locally thresholding the discrete cosine transforms of overlapping subimages, using the hard threshold t.
FourierDCTMatrix
FourierDCTMatrix[n] returns an n×n discrete cosine transform matrix of type 2.
FourierDCTMatrix[n,m] returns an n×n discrete cosine transform matrix of type m.
FourierDST
FourierDST[list] finds the Fourier discrete sine transform of a list of real numbers.
FourierDST[list,m] finds the Fourier discrete sine transform of type m.
FourierDSTMatrix
FourierDSTMatrix[n] returns an n×n discrete sine transform matrix of type 2.
FourierDSTMatrix[n,m] returns an n×n discrete sine transform matrix of type m.
FourierMatrix
FourierMatrix[n] returns an n×n Fourier matrix.
FourierParameters
FourierParameters is an option to Fourier and related functions that specifies the conventions to use in computing Fourier transforms.
FourierSequenceTransform
FourierSequenceTransform[expr,n,ω] gives the Fourier sequence transform of expr.
FourierSequenceTransform[expr,{n1,n2,…},{ω1,ω2,…}] gives the multidimensional Fourier sequence transform.
FourierSeries
FourierSeries[expr,t,n] gives the nth-order Fourier series expansion of expr in t.
FourierSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier series.
FourierSinCoefficient
FourierSinCoefficient[expr,t,n] gives the nth coefficient in the Fourier sine series expansion of expr.
FourierSinCoefficient[expr,{t1,t2,…},{n1,n2,…}] gives a multidimensional Fourier sine coefficient.
FourierSinSeries
FourierSinSeries[expr,t,n] gives the nth-order Fourier sine series expansion of expr in t.
FourierSinSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier sine series of expr.
FourierSinTransform
FourierSinTransform[expr,t,ω] gives the symbolic Fourier sine transform of expr.
FourierSinTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier sine transform of expr.
FourierTransform
FourierTransform[expr,t,ω] gives the symbolic Fourier transform of expr.
FourierTransform[expr,{t1,t2,…},{ω1,ω2,…}] gives the multidimensional Fourier transform of expr.
FourierTrigSeries
FourierTrigSeries[expr,t,n] gives the nth-order Fourier trigonometric series expansion of expr in t.
FourierTrigSeries[expr,{t1,t2,…},{n1,n2,…}] gives the multidimensional Fourier trigonometric series of expr.
FoxHReduce
FoxHReduce[expr,x] attempts to reduce expr to a single FoxH object as a function of x.
FractionalBrownianMotionProcess
FractionalBrownianMotionProcess[μ,σ,h] represents fractional Brownian motion process with drift μ, volatility σ, and Hurst index h.
FractionalBrownianMotionProcess[h] represents fractional Brownian motion process with drift 0, volatility 1, and Hurst index h.
FractionalGaussianNoiseProcess
FractionalGaussianNoiseProcess[μ,σ,h] represents a fractional Gaussian noise process with drift μ, volatility σ, and Hurst index h.
FractionalGaussianNoiseProcess[h] represents a fractional Gaussian noise process with drift 0, volatility 1, and Hurst index h.
FractionalPart
FractionalPart[x] gives the fractional part of x.
FractionLine
FractionLine is an option for fractions that specifies the thickness of the line separating the numerator and denominator.
Frame
Frame is an option for Graphics, Grid, and other constructs that specifies whether to include a frame.
Framed
Framed[expr] displays a framed version of expr.
FrameLabel
FrameLabel is an option for Graphics, Manipulate, and related functions that specifies labels to be placed on the edges of a frame.
FrameListVideo
FrameListVideo[{img1,img2,…}] generates a video containing frames img1, img2, etc.
FrameListVideo[files] generates a video from existing image files.
FrameMargins
FrameMargins is an option for objects that can be displayed with frames which specifies the absolute margins in printer's points to leave inside the frame.
FrameRate
FrameRate is an option to specify the number of frames per second.
FrameStyle
FrameStyle is an option for Graphics, Grid, and other constructs that specifies the style in which to draw frames.
FrameTicks
FrameTicks is an option for 2D graphics functions that specifies tick marks for the edges of a frame.
FrameTicksStyle
FrameTicksStyle is an option for 2D graphics functions that specifies how frame ticks should be rendered.
FRatioDistribution
FRatioDistribution[n,m] represents an F-ratio distribution with n numerator and m denominator degrees of freedom.
FrechetDistribution
FrechetDistribution[α,β] represents the Fréchet distribution with shape parameter α and scale parameter β.
FrechetDistribution[α,β,μ] represents the Fréchet distribution with shape parameter α, scale parameter β, and location parameter μ.
FreeQ
FreeQ[expr,form] yields True if no subexpression in expr matches form, and yields False otherwise.
FreeQ[expr,form,levelspec] tests only those parts of expr on levels specified by levelspec.
FreeQ[form] represents an operator form of FreeQ that can be applied to an expression.
FrequencySamplingFilterKernel
FrequencySamplingFilterKernel[{a1,…,ak}] creates a finite impulse response (FIR) filter kernel using a frequency sampling method from amplitude values ai.
FrequencySamplingFilterKernel[{a1,…,ak},m] creates an FIR filter kernel of type m.
FresnelC
FresnelC[z] gives the Fresnel integral C(z).
FresnelF
FresnelF[z] gives the Fresnel auxiliary function F(z).
FresnelG
FresnelG[z] gives the Fresnel auxiliary function G(z).
FresnelS
FresnelS[z] gives the Fresnel integral S(z).
Friday
Friday is a day of the week.
FrobeniusNumber
FrobeniusNumber[{a1,…,an}] gives the Frobenius number of a1,…,an.
FrobeniusSolve
FrobeniusSolve[{a1,…,an},b] gives a list of all solutions of the Frobenius equation a1x1+…+anxnb.
FrobeniusSolve[{a1,…,an},b,m] gives at most m solutions.
FromAbsoluteTime
FromAbsoluteTime[time] gives a date object corresponding to an absolute time specification as given by AbsoluteTime.
FromCharacterCode
FromCharacterCode[n] gives a string consisting of the character with integer code n.
FromCharacterCode[{n1,n2,…}] gives a string consisting of the sequence of characters with codes ni.
FromCharacterCode[{{n11,n12,…},{n21,…},…}] gives a list of strings.
FromCharacterCode[codes,"encoding"] uses the specified character encoding.
FromCoefficientRules
FromCoefficientRules[list,{x1,x2,…}] constructs a polynomial from a list of rules for exponent vectors and coefficients.
FromContinuedFraction
FromContinuedFraction[list] reconstructs a number from the list of its continued fraction terms.
FromDate
FromDate[date] converts a date of the form {y,m,d,h,m,s} to an absolute number of seconds since the beginning of January 1, 1900.
FromDateString
FromDateString["string"] gives a date object corresponding to the date represented by "string".
FromDateString["string",{e1,e2,…}] gives the date object obtained by extracting elements "ei" from "string".
FromDateString["string",fmt] gives the date object obtained using the date format fmt.
FromDigits
FromDigits[list] constructs an integer from the list of its decimal digits.
FromDigits[list,b] takes the digits to be given in base b.
FromDigits[list,MixedRadix[blist]] uses the mixed radix with list of bases blist.
FromDigits["string"] constructs an integer from a string of digits.
FromDigits["string","Roman"] constructs an integer from Roman numerals.
FromDMS
FromDMS[{d,m,s}] converts from degrees, minutes, and seconds to decimal degrees.
FromDMS["dms"] converts from a DMS string to decimal degrees.
FromDMS["latlon"] converts from a latitude-longitude string to latitude and longitude in decimal degrees.
FromEntity
FromEntity[entity] returns a Wolfram Language object corresponding to an entity.
FromJulianDate
FromJulianDate[jd] gives a date object corresponding to the Julian date jd.
FromJulianDate["type",jd] gives a date object corresponding to the specified Julian date variant.
FromLetterNumber
FromLetterNumber[n] gives the lowercase letter at position n in the English alphabet.
FromLetterNumber[n,alpha] gives the letter at position n in the alphabet specified by alpha.
FromPolarCoordinates
FromPolarCoordinates[{r,θ}] gives the {x,y} Cartesian coordinates corresponding to the polar coordinates {r,θ}.
FromPolarCoordinates[{r,θ1,…,θn-2,ϕ}] gives the coordinates corresponding to the hyperspherical coordinates {r,θ1,…,θn-2,ϕ}
FromRomanNumeral
FromRomanNumeral["string"] gives the integer corresponding to the Roman numeral "string".
FromSphericalCoordinates
FromSphericalCoordinates[{r,θ,ϕ}] gives the {x,y,z} Cartesian coordinates corresponding to the spherical coordinates {r,θ,ϕ}.
FromUnixTime
FromUnixTime[time] gives a date object corresponding to a UnixTime specification.
Full
Full is a setting used for certain options, typically indicating that a full range of values should be included.
FullAxes
FullAxes[graphics] returns the axes options of a graphics object.
FullDefinition
FullDefinition[symbol] prints as the definitions given for symbol, and all symbols on which these depend.
FullDefinition["symbol"] prints as the definitions given for the symbol named "symbol" if it exists, and all symbols on which these depend.
FullDefinition[patt] prints as the definitions given for the symbols whose names textually match the arbitrary string pattern patt, and all symbols on which these depend.
FullDefinition[{spec1,spec2,…}] prints as the definitions given for the symbols that are equal to or whose names match any of the speci, and all symbols on which these depend.
FullForm
FullForm[expr] prints as the full form of expr, with no special syntax.
FullGraphics
FullGraphics[g] takes a graphics object, and generates a new one in which objects specified by graphics options are given as explicit lists of graphics primitives.
FullInformationOutputRegulator
FullInformationOutputRegulator[sys,rspec] gives the full state information output regulator for sys using specification rspec.
FullInformationOutputRegulator[{sys,{out1,…},{in1,…}},…] specifies the regulated outputs outi and the controlled inputs inj.
FullRegion
FullRegion[n] represents the full region n.
FullSimplify
FullSimplify[expr] tries a wide range of transformations on expr involving elementary and special functions and returns the simplest form it finds.
FullSimplify[expr,assum] does simplification using assumptions.
Function
body& or Function[body] is a pure (or "anonymous") function. The formal parameters are # (or #1), #2, etc.
x|->body or xbody or Function[x,body] is a pure function with a single formal parameter x.
{x1,x2,…}|->body or {x1,x2,…}body or Function[{x1,x2,…},body] is a pure function with a list of formal parameters.
Function[params,body,attrs] is a pure function that is treated as having attributes attrs for purposes of evaluation.
FunctionAnalytic
FunctionAnalytic[f,x] tests whether f(x) is an analytic function for x∈Reals.
FunctionAnalytic[f,x,dom] tests whether f(x) is an analytic function for x∈dom.
FunctionAnalytic[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…),f2(x1,x2,…),… are analytic functions for x1,x2,…∈dom.
FunctionAnalytic[{funs,cons},xvars,dom] tests whether funs(xvars) are analytic functions for xvars in an open set containing the solutions of the constraints cons over the domain dom.
FunctionBijective
FunctionBijective[f,x] tests whether f(x)y has exactly one solution x∈Reals for each y∈Reals.
FunctionBijective[f,x,dom] tests whether f(x)y has exactly one solution x∈dom for each y∈dom.
FunctionBijective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has exactly one solution x1,x2,…∈dom for each y1,y2,…∈dom.
FunctionBijective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has exactly one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons.
FunctionCompile
FunctionCompile[f] generates a compiled code function from a pure function.
FunctionCompile[{f1,f2,…}] generates a list of compiled code functions from a list of pure functions.
FunctionCompile[<|k1->f1,k2->f2,…|>] generates an association of compiled code functions from an association of Wolfram Language functions.
FunctionCompile[defs,fspec] uses the local auxiliary definitions defs.
FunctionCompileExport
FunctionCompileExport["file.ext",fspec] exports a compiled version of functions fspec in the format specified by the file extension ext.
FunctionCompileExport[path,defs,fspec] exports a compiled version of fspec using local auxiliary definitions defs.
FunctionCompileExport[path,fspec,"format"] exports in the specified format.
FunctionCompileExport[path,defs,fspec,"format"] exports a compiled version using local auxiliary definitions.
FunctionCompileExportByteArray
FunctionCompileExportByteArray[fspec] gives a byte array of binary LLVM code obtained by compiling the function specification fspec.
FunctionCompileExportByteArray[defs,fspec] uses the auxiliary definitions defs for compilation.
FunctionCompileExportByteArray[fspec,"format"] gives a byte array of binary code in the specified format.
FunctionCompileExportLibrary
FunctionCompileExportLibrary[file,fspec] exports a compiled version of function specification fspec as a shared library suitable for external use.
FunctionCompileExportLibrary[file,defs,fspec] uses the auxiliary definitions defs for compilation.
FunctionCompileExportString
FunctionCompileExportString[fspec] gives a string of textual LLVM code obtained by compiling the function specification fspec.
FunctionCompileExportString[defs,fspec] uses the auxiliary definitions defs for compilation.
FunctionCompileExportString[fspec,"format"] gives a string of textual code in the specified format.
FunctionContinuous
FunctionContinuous[f,x] tests whether f(x) is a real-valued continuous function for x∈Reals.
FunctionContinuous[f,x,dom] tests whether f(x) is a continuous function for x∈dom.
FunctionContinuous[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…),f2(x1,x2,…),… are continuous functions for x1,x2,…∈dom.
FunctionContinuous[{funs,cons},xvars,dom] tests whether funs(xvars) are continuous functions for xvars∈dom restricted by the constraints cons.
FunctionConvexity
FunctionConvexity[f,{x1,x2,…}] finds the convexity of the function f with variables x1,x2,… over the reals.
FunctionConvexity[{f,cons},{x1,x2,…}] finds the convexity when variables are restricted by the constraints cons representing a convex region.
FunctionDeclaration
FunctionDeclaration[name,typedfun] declares name to be a typed function suitable for use in a compiler environment.
FunctionDiscontinuities
FunctionDiscontinuities[f,x] finds the discontinuities of f(x) for x∈Reals.
FunctionDiscontinuities[f,x,dom] finds the discontinuities of f(x) for x∈dom.
FunctionDiscontinuities[{f1,f2,…},{x1,x2,…},dom] finds the discontinuities of f1(x1,x2,…),f2(x1,x2,…),… for x1,x2,…∈dom.
FunctionDomain
FunctionDomain[f,x] finds the largest domain of definition of the real function f of the variable x.
FunctionDomain[f,x,dom] considers f to be a function with arguments and values in the domain dom.
FunctionDomain[funs,vars,dom] finds the largest domain of definition of the mapping funs of the variables vars.
FunctionDomain[{funs,cons},vars,dom] finds the domain of funs with the values of vars restricted by constraints cons.
FunctionExpand
FunctionExpand[expr] tries to expand out special and certain other functions in expr, when possible reducing compound arguments to simpler ones.
FunctionExpand[expr,assum] expands using assumptions.
FunctionInjective
FunctionInjective[f,x] tests whether f(x)y has at most one solution x∈Reals for each y.
FunctionInjective[f,x,dom] tests whether f(x)y has at most one solution x∈dom.
FunctionInjective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has at most one solution x1,x2, …∈dom.
FunctionInjective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has at most one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons.
FunctionInterpolation
FunctionInterpolation[expr,{x,xmin,xmax}] evaluates expr with x running from xmin to xmax and constructs an InterpolatingFunction object which represents an approximate function corresponding to the result.
FunctionInterpolation[expr,{x,xmin,xmax},{y,ymin,ymax},…] constructs an InterpolatingFunction object with several arguments.
FunctionLayer
FunctionLayer[f] represents a net layer that applies function f to its input.
FunctionMeromorphic
FunctionMeromorphic[f,x] tests whether f(x) is a meromorphic function of x.
FunctionMeromorphic[f,{x1,x2,…}] tests whether f1(x1,x2,…) is a meromorphic function of x1,x2,….
FunctionMeromorphic[{f1,f2,…},{x1,x2,…}] tests whether f1(x1,x2,…),f2(x1,x2,…),… are meromorphic functions for x1,x2,….
FunctionMeromorphic[{funs,cons},xvars] tests whether funs(xvars) are meromorphic functions for xvars in an open set containing the solutions of the constraints cons.
FunctionMonotonicity
FunctionMonotonicity[f,x] finds the monotonicity of the function f with the variable x over the reals.
FunctionMonotonicity[f,x,dom] finds the monotonicity of f when x is restricted to the domain dom.
FunctionMonotonicity[{f,cons},x,dom] gives the monotonicity of f when x is restricted by the constraints cons.
FunctionPeriod
FunctionPeriod[f,x] gives a period p of the function f over the reals such that f(x+p)f(x).
FunctionPeriod[f,x,dom] gives a period with x restricted to the domain dom.
FunctionPeriod[{f1,f2,…},{x1,x2,…},…] gives periods {p1,p2,…} for {x1,x2,…} such that f(x1+p1,x2+p2,…)f(x1,x2,…).
FunctionPoles
FunctionPoles[f,x] finds the poles of the meromorphic function f with the variable x.
FunctionPoles[{f,cons},x] gives the poles of f when x is restricted by the constraints cons.
FunctionRange
FunctionRange[f,x,y] finds the range of the real function f of the variable x returning the result in terms of y.
FunctionRange[f,x,y,dom] considers f to be a function with arguments and values in the domain dom.
FunctionRange[funs,xvars,yvars,dom] finds the range of the mapping funs of the variables xvars returning the result in terms of yvars.
FunctionRange[{funs,cons},xvars,yvars,dom] finds the range of the mapping funs with the values of xvars restricted by constraints cons.
FunctionSign
FunctionSign[f,{x1,x2,…}] finds the real sign of the function f with variables x1,x2,… over the reals.
FunctionSign[f,{x1,x2,…},dom] finds the real sign with variables restricted to the domain dom.
FunctionSign[{f,cons},{x1,x2,…},dom] gives the sign when variables are restricted by the constraints cons.
FunctionSingularities
FunctionSingularities[f,x] finds the singularities of f(x) for x∈Reals.
FunctionSingularities[f,x,dom] finds the singularities of f(x) for x∈dom.
FunctionSingularities[{f1,f2,…},{x1,x2,…},dom] finds the singularities of f1(x1,x2,…),f2(x1,x2,…),… for x1,x2,…∈dom.
FunctionSpace
FunctionSpace is an option for FindSequenceFunction and related functions that specifies the space of functions to consider for representations.
FunctionSurjective
FunctionSurjective[f,x] tests whether f(x)y has at least one solution x∈ for each y∈Reals.
FunctionSurjective[f,x,dom] tests whether f(x)y has at least one solution x∈dom for each y∈dom.
FunctionSurjective[{f1,f2,…},{x1,x2,…},dom] tests whether f1(x1,x2,…)y1,f2(x1,x2,…)y2,… has at least one solution x1,x2,…∈dom for each y1,y2,…∈dom.
FunctionSurjective[{funs,xcons,ycons},xvars,yvars,dom] tests whether funs(xvars)yvars has at least one solution with xvars∈dom restricted by the constraints xcons for each yvars∈dom restricted by the constraints ycons.
FussellVeselyImportance
FussellVeselyImportance[rdist,t] gives the Fussell–Vesely importances for all components in the ReliabilityDistribution rdist at time t.
FussellVeselyImportance[fdist,t] gives the Fussell–Vesely importances for all components in the FailureDistribution fdist at time t.
GaborFilter
GaborFilter[data,r,k] filters data by convolving with a Gabor kernel of pixel radius r and wave vector k.
GaborFilter[data,r,k,ϕ] uses a Gabor kernel with phase shift ϕ.
GaborFilter[data,{r,σ},…] uses a Gabor kernel with radius r and standard deviation σ.
GaborWavelet
GaborWavelet[] represents a Gabor wavelet of frequency 6.
GaborWavelet[w] represents a Gabor wavelet of frequency w.
GainMargins
GainMargins[lsys] gives the gain margins of the linear time-invariant system lsys.
GainPhaseMargins
GainPhaseMargins[lsys] gives the gain and phase margins of the linear time-invariant system lsys.
GalaxyData
GalaxyData[entity,property] gives the value of the specified property for the galaxy entity.
GalaxyData[{entity1,entity2,…},property] gives a list of property values for the specified galaxy entities.
GalaxyData[entity,property,annotation] gives the specified annotation associated with the given property.
GalleryView
GalleryView[{expr1,expr2,…}] represents an object in which the expri are displayed in a browsable gallery layout.
GalleryView[{assoc1,assoc2,…}] uses each of the associations associ to define the display of an item in the gallery.
Gamma
Gamma[z] is the Euler gamma function Γ(z).
Gamma[a,z] is the incomplete gamma function Γ(a,z).
Gamma[a,z0,z1] is the generalized incomplete gamma function Γ(a,z0)-Γ(a,z1).
GammaDistribution
GammaDistribution[α,β] represents a gamma distribution with shape parameter α and scale parameter β.
GammaDistribution[α,β,γ,μ] represents a generalized gamma distribution with shape parameters α and γ, scale parameter β, and location parameter μ.
GammaRegularized
GammaRegularized[a,z] is the regularized incomplete gamma function Q(a,z).
GapPenalty
GapPenalty is an option for SequenceAlignment and related functions that gives the additional cost associated with each gap corresponding to a run of insertions or deletions.
GARCHProcess
GARCHProcess[κ,{α1,…,αq},{β1,…,βp}] represents a generalized autoregressive conditionally heteroscedastic process of orders p and q, driven by a standard white noise.
GARCHProcess[κ,{α1,…,αq},{β1,…,βp},init] represents a GARCH process with initial data init.
GatedRecurrentLayer
GatedRecurrentLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors each of size n.
GatedRecurrentLayer[n,opts] includes options for initial weights and other parameters.
Gather
Gather[list] gathers the elements of list into sublists of identical elements.
Gather[list,test] applies test to pairs of elements to determine if they should be considered identical.
GatherBy
GatherBy[list,f] gathers into sublists each set of elements in list that gives the same value when f is applied.
GatherBy[list,{f1,f2,…}] gathers list into nested sublists using fi at level i.
GaugeFaceElementFunction
GaugeFaceElementFunction is an option for gauge functions that gives a function to use to generate the primitives for rendering the gauge face.
GaugeFaceStyle
GaugeFaceStyle is an option for gauge functions that specifies the style in which the face is to be drawn.
GaugeFrameElementFunction
GaugeFrameElementFunction is an option for gauge functions that gives a function to generate the primitives for rendering the gauge frame.
GaugeFrameSize
GaugeFrameSize is an option for gauge functions that controls the size of the frame around the gauge.
GaugeFrameStyle
GaugeFrameStyle is an option for gauge functions that specifies the style in which the frame is to be drawn.
GaugeLabels
GaugeLabels is an option for gauge functions that specifies labels to be placed on the gauge.
GaugeMarkers
GaugeMarkers is an option for gauge functions that specifies what markers to draw to mark the values.
GaugeStyle
GaugeStyle is an option for gauge functions that specifies styles in which the markers are to be drawn.
GaussianIntegers
GaussianIntegers is an option for FactorInteger, PrimeQ, Factor, and related functions that specifies whether factorization should be done over Gaussian integers.
GaussianOrthogonalMatrixDistribution
GaussianOrthogonalMatrixDistribution[σ,n] represents a Gaussian orthogonal matrix distribution with matrix dimensions {n,n} and scale parameter σ.
GaussianOrthogonalMatrixDistribution[n] represents a Gaussian orthogonal matrix distribution with unit scale parameter.
GaussianSymplecticMatrixDistribution
GaussianSymplecticMatrixDistribution[σ,n] represents a Gaussian symplectic matrix distribution with matrix dimensions {2 n,2 n} over the field of complex numbers and scale parameter σ.
GaussianSymplecticMatrixDistribution[n] represents a Gaussian symplectic matrix distribution with unit scale parameter.
GaussianUnitaryMatrixDistribution
GaussianUnitaryMatrixDistribution[σ,n] represents a Gaussian unitary matrix distribution with matrix dimensions {n,n} and scale parameter σ.
GaussianUnitaryMatrixDistribution[n] represents a Gaussian unitary matrix distribution with unit scale parameter.
GaussianWindow
GaussianWindow[x] represents a Gaussian window function of x.
GaussianWindow[x,σ] uses standard deviation σ.
GCD
GCD[n1,n2,…] gives the greatest common divisor of the ni.
GegenbauerC
GegenbauerC[n,m,x] gives the Gegenbauer polynomial Cn(m)(x).
GegenbauerC[n,x] gives the renormalized form "lim"+m->0�/m.
General
General is a symbol to which general system messages are attached.
GenerateAsymmetricKeyPair
GenerateAsymmetricKeyPair[] randomly generates a PrivateKey and corresponding PublicKey object for use with public-key cryptographic functions.
GenerateAsymmetricKeyPair[type] randomly generates private and public keys of the specified type.
GenerateAsymmetricKeyPair[opts] randomly generates keys using the specified options.
GenerateConditions
GenerateConditions is an option for Integrate, Sum, and similar functions that specifies whether explicit conditions on parameters should be generated in the result.
GeneratedAssetFormat
GeneratedAssetFormat is an option for functions like VideoGenerator that specifies the format of the resulting asset.
GeneratedAssetLocation
GeneratedAssetLocation is an option for functions like VideoGenerator that specifies the location of the resulting asset.
GeneratedDocumentBinding
GeneratedDocumentBinding is an option for supplying parameters to a DocumentGenerator during manual evaluation.
GenerateDerivedKey
GenerateDerivedKey[password] generates a DerivedKey object from the password given.
GenerateDerivedKey[password,salt] generates a DerivedKey object from the password and salt given.
GenerateDigitalSignature
GenerateDigitalSignature[expr,key] generates a digital signature for expr using the specified private key.
GenerateDigitalSignature[key] represents an operator form of GenerateDigitalSignature that can be applied to expressions.
GeneratedParameters
GeneratedParameters is an option that specifies how parameters generated to represent the results of various symbolic operations should be named.
GeneratedQuantityMagnitudes
GeneratedQuantityMagnitudes is an option that specifies how quantities generated to represent the quantity multiplier results in NondimensionalizationTransform should be named.
GenerateFileSignature
GenerateFileSignature["file",key] generates a digital signature of file using the specified private key.
GenerateFileSignature[{"file",range},key] generates a digital signature of the specified range of bytes in the file.
GenerateFileSignature[{{file1,range1},{file2,range2},…},key] generates digital signatures for each specified filei and rangei.
GenerateFileSignature[key] represents an operator form of GenerateFileSignature that can be applied to files.
GenerateSecuredAuthenticationKey
GenerateSecuredAuthenticationKey[] generates a new anonymous SecuredAuthenticationKey owned by the current user ID.
GenerateSecuredAuthenticationKey["name"] generates a new SecuredAuthenticationKey with the specified name owned by the current user ID.
GenerateSecuredAuthenticationKey[SecuredAuthenticationKey[…]] generates a new set of credentials for an existing SecuredAuthenticationKey.
GenerateSymmetricKey
GenerateSymmetricKey[] randomly generates a SymmetricKey object suitable for use with cryptographic functions.
GenerateSymmetricKey["password"] derives a SymmetricKey object from the password string given.
GenerateSymmetricKey[bytes] generates a SymmetricKey object using the byte array or list of bytes directly as the key.
GenerateSymmetricKey[DerivedKey[…]] generates a symmetric key object with a key given by the DerivedKey object.
GenerateSymmetricKey[opts] randomly generates a symmetric key using the specified options.
GeneratingFunction
GeneratingFunction[expr,n,x] gives the generating function in x for the sequence whose nth series coefficient is given by the expression expr.
GeneratingFunction[expr,{n1,…,nm},{x1,…,xm}] gives the multidimensional generating function in x1,…,xm whose n1,… ,nm coefficient is given by expr.
GeneratorDescription
GeneratorDescription is an option for providing a textual description for a DocumentGenerator.
GeneratorHistoryLength
GeneratorHistoryLength is an option for document generators controlling the number of runs archived in the cloud.
GeneratorOutputType
GeneratorOutputType is an option controlling the file format of documents produced by a DocumentGenerator.
Generic
Generic is a setting for the Mode option of Solve and related functions.
GenericCylindricalDecomposition
GenericCylindricalDecomposition[ineqs,{x1,x2,…}] finds the full-dimensional part of the decomposition of the region represented by the inequalities ineqs into cylindrical parts whose directions correspond to the successive xi, together with any hypersurfaces containing the rest of the region.
GenomeData
GenomeData["gene"] gives the DNA sequence for the specified gene on the reference human genome.
GenomeData["gene","property"] gives the value of the specified property for the human gene gene.
GenomeData[{"chr",{n1,n2}}] gives the sequence from positions n1 to n2 on chromosome chr in the reference human genome.
GenomeLookup
GenomeLookup["seq"] returns the positions of exact matches for the DNA sequence seq on the reference human genome.
GenomeLookup["seq",n] returns at most n matches.
GeoAntipode
GeoAntipode[loc] gives the antipodal position of location loc.
GeoAntipode[g] gives the antipodal primitive of the geo primitive g.
GeoArea
GeoArea[g] gives the area of the geo region g.
GeoArraySize
GeoArraySize is an option for geographic data functions that determines the dimensions of the array generated.
GeoBackground
GeoBackground is an option that specifies the background style of a GeoGraphics object.
GeoBoundary
GeoBoundary[g] returns the boundary line of the geo region g.
GeoBounds
GeoBounds[g] gives the ranges of latitudes and longitudes in the geo region g.
GeoBounds[g,δ] pads ranges of latitudes and longitudes by ±δ.
GeoBounds[g,Scaled[s]] pads range of latitudes and longitudes by a scaled amount s.
GeoBoundsRegion
GeoBoundsRegion[{{latmin,latmax},{lonmin,lonmax}}] is a two-dimensional GeoGraphics primitive that represents a geo region bounded by parallels latmin, latmax and meridians lonmin, lonmax on the surface of the Earth.
GeoBoundsRegion[g] represents the latitude-longitude bounding box of the geo region g.
GeoBoundsRegion[g,δ] pads the ranges of latitudes and longitudes by ±δ.
GeoBoundsRegionBoundary
GeoBoundsRegionBoundary[{{latmin,latmax},{lonmin,lonmax}}] is a one-dimensional GeoGraphics primitive that represents the boundary of the region between parallels latmin, latmax and meridians lonmin, lonmax on the surface of the Earth.
GeoBoundsRegionBoundary[g] represents the boundary of the latitude-longitude bounding box of the geo region g.
GeoBoundsRegionBoundary[g,δ] pads the ranges of latitudes and longitudes by ±δ.
GeoBubbleChart
GeoBubbleChart[{reg1->val1,reg2->val2,…}] makes a geo bubble chart with bubbles centered at the geographic regions regi with sizes vali.
GeoBubbleChart[regions->values] uses a collection of regions regi from regions with corresponding sizes vali from values.
GeoBubbleChart[{data1,data2,…}] plots data from all the datai.
GeoBubbleChart[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.
GeoCenter
GeoCenter is an option for GeoGraphics that specifies the coordinates of the point that should appear at the geographic center of the final map.
GeoCircle
GeoCircle[loc,r] is a two-dimensional GeoGraphics primitive that represents a circle of radius r centered at the location loc on the surface of the Earth.
GeoCircle[loc,r,{α1,α2}] represents a sector of a circle from bearing α1 to bearing α2.
GeoContourPlot
GeoContourPlot[{loc1->val1,loc2->val2,…}] makes a geo contour plot from values vali defined at specified locations loci.
GeoContourPlot[locs->vals] uses a collection of locations locs with corresponding values vals.
GeoDensityPlot
GeoDensityPlot[{loc1->val1,loc2->val2,…}] makes a geo density plot with colors at the location loci determined by the value vali.
GeoDensityPlot[locs->vals] uses a collection of locations locs with corresponding values vals.
GeodesicClosing
GeodesicClosing[image,ker] gives the geodesic closing of image with respect to the structuring element ker.
GeodesicClosing[image,r] gives the geodesic closing with respect to a range r square.
GeodesicClosing[data,…] applies geodesic closing to an array of data.
GeodesicDilation
GeodesicDilation[marker,mask] gives the fixed point of the geodesic dilation of the marker constrained by the mask.
GeodesicErosion
GeodesicErosion[marker,mask] gives the fixed point of the geodesic erosion of the marker constrained by the mask.
GeodesicOpening
GeodesicOpening[image,ker] gives the geodesic opening of image with respect to the structuring element ker.
GeodesicOpening[image,r] gives the geodesic opening with respect to a range r square.
GeodesicOpening[data,…] applies geodesic opening to an array of data.
GeoDestination
GeoDestination[loc,{d,α}] gives the end position of the geodesic of length d starting from loc with azimuthal direction α.
GeodesyData
GeodesyData["name","property"] gives the value of the specified property for a named geodetic datum or reference ellipsoid.
GeodesyData[{a,b},"property"] gives the value of the property for the ellipsoid with semimajor axis a and semiminor axis b.
GeodesyData[obj,{"property",coords}] gives the value of the property at the specified coordinates.
GeoDirection
GeoDirection[{lat1,lon1},{lat2,lon2}] gives the azimuthal direction from one latitude-longitude position on the Earth to another.
GeoDirection[loc1,loc2] gives the azimuthal direction between locations specified by position objects or geographic entities.
GeoDisk
GeoDisk[loc,r] is a two-dimensional GeoGraphics primitive that represents a filled disk of radius r centered at the location loc on the surface of the Earth.
GeoDisk[loc,r,{α1,α2}] gives a sector of a disk from bearing α1 to bearing α2.
GeoDisplacement
GeoDisplacement[{dist,α}] represents a geodesic displacement of length dist and initial bearing α from a geo location.
GeoDisplacement[{dist,α},pathtype] represents a displacement of length dist and initial bearing α along a path of type pathtype.
GeoDisplacement[loc1,loc2,pathtype] returns the displacement needed to reach loc2 from loc1 along a path of type pathtype.
GeoDistance
GeoDistance[{lat1,lon1},{lat2,lon2}] gives the geodesic distance between latitude-longitude positions on the Earth.
GeoDistance[loc1,loc2] gives the distance between locations specified by position objects or geographical entities.
GeoDistance[{loc1,…,locn}] gives the total distance from loc1 to locn through all the intermediate loci.
GeoDistanceList
GeoDistanceList[{loc1,loc2,…,locn}] returns the list of geodesic distances between consecutive pairs of locations.
GeoElevationData
GeoElevationData[] gives the elevation above sea level at $GeoLocation.
GeoElevationData[loc] gives the elevation at the geographic location loc.
GeoElevationData[{loc1,loc2}] gives an array of elevation values within the bounding box given by {loc1,loc2}.
GeoElevationData[GeoPosition[{{lat1,lon1},{lat2,lon2},…}]] gives the list of elevations at the positions {lati,loni}.
GeoElevationData[loc,etype] gives the elevation of type etype for the location loc.
GeoElevationData[loc,etype,format] gives the elevation in the specified format.
GeoEntities
GeoEntities[reg,enttype] gives a list of the geographic entities of type enttype contained in the extended region reg.
GeoEntities[reg] gives a list of the geographic regions of any type contained in reg.
GeoGraphics
GeoGraphics[primitives,options] represents a two-dimensional geographical image.
GeoGraphPlot
GeoGraphPlot[{e1,e2,…}] generates a plot of the geographic graph with edges ei.
GeoGraphPlot[{v1,v2,…},{e1,e2,…}] generates a plot with vertices vi and edges ej.
GeoGraphPlot[{vi->vj,…}] uses rules vi->vj to specify the graph.
GeoGraphPlot[g] displays the graph g with vertices at geographic locations on a map.
GeoGraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
GeoGraphValuePlot
GeoGraphValuePlot[{{src1,dest1,flow1},{src2,dest2,flow2},…,{srcn,destn,flown}}] plots the flows between geo locations.
GeoGraphValuePlot[{{e1,val1},{e2,val2},…}] plots the values vali for the edges ei.
GeoGraphValuePlot[g] plots the flow for a graph g with associated edge weights.
GeogravityModelData
GeogravityModelData[] returns the gravitational field data for the current location.
GeogravityModelData[locationspec] returns the gravitational field data for a location.
GeogravityModelData[locationspec,component] returns the component of the gravitational field.
GeoGridDirectionDifference
GeoGridDirectionDifference[proj,loc,β] gives the difference between the angle from north to direction β on the geo grid obtained with projection proj and the actual angle from north to direction β at location loc.
GeoGridDirectionDifference[proj,loc,α->β] gives the difference between projected and unprojected angles from direction α to direction β.
GeoGridLines
GeoGridLines is an option for GeoGraphics that specifies what parallels and meridians to show.
GeoGridLinesStyle
GeoGridLinesStyle is an option for GeoGraphics that specifies how parallels and meridians should be rendered.
GeoGridPosition
GeoGridPosition[{x,y},proj] represents a point {x,y} in a planimetric cartographic grid using the projection proj.
GeoGridPosition[{x,y,h},proj] represents a point {x,y,h} in a cartographic grid with height h with respect to the reference ellipsoid.
GeoGridPosition[{{x1,y1},{x2,y2},…},proj] represents an array of cartographic grid positions.
GeoGridPosition[{x,y,h},proj,datum] represents a point in a cartographic grid obtained by projection from data in the given datum.
GeoGridPosition[entity,proj] returns the cartographic grid position of the specified geographical entity.
GeoGridRange
GeoGridRange is an option for geographic functions that specifies the range of projected coordinates to include.
GeoGridRangePadding
GeoGridRangePadding is an option for geographic functions that specifies how much to extend the projected coordinate ranges determined by GeoGridRange.
GeoGridUnitArea
GeoGridUnitArea[proj,loc] gives the actual geo area corresponding to a unit area on the geo grid obtained with projection proj, evaluated in the limit of small geo regions around location loc.
GeoGridUnitDistance
GeoGridUnitDistance[proj,loc,α] gives the actual geo distance corresponding to a unit distance on the geo grid obtained with projection proj, evaluated in the limit of small displacement from location loc in direction α.
GeoGridVector
GeoGridVector[loc->{vx,vy},proj] represents a horizontal two-dimensional vector of components vx, vy in the orthonormal frame of the coordinates of the geo projection proj, at geo location loc.
GeoGridVector[loc->{vx,vy,vz},proj] represents a three-dimensional vector of horizontal components vx, vy and vertical component vz at geo location loc.
GeoGridVector[{loc1,loc2,…}->{vec1,vec2,…},proj] represents a collection of vectors veci at respective geo locations loci.
GeoGridVector[{loc1->vec1,loc2->vec2,…},proj] represents the same collection of vectors.
GeoGridVector[vec,proj] represents a geo vector whose associated location has been implicitly specified.
GeoGroup
GeoGroup[geoobjects] represents a list of geographic objects to be treated as a single object for certain operations.
GeoHemisphere
GeoHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth centered at your current geo location.
GeoHemisphere[loc] represents the half of the Earth centered at the location loc.
GeoHemisphereBoundary
GeoHemisphereBoundary[] is a one-dimensional GeoGraphics primitive that represents the boundary line of a hemisphere of the Earth centered at the current geo location.
GeoHemisphereBoundary[loc] represents the boundary line of a hemisphere centered at the location loc.
GeoHistogram
GeoHistogram[locs] plots a density histogram of the geographic locations locs.
GeoHistogram[locs,bspec] plots a density histogram with bins specified by bspec.
GeoHistogram[locs,bspec,hspec] plots a density histogram with bin densities computed according to the specification hspec.
GeoIdentify
GeoIdentify[enttype] identifies the geographic entities of the type enttype in which the current geo location is contained.
GeoIdentify[enttype,loc] identifies the entities in which the location loc is contained.
GeoIdentify[] identifies the entities of any type in which the current geo location is contained.
GeoImage
GeoImage[reg] gives a satellite image of the geo region reg.
GeoImage[reg,mapstyle] gives an image of the geo region reg with style mapstyle.
GeoLabels
GeoLabels is an option for GeoListPlot and GeoRegionValuePlot that specifies whether and how to add labels to the locations in the first argument.
GeoLength
GeoLength[g] gives the length of the geo path g.
GeoListPlot
GeoListPlot[{loc1,loc2,…}] generates a map on which the locations loci are indicated.
GeoListPlot[{list1,list2,…}] generates a map showing several lists of locations.
GeoLocation
GeoLocation is an option for Interpreter and related functions that specifies the location to assume for semantic interpretation.
GeologicalPeriodData
GeologicalPeriodData[entity,property] gives the value of the specified property for the geological period entity.
GeologicalPeriodData[{entity1,entity2,…},property] gives a list of property values for the specified period name entities.
GeologicalPeriodData[entity,property,annotation] gives the specified annotation associated with the given property.
GeomagneticModelData
GeomagneticModelData[] returns the current magnetic field data for the current location.
GeomagneticModelData[locationspec] returns the current magnetic field data for a location.
GeomagneticModelData[datespec] returns the magnetic field data for the specified time for the current location.
GeomagneticModelData[locationspec,datespec] returns the magnetic field data for the specified time and location.
GeomagneticModelData[locationspec,datespec,component] returns the component of the magnetic field for the specified time and location.
GeoMarker
GeoMarker[] is a GeoGraphics primitive that represents a marker at the current $GeoLocation.
GeoMarker[loc] is a GeoGraphics primitive that represents a marker at the location loc.
GeoMarker[{loc1,loc2,…}] is a GeoGraphics primitive that represents markers at locations loci.
GeoMarker[loc,marker] is a GeoGraphics primitive that represents a custom marker at the location loc.
GeoMarker[{loc1,loc2,…},marker] is a GeoGraphics primitive that represents custom markers at locations loci.
GeometricAssertion
GeometricAssertion[obj,prop] represents the assertion that the geometric object obj satisfies prop.
GeometricAssertion[{obj1,obj2,…},prop] represents the assertion that the obji satisfy prop.
GeometricAssertion[objs,prop1,prop2,…] represents the assertion that objs satisfies each of the propi.
GeometricBrownianMotionProcess
GeometricBrownianMotionProcess[μ,σ,x0] represents a geometric Brownian motion process with drift μ, volatility σ, and initial value x0.
GeometricDistribution
GeometricDistribution[p] represents a geometric distribution with probability parameter p.
GeometricMean
GeometricMean[data] gives the geometric mean of the values in data.
GeometricScene
GeometricScene[{p1,p2,…},{hyp1,hyp2,…}] represents an abstract 2D geometric scene defined by the hypotheses hypi in terms of the symbolic points pi.
GeometricScene[{{p1,p2,…},{k1,k2,…}},hyps] represents a scene whose hypotheses depend on the symbolic scalar quantities ki.
GeometricScene[{{p1->{x1,y1},…},{k1->v1,…}},hyps] represents a specific instance with explicit values for all points and scalar quantities.
GeometricScene[params,hyps,{con1,con2,…}] represents a scene together with some conclusions coni about it.
GeometricScene[{{{p1->{x1,y1},…},{k1->v1,…}},…},hyps] represents a collection of specific instances of the same scene.
GeometricScene[{scene1,scene2,…}] combines several scene instances into one scene object.
GeometricStep
GeometricStep[{hyp1,hyp2,…}] gives a symbolic representation of a step in the definition of a geometric scene, in which the hypotheses hypi are introduced.
GeometricStep[hyps,label] labels the step with label when displaying an instance of the geometric scene.
GeometricTest
GeometricTest[obj,prop] tests whether the geometric object obj satisfies prop.
GeometricTest[{obj1,obj2,…},prop] tests whether the obji satisfy prop.
GeometricTest[objs,prop1,prop2,…] tests whether objs satisfy each of the propi.
GeometricTransformation
GeometricTransformation[g,tfun] represents the result of applying the transformation function tfun to the geometric objects corresponding to the primitives g.
GeometricTransformation[g,m] transforms geometric objects in g by effectively replacing every point r by m.r.
GeometricTransformation[g,{m,v}] effectively replaces every point r by m.r+v.
GeometricTransformation[g,{t1,t2,…}] represents multiple copies of g transformed by a collection of transformations.
GeoModel
GeoModel is an option for GeoGraphics that specifies the reference body or model for it for the purposes of geodetic computations and map drawing.
GeoNearest
GeoNearest[enttype,loc] returns the geographic entity of type enttype closest to the geo location loc.
GeoNearest[{reg1,reg2,…,regn},loc] returns the nearest of the regi.
GeoNearest[{reg1->val1,reg2->val2,…,regn->valn},loc] returns the vali corresponding to the nearest regi.
GeoNearest[{reg1,reg2,…,regn}->{val1,val2,…,valn},loc] returns the same result.
GeoNearest[{reg1,reg2,…,regn}->Automatic,loc] takes the vali to be successive integers i.
GeoNearest[spec,loc,n] returns n nearest values.
GeoNearest[spec,loc,{n,r}] returns up to n matches within a radius r of loc.
GeoOrientationData
GeoOrientationData[date,prop] gives the value of the property prop about the orientation of the Earth on the given date.
GeoOrientationData[date,prop,"variant"] gives the specified variant of the property prop on the given date.
GeoPath
GeoPath[{loc1,loc2},pathtype] is a GeoGraphics primitive that represents a path of type pathtype between locations loc1 and loc2.
GeoPath[{loc1,loc2,…},pathtype] represents a path formed by joining paths of type pathtype between consecutive locations loci.
GeoPath[{loc1,d,α},pathtype] represents a path moving from location loc1 a distance d with initial bearing α.
GeoPath[{{loc11,loc12,…},{loc21,…},…},pathtype] represents a disjoint collection of paths of type pathtype.
GeoPolygon
GeoPolygon[{loc1,…,locn}] is a GeoGraphics primitive that represents a filled polygon whose boundary is formed by geodesic segments between locations loci and loci+1.
GeoPolygon[{loc1,…,locn}->{{q1,…,qm},…}] represents a geo polygon with holes {q1,…,qm}, ….
GeoPolygon[{poly1,poly2,…}] represents a collection of polygons polyi.
GeoPolygon[{poly1,poly2,…},sideness] specifies which of the two sides of each boundary polyi is in the interior of the geo polygon.
GeoPolygon[polys,sideness,pathtype] represents a geo polygon whose boundary is formed by geo paths of type pathtype.
GeoPosition
GeoPosition[{lat,lon}] represents a geodetic position with latitude lat and longitude lon.
GeoPosition[{lat,lon,h}] represents a geodetic position with height h relative to the reference ellipsoid.
GeoPosition[{lat,lon,h},datum] represents a geodetic position referring to the specified datum.
GeoPosition[{{lat1,lon1},{lat2,lon2},…},datum] represents an array of geodetic positions.
GeoPosition[entity] returns the geodetic position of the specified geographical entity.
GeoPositionENU
GeoPositionENU[{east,north,up},p] represents a position with local Cartesian coordinates {east,north,up} in a reference system centered at the position p.
GeoPositionENU[{{e1,n1,u1},{e2,n2,u2},…},p] represents an array of positions.
GeoPositionENU[entity,p] returns the Cartesian position with respect to p of the specified geographical entity.
GeoPositionXYZ
GeoPositionXYZ[{x,y,z}] represents a position in a Cartesian geocentric coordinate system.
GeoPositionXYZ[{x,y,z},datum] represents a point referred to the specified datum.
GeoPositionXYZ[{{x1,y1,z1},{x2,y2,z2},…},datum] represents an array of points in a Cartesian geocentric coordinate system.
GeoPositionXYZ[entity] returns the Cartesian geocentric position of the given geographical entity.
GeoProjection
GeoProjection is an option for GeoGraphics that specifies the cartographic projection to use for the map.
GeoProjectionData
GeoProjectionData["projection","property"] gives the value of the specified property for the specified cartographic projection.
GeoProjectionData["projection"] gives the complete options for the default form of the specified projection.
GeoRange
GeoRange is an option for geographic functions that specifies the range of latitude and longitude to include.
GeoRangePadding
GeoRangePadding is an option for GeoGraphics that specifies what padding to use when extending beyond the original ranges of latitude and longitude.
GeoRegionValuePlot
GeoRegionValuePlot[{reg1->val1,reg2->val2,…}] generates a plot in which the geographic regions regi are colored according to the values vali.
GeoRegionValuePlot[regions->values] uses a collection of regions regi from regions with corresponding values vali from values.
GeoRegionValuePlot[region->prop] generates a plot in which the geographic subdivisions in region are colored according to the values EntityValue[…,prop].
GeoRegionValuePlot[data] generates a plot using the data available in data.
GeoResolution
GeoResolution is an option for geographic functions that specifies an average distance between neighboring pixels in the resulting map.
GeoScaleBar
GeoScaleBar is an option for GeoGraphics that determines what scale to show on the map.
GeoServer
GeoServer is an option for GeoGraphics, GeoStyling and GeoImage that specifies the URL address of a geo server and connection parameters to download map tiles and geo elevation data.
GeoSmoothHistogram
GeoSmoothHistogram[locs] plots a smooth kernel histogram of the geo locations locs.
GeoSmoothHistogram[locs,espec] plots a smooth kernel histogram with estimator specification espec.
GeoSmoothHistogram[locs,espec,dfun] plots the distribution function dfun.
GeoStreamPlot
GeoStreamPlot[vecs] generates a stream plot from the field of geo vectors vecs.
GeoStreamPlot[{vecs1,vecs2,…}] generates a separate set of streams for each vecsi.
GeoStyling
GeoStyling[mapstyle] displays faces of polygons and other filled geo objects using mapstyle.
GeoStyling[mapstyle,directive] uses mapstyle with the given graphics directive applied.
GeoStylingImageFunction
GeoStylingImageFunction is an option for specifying an image effect to apply to a geo style.
GeoVariant
GeoVariant[obj,qual] represents a geographic object obj with qualifier qual.
GeoVector
GeoVector[loc->{m,α}] represents a horizontal two-dimensional vector of magnitude m and bearing α at geo location loc.
GeoVector[loc->{m,α,w}] represents a three-dimensional vector of horizontal modulus m, bearing α and vertical component w at geo location loc.
GeoVector[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.
GeoVector[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.
GeoVector[vec] represents a geo vector whose associated location has been implicitly specified.
GeoVectorENU
GeoVectorENU[loc->{ve,vn}] represents a horizontal two-dimensional vector of components ve and vn in an orthonormal frame tangent to the Earth at geo location loc.
GeoVectorENU[loc->{ve,vn,vu}] represents a three-dimensional vector of horizontal components ve and vn, and vertical component vu at geo location loc.
GeoVectorENU[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.
GeoVectorENU[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.
GeoVectorENU[vec] represents a geo vector whose associated location has been implicitly specified.
GeoVectorPlot
GeoVectorPlot[vecs] generates a vector plot from the field of geo vectors vecs.
GeoVectorPlot[{vecs1,vecs2,…}] generates a separate set of vectors for each vecsi.
GeoVectorXYZ
GeoVectorXYZ[loc->{vX,vY,vZ}] represents a three-dimensional vector of Cartesian components vX, vY, vZ in an orthonormal frame parallel to the geocentric frame, at location loc.
GeoVectorXYZ[{loc1,loc2,…}->{vec1,vec2,…}] represents a collection of vectors veci at respective geo locations loci.
GeoVectorXYZ[{loc1->vec1,loc2->vec2,…}] represents the same collection of vectors.
GeoVectorXYZ[vec] represents a geo vector whose associated location has been implicitly specified.
GeoVisibleRegion
GeoVisibleRegion[{lat,lon,h}] is a two-dimensional GeoGraphics primitive that represents the region on the surface of the Earth visible from the point of coordinates lat,lon and height h above the reference ellipsoid.
GeoVisibleRegion[pos] represents the region visible from the position pos.
GeoVisibleRegion[{pos1,pos2,…}] represents the collection of regions visible from the positions posi.
GeoVisibleRegionBoundary
GeoVisibleRegionBoundary[{lat,lon,h}] is a one-dimensional GeoGraphics primitive that represents the boundary of the region on the surface of the Earth visible from the point of coordinates lat,lon and height h above the reference ellipsoid.
GeoVisibleRegionBoundary[pos] represents the boundary of the region visible from the position pos.
GeoVisibleRegionBoundary[{pos1,pos2,…}] represents the collection of boundaries of the regions visible from the positions posi.
GeoWithinQ
GeoWithinQ[reg,loc] returns True if the location loc is contained within the region reg, and False otherwise.
GeoWithinQ[reg] represents an operator form of GeoWithinQ that can be applied to a location.
GeoZoomLevel
GeoZoomLevel is an option for specifying the resolution at which to render a map.
GestureHandler
GestureHandler[expr,{gesture1fun1,gesture2fun2,…}] displays as expr, evaluating funi[value,velocity] whenever "gesturei" occurs within the screen space occupied by expr.
GestureHandler[expr,{"gesture"{fun,funend},…}] evaluates fun as updates are received for "gesture", followed by funend[value,velocity] when the gesture ends.
GestureHandler[expr,{"gesture"{funstart,fun,funend},…}] also evaluates fstart[value,velocity] when "gesture" begins.
Get
<<name reads in a file, evaluating each expression in it and returning the last one.
Get[stream] reads from a stream, evaluating each expression in it and returning the last one.
Get["file","key"] reads a file that has been encoded using Encode["source","file","key"].
GetContext
GetContext["context`"] loads the file named by ContextToFileName["context`"], which gives the conventional filename for a package that defines "context`".
GetEnvironment
GetEnvironment["var"] gives the setting corresponding to the variable "var" in the operating system environment.
GetEnvironment[{var1,var2,…}] gives a list of rules, corresponding to specified environment variables.
GetEnvironment[] gives information about all existing settings in the operating system environment.
Glaisher
Glaisher is Glaisher's constant with numerical value ≃1.28243.
GlobalClusteringCoefficient
GlobalClusteringCoefficient[g] gives the global clustering coefficient of the graph g.
GlobalClusteringCoefficient[{v->w,…}] uses rules v->w to specify the graph g.
Glow
Glow[col] is a graphics directive which specifies that surfaces of 3D graphics objects that follow are to be taken to glow with color col.
Glow[] specifies that there is no glow.
GoldenAngle
GoldenAngle is the golden angle (3-@5) π, with numerical value ≃137.5°.
GoldenRatio
GoldenRatio is the golden ratio ϕ1/2 (@5+1), with numerical value ≃1.61803.
GompertzMakehamDistribution
GompertzMakehamDistribution[λ,ξ] represents a Gompertz distribution with scale parameter λ and frailty parameter ξ.
GompertzMakehamDistribution[λ,ξ,θ,α] represents a Gompertz–Makeham distribution with parameters λ, ξ, θ, and α.
GoochShading
GoochShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with a warm color facing toward the light and a cool color facing away.
GoochShading[col] uses cool and warm colors obtained by blending col with slate Blue and Orange.
GoochShading[{ccol,wcol}] uses the cool color ccol and the warm color wcol.
GoochShading[{w1,w2}->{ccol,wcol}] uses the colors ccol and wcol weighted by the wi.
GoochShading["scheme"] uses the specified gradient color scheme in ColorData.
GoodmanKruskalGammaTest
GoodmanKruskalGammaTest[v1,v2] tests whether the vectors v1 and v2 are independent.
GoodmanKruskalGammaTest[…,"property"] returns the value of "property".
Goto
Goto[tag] scans for Label[tag], and transfers control to that point.
Grad
Grad[f,{x1,…,xn}] gives the gradient (∂f/∂x1,…,∂f/∂xn).
Grad[f,{x1,…,xn},chart] gives the gradient in the coordinates chart.
Gradient
Gradient is an option for FindMinimum and related functions that specifies the gradient vector to assume for the function being extremized.
GradientFilter
GradientFilter[data,r] gives the magnitude of the gradient of data, computed using discrete derivatives of a Gaussian of sample radius r.
GradientFilter[data,{r,σ}] uses a Gaussian with standard deviation σ.
GradientFilter[data,{{r1,r2,…},…}] uses a Gaussian with radius ri at level i in data.
GradientFittedMesh
GradientFittedMesh[{p1,p2,…}] gives a MeshRegion whose gradient best fits the normals at points p1,p2,….
GradientOrientationFilter
GradientOrientationFilter[data,r] gives the local orientation parallel to the gradient of data, computed using discrete derivatives of a Gaussian of pixel radius r, returning values between -π/2 and π/2.
GradientOrientationFilter[data,{r,σ}] uses a Gaussian with standard deviation σ.
GrammarApply
GrammarApply[grammar,input] attempts to parse input according to the grammar defined by grammar.
GrammarToken
GrammarToken[form] is a grammar rules pattern object that represents any input of the specified form.
Graph
Graph[{e1,e2,…}] yields a graph with edges ej.
Graph[{v1,v2,…},{e1,e2,…}] yields the graph with vertices vi and edges ej.
Graph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a graph with vertex and edge properties defined by the symbolic wrappers wk.
Graph[data] yields a graph from data.
Graph3D
Graph3D[g] creates a graph with vertices and edges from the graph g and represented as a 3D plot.
Graph3D[{e1,e2,…}] creates a graph with edges ej and represented as a 3D plot.
Graph3D[{v1,v2,…},{e1,e2,…}] creates a graph with vertices vi and edges ej.
GraphAssortativity
GraphAssortativity[g] gives the assortativity coefficient of a graph g using vertex degrees.
GraphAssortativity[g,"prop"] gives the assortativity coefficient of the graph g using vertex property "prop".
GraphAssortativity[g,{{vi1,vi2,…},…}] gives the assortativity coefficient of the graph g with respect to the vertex partition {{vi1,vi2,…},…}.
GraphAssortativity[g,{v1,v2,…}->{x1,x2,…}] gives the assortativity coefficient of the graph g using data {x1,x2,…} for vertices {v1,v2,…}.
GraphAssortativity[{v->w,…},…] uses rules v->w to specify the graph g.
GraphAutomorphismGroup
GraphAutomorphismGroup[g] gives the automorphism group of a graph g.
GraphAutomorphismGroup[{v->w,…}] uses rules v->w to specify the graph g.
GraphCenter
GraphCenter[g] gives the set of vertices with minimum eccentricity in the graph g.
GraphCenter[{v->w,…}] uses rules v->w to specify the graph g.
GraphComplement
GraphComplement[g] gives the graph complement of the graph g.
GraphComplement[{v->w,…}] uses rules v->w to specify the graph g.
GraphData
GraphData[name] gives a graph with the specified name.
GraphData[entity] gives the graph corresponding to the graph entity.
GraphData[entity,property] gives the value of the property for the specified graph entity.
GraphData[class] gives a list of available named graphs in the specified graph class.
GraphData[n] gives a list of available named graphs with n vertices.
GraphDensity
GraphDensity[g] gives the graph density of the graph g.
GraphDensity[{v->w,…}] uses rules v->w to specify the graph g.
GraphDiameter
GraphDiameter[g] gives the greatest distance between any pair of vertices in the graph g.
GraphDiameter[{v->w,…}] uses rules v->w to specify the graph g.
GraphDifference
GraphDifference[g1,g2] gives the graph difference of the graphs g1 and g2.
GraphDifference[{v->w,…},…] uses rules v->w to specify the graph g.
GraphDisjointUnion
GraphDisjointUnion[g1,g2] gives the graph disjoint union of the graphs g1 and g2.
GraphDisjointUnion[g1,g2,…] gives the disjoint union of g1, g2, ….
GraphDisjointUnion[{v->w,…},…] uses rules v->w to specify the graph g.
GraphDistance
GraphDistance[g,s,t] gives the distance from source vertex s to target vertex t in the graph g.
GraphDistance[g,s] gives the distance from s to all vertices of the graph g.
GraphDistance[{v->w,…},…] uses rules v->w to specify the graph g.
GraphDistanceMatrix
GraphDistanceMatrix[g] gives the matrix of distances between vertices for the graph g.
GraphDistanceMatrix[g,d] gives the matrix of distances between vertices of maximal distance d in the graph g.
GraphDistanceMatrix[{v->w,…},…] uses rules v->w to specify the graph g.
GraphEmbedding
GraphEmbedding[g] gives coordinates of the vertices of the graph g.
GraphEmbedding[g,"emb"] gives coordinates of the vertices of the graph g using the embedding "emb".
GraphEmbedding[g,"emb",dim] gives coordinates in dimension dim of the vertices of the graph g using the embedding "emb".
GraphHighlight
GraphHighlight is an option to Graph and related objects that specifies graph elements to highlight.
GraphHighlightStyle
GraphHighlightStyle is an option to Graph and related objects that specifies styles to use for highlighted graph elements.
GraphHub
GraphHub[g] gives the set of vertices with maximum vertex degree in the underlying simple graph of g.
GraphHub[g,"In"] gives the set of vertices with maximum vertex in-degree.
GraphHub[g,"Out"] gives the set of vertices with maximum vertex out-degree.
GraphHub[{v->w,…},…] uses rules v->w to specify the graph g.
Graphics
Graphics[primitives,options] represents a two-dimensional graphical image.
Graphics3D
Graphics3D[primitives,options] represents a three-dimensional graphical image.
GraphicsArray
GraphicsArray[{g1,g2,…}] represents a row of graphics objects.
GraphicsArray[{{g11,g12,…},…}] represents a two-dimensional array of graphical objects.
GraphicsColumn
GraphicsColumn[{g1,g2,…}] generates a graphic in which the gi are laid out in a column, with g1 above g2, etc.
GraphicsColumn[list,alignment] aligns each element horizontally in the specified way.
GraphicsColumn[list,alignment,spacing] leaves the specified spacing between successive elements.
GraphicsComplex
GraphicsComplex[{pt1,pt2,…},data] represents a graphics complex in which coordinates given as integers i in graphics primitives in data are taken to be pti.
GraphicsGrid
GraphicsGrid[{{g11,g12,…},…}] generates a graphic in which the gij are laid out in a two-dimensional grid.
GraphicsGroup
GraphicsGroup[{g1,g2,…}] represents a collection of graphics objects grouped together for purposes of interactive selection in a notebook.
GraphicsRow
GraphicsRow[{g1,g2,…}] generates a graphic in which the gi are laid out in a row.
GraphicsRow[list,spacing] leaves the specified spacing between successive elements.
GraphicsSpacing
GraphicsSpacing is an option for GraphicsArray that specifies the spacing between elements in the array.
GraphIntersection
GraphIntersection[g1,g2] gives the graph intersection of the graphs g1 and g2.
GraphIntersection[g1,g2,…] gives the graph intersection of g1, g2, … .
GraphIntersection[{v->w,…},…] uses rules v->w to specify the graph g.
GraphLayers
GraphLayers is an option for LayeredGraphPlot3D and related functions that specifies layers to draw on the plot.
GraphLayerStyle
GraphLayerStyle is an option for LayeredGraphPlot3D and related functions that specifies the style in which to draw a layer on the plot.
GraphLayout
GraphLayout is an option to Graph and related functions that specifies what layout to use.
GraphLinkEfficiency
GraphLinkEfficiency[g] gives the link efficiency of the graph g.
GraphLinkEfficiency[{v->w,…}] uses rules v->w to specify the graph g.
GraphPeriphery
GraphPeriphery[g] gives vertices that are maximally distant to at least one vertex in the graph g.
GraphPeriphery[{v->w,…}] uses rules v->w to specify the graph g.
GraphPlot
GraphPlot[g] generates a plot of the graph g.
GraphPlot[{e1,e2,…}] generates a plot of the graph with edges ei.
GraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
GraphPlot[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.
GraphPlot[m] uses the adjacency matrix m to specify the graph g.
GraphPlot3D
GraphPlot3D[g] generates a 3D plot of the graph g.
GraphPlot3D[{e1,e2,…}] generates a 3D plot of the graph with edges ei.
GraphPlot3D[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
GraphPlot3D[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.
GraphPlot3D[m] uses the adjacency matrix m to specify the graph g.
GraphPower
GraphPower[g,n] gives the graph-nth power of the graph g.
GraphPower[{v->w,…},…] uses rules v->w to specify the graph g.
GraphPropertyDistribution
GraphPropertyDistribution[expr,xgdist] represents the distribution of the property expr where the random variable x follows the graph distribution gdist.
GraphPropertyDistribution[expr,{x1gdist1,x2gdist2,…}] represents the distribution where x1, x2, … are independent and follow the graph distributions gdist1, gdist2, ….
GraphQ
GraphQ[g] yields True if g is a valid Graph object and False otherwise.
GraphRadius
GraphRadius[g] gives the minimum eccentricity of the vertices in the graph g.
GraphRadius[{v->w,…}] uses rules v->w to specify the graph g.
GraphReciprocity
GraphReciprocity[g] gives the reciprocity of a graph g.
GraphReciprocity[{v->w,…}] uses rules v->w to specify the graph g.
GraphStyle
GraphStyle is an option to Graph and related objects that specifies styles to use for the different graph elements.
GraphTree
GraphTree[g] constructs a tree from the tree graph g.
GraphTree[g,root] specifies what vertex to use as the root.
GraphTree[g,root,h] applies h to each vertex to get the corresponding data and ordering of subtrees.
GraphUnion
GraphUnion[g1,g2] gives the graph union of the graphs g1 and g2.
GraphUnion[g1,g2,…] gives the graph union of g1, g2, ….
GraphUnion[{v->w,…},…] uses rules v->w to specify the graph g.
Gray
Gray represents the color gray in graphics or style specifications.
GrayLevel
GrayLevel[g] represents a color in the grayscale color space with gray level g.
GrayLevel[g,a] specifies opacity a.
GrayLevel["string"] returns a color from an HTML color name etc.
GrayLevel[color] returns the grayscale representation of color.
Greater
x>y yields True if x is determined to be greater than y.
x1>x2>x3 yields True if the xi form a strictly decreasing sequence.
GreaterEqual
x>=y or x≥y yields True if x is determined to be greater than or equal to y.
x1≥x2≥x3 yields True if the xi form a nonincreasing sequence.
GreaterEqualLess
GreaterEqualLess[x,y,…] displays as x⋛y⋛….
GreaterEqualThan
GreaterEqualThan[y] is an operator form that yields x≥y when applied to an expression x.
GreaterFullEqual
GreaterFullEqual[x,y,…] displays as x≧y≧….
GreaterGreater
GreaterGreater[x,y,…] displays as x≫y≫….
GreaterLess
GreaterLess[x,y,…] displays as x≷y≷….
GreaterSlantEqual
GreaterSlantEqual[x,y,…] displays as x⩾y⩾….
GreaterThan
GreaterThan[y] is an operator form that yields x>y when applied to an expression x.
GreaterTilde
GreaterTilde[x,y,…] displays as x≳y≳….
Green
Green represents the color green in graphics or style specifications.
GreenFunction
GreenFunction[{ℒ[u[x]],ℬ[u[x]]},u,{x,xmin,xmax},y] gives a Green's function for the linear differential operator ℒ with boundary conditions ℬ in the range xmin to xmax.
GreenFunction[{ℒ[u[x1,x2,…]],ℬ[u[x1,x2,…]]},u,{x1,x2,…}∈Ω,{y1,y2,…}] gives a Green's function for the linear partial differential operator ℒ over the region Ω.
GreenFunction[{ℒ[u[x,t]],ℬ[u[x,t]]},u,{x,xmin,xmax},t,{y,τ}] gives a Green's function for the linear time-dependent operator ℒ in the range xmin to xmax.
GreenFunction[{ℒ[u[x1,…,t]],ℬ[u[x1,…,t]]},u,{x1,…}∈Ω,t,{y1,…,τ}] gives a Green's function for the linear time-dependent operator ℒ over the region Ω.
Grid
Grid[{{expr11,expr12,…},{expr21,expr22,…},…}] is an object that formats with the exprij arranged in a two-dimensional grid.
GridFrame
GridFrame is an option for grids that specifies whether a surrounding frame is drawn.
GridFrameMargins
GridFrameMargins is an option for grids that specifies the spacing between the content of the grid and the frame surrounding it.
GridGraph
GridGraph[{m,n}] gives the grid graph with m×n vertices Gm,n.
GridGraph[{n1,n2,…,nk}] gives the k-dimensional grid graph with n1×n2×⋯×nk vertices Gn1,n2,…,nk.
GridLines
GridLines is an option for two-dimensional graphics functions that specifies grid lines.
GridLinesStyle
GridLinesStyle is an option for 2D graphics functions that specifies how grid lines should be rendered.
GridVideo
GridVideo[{v1,v2,…}] creates a video in which each frame is a grid of frames of all vi at the corresponding time.
GridVideo[{{v11,v12,…},…}] uses the array position of each video vij to create the video grid.
GroebnerBasis
GroebnerBasis[{poly1,poly2,…},{x1,x2,…}] gives a list of polynomials that form a Gröbner basis for the set of polynomials polyi.
GroebnerBasis[{poly1,poly2,…},{x1,x2,…},{y1,y2,…}] finds a Gröbner basis in which the yi have been eliminated.
GroupActionBase
GroupActionBase is an option to specify a base for a group.
GroupBy
GroupBy[{elem1,elem2,…},f] gives an association that groups the elemi into lists associated with distinct keys f[elemi].
GroupBy[{elem1,elem2,…},fk->fv] groups the fv[elemi] according to the fk[elemi].
GroupBy[{elem1,elem2,…},{fs1,fs2,…}] groups into nested associations using fsi at level i.
GroupBy[{elem1,elem2,…},spec,red] applies the function red to reduce lists of values that are generated.
GroupBy[spec] represents an operator form of GroupBy that can be applied to an expression.
GroupCentralizer
GroupCentralizer[group,g] returns the centralizer of the element g in group.
GroupElementFromWord
GroupElementFromWord[group,w] returns the element of group determined by the word w in the generators of group.
GroupElementPosition
GroupElementPosition[group,g] returns the position of the element g in the list of elements of group.
GroupElementPosition[group,{g1,…,gn}] returns the list of positions of the elements g1,…,gn in group.
GroupElementQ
GroupElementQ[group,g] returns True if the object g is an element of group and False otherwise.
GroupElements
GroupElements[group] returns the list of all elements of group.
GroupElements[group,{r1,…,rk}] returns the elements numbered r1,…,rk in group in the standard order.
GroupElementToWord
GroupElementToWord[group,g] decomposes the group element g as a product of generators of group.
GroupGenerators
GroupGenerators[group] returns a list of generators of group.
Groupings
Groupings[n,k] gives a list of all possible groupings of 1,…,n taken k at a time.
Groupings[{a1,…,an},k] gives all possible groupings of a1,…,an taken k at a time.
Groupings[{{a1,a2,…},{b1,b2,…},…},k] gives the combination of all possible groupings of each of the lists ai,bi,… taken k at a time.
Groupings[aspec,f->k] gives all possible groupings of aspec taken k at a time with the function f applied at each level.
Groupings[aspec,{f1->k1,f2->k2,…}] gives all possible groupings in which the function fi is applied to ki elements.
Groupings[aspec,{{f1->k1,m1},{f2->k2,m2},…}] allows at most mi occurrences in a given grouping of fi applied to ki elements.
Groupings[aspec,kspec,h] wraps the function h around each grouping generated.
GroupMultiplicationTable
GroupMultiplicationTable[group] gives the multiplication table of group as an array.
GroupOrbits
GroupOrbits[group,{p1,…}] returns the orbits of the points pi under the action of the elements of group.
GroupOrbits[group,{p1,…},f] finds the orbits under the group action given by a function f.
GroupOrder
GroupOrder[group] returns the number of elements of group.
GroupPageBreakWithin
GroupPageBreakWithin is an option for Cell that specifies whether a page break should be allowed within the group of cells if the notebook that contains the group is printed.
GroupSetwiseStabilizer
GroupSetwiseStabilizer[group,{p1,…,pn}] returns the subgroup of group for which the images of the points pi are still in the list {p1,…,pn}.
GroupSetwiseStabilizer[group,{p1,…,pn},f] returns the setwise stabilizer subgroup under the action given by the function f.
GroupStabilizer
GroupStabilizer[group,{p1,…,pn}] returns the subgroup of elements of group that move none of the points p1, …, pn.
GroupStabilizer[group,{p1,…,pn},f] returns the stabilizer subgroup under the action given by the function f.
GroupStabilizerChain
GroupStabilizerChain[group] returns a list of successive stabilizers in group of the points in a base of group.
GrowCutComponents
GrowCutComponents[image,{marker1,marker2,…}] creates a segmentation from image by growing each markeri.
GrowCutComponents[video,…] returns segmentation for each frame in video.
Gudermannian
Gudermannian[z] gives the Gudermannian function gd(z).
GuidedFilter
GuidedFilter[image,guide,r,ϵ] filters image using the guide image guide over range-r neighborhoods with pixel-value regularizer ϵ.
GuidedFilter[image,r,ϵ] filters image so as to reduce noise, using image as the guide.
GumbelDistribution
GumbelDistribution[α,β] represents a Gumbel distribution with location parameter α and scale parameter β.
GumbelDistribution[] represents a Gumbel distribution with location parameter 0 and scale parameter 1.
HaarWavelet
HaarWavelet[] represents a Haar wavelet.
HadamardMatrix
HadamardMatrix[n] returns an n×n Hadamard matrix.
HalfLine
HalfLine[{p1,p2}] represents the half-line from the point p1 through p2.
HalfLine[p,v] represents the half-line from the point p in the direction v.
HalfNormalDistribution
HalfNormalDistribution[θ] represents a half-normal distribution with scale inversely proportional to parameter θ.
HalfPlane
HalfPlane[{p1,p2},w] represents the half-plane bounded by the line through p1 and p2 and extended in the direction w.
HalfPlane[p,v,w] represents the half-plane bounded by the line through p along v and extended in the direction w.
HalfSpace
HalfSpace[n,p] represents the half-space of points x such that n.(x-p)≤0.
HalfSpace[n,c] represents the half-space of points x such that n.x≤c.
HalftoneShading
HalftoneShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with a base pattern of dots.
HalftoneShading[d] uses the density d of shading.
HalftoneShading[col] uses dots with the specified color col.
HalftoneShading["shape"] uses the specified "shape" as base pattern.
HalftoneShading[d,col,"shape"] uses a fixed pattern of "shape" with the specified color col and density d.
HamiltonianGraphQ
HamiltonianGraphQ[g] yields True if the graph g is Hamiltonian, and False otherwise.
HammingDistance
HammingDistance[u,v] gives the Hamming distance between strings or vectors u and v.
HammingDistance[u,v] gives the Hamming distance between strings, vectors or biomolecular sequences u and v.
HammingWindow
HammingWindow[x] represents a Hamming window function of x.
HandlerFunctions
HandlerFunctions is an option that specifies functions to apply when events are generated.
HandlerFunctionsKeys
HandlerFunctionsKeys is an option that specifies the content of associations to which to apply handler functions.
HankelH1
HankelH1[n,z] gives the Hankel function of the first kind Hn(1)(z).
HankelH2
HankelH2[n,z] gives the Hankel function of the second kind Hn(2)(z).
HankelMatrix
HankelMatrix[n] gives the n×n Hankel matrix with first row and first column being successive integers.
HankelMatrix[{c1,c2,…,cn}] gives the Hankel matrix whose first column consists of entries c1, c2, ….
HankelMatrix[{c1,c2,…,cm},{r1,r2,…, rn}] gives the Hankel matrix with entries ci down the first column, and ri across the last row.
HankelTransform
HankelTransform[expr,r,s] gives the Hankel transform of order 0 for expr.
HankelTransform[expr,r,s,ν] gives the Hankel transform of order ν for expr.
HannPoissonWindow
HannPoissonWindow[x] represents a Hann–Poisson window function of x.
HannPoissonWindow[x,α] uses the parameter α.
HannWindow
HannWindow[x] represents a Hann window function of x.
HannWindow[x,α] uses the parameter α.
HaradaNortonGroupHN
HaradaNortonGroupHN[] represents the sporadic simple Harada–Norton group HN.
HararyGraph
HararyGraph[k,n] generates the minimal k-connected graph on n vertices Hk,n.
HarmonicMean
HarmonicMean[data] gives the harmonic mean of the values in data.
HarmonicNumber
HarmonicNumber[n] gives the nth harmonic number Hn.
HarmonicNumber[n,r] gives the harmonic number Hn(r) of order r.
Hash
Hash[expr] gives an integer hash code for the expression expr.
Hash[expr,type] gives an integer hash digest of the specified type for expr.
Hash[expr,type,"format"] gives a hash code in the specified format.
HatchFilling
HatchFilling[] is a two-dimensional graphics directive that specifies that faces of polygons and other filled graphics objects are to be drawn using closely spaced parallel lines.
HatchFilling["name"] uses the specified line hatching "name".
HatchFilling[θ] draws parallel lines with an angle θ.
HatchFilling[θ,r] draws parallel lines with absolute thickness r.
HatchFilling[θ,r,d] draws parallel lines with gaps of absolute thickness d.
HatchShading
HatchShading[] is a three-dimensional graphics directive specifying that objects that follow are to be drawn with closely spaced parallel lines.
HatchShading[d] uses the density d of shading.
HatchShading[col] uses lines with the specified color col.
HatchShading[d,col] uses lines with the specified color col and density d.
Haversine
Haversine[z] gives the haversine function hav(z).
HazardFunction
HazardFunction[dist,x] gives the hazard function for the distribution dist evaluated at x.
HazardFunction[dist,{x1,x2,…}] gives the multivariate hazard function for the distribution dist evaluated at {x1,x2,…}.
HazardFunction[dist] gives the hazard function as a pure function.
Head
Head[expr] gives the head of expr.
Head[expr,h] wraps the result with h.
HeadCompose
HeadCompose[a, b, c, d] gives a[b][c][d].
HeaderAlignment
HeaderAlignment is an option for Dataset that specifies how the contents of a header should be aligned within the available area in the header.
HeaderBackground
HeaderBackground is an option for Dataset that specifies what background color to use for row and column headers.
HeaderDisplayFunction
HeaderDisplayFunction is an option for Dataset that specifies a function to apply to headers before displaying them.
HeaderLines
HeaderLines is an option for SemanticImport and related functions that specifies how many of the initial rows should be considered part of a column header.
HeaderSize
HeaderSize is an option for Dataset that specifies the widths and heights of headers.
HeaderStyle
HeaderStyle is an option for Dataset that specifies the style to use for headers.
Heads
Heads is an option for functions which use level specifications that specifies whether heads of expressions should be included.
HeatFluxValue
HeatFluxValue[pred,vars,pars] represents a thermal heat flux boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatFluxValue[pred,vars,pars,lkey] represents a thermal heat flux boundary condition with local parameters specified in pars[lkey].
HeatInsulationValue
HeatInsulationValue[pred,vars,pars] represents a thermal insulation boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatInsulationValue[pred,vars,pars,lkey] represents a thermal insulation boundary condition with local parameters specified in pars[lkey].
HeatOutflowValue
HeatOutflowValue[pred,vars,pars] represents a thermal outflow boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatOutflowValue[pred,vars,pars,lkey] represents a thermal outflow boundary condition with local parameters specified in pars[lkey].
HeatRadiationValue
HeatRadiationValue[pred,vars,pars] represents a thermal radiation boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatRadiationValue[pred,vars,pars,lkey] represents a thermal radiation boundary condition with local parameters specified in pars[lkey].
HeatSymmetryValue
HeatSymmetryValue[pred,vars,pars] represents a thermal symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatSymmetryValue[pred,vars,pars,lkey] represents a thermal symmetry boundary condition with local parameters specified in pars[lkey].
HeatTemperatureCondition
HeatTemperatureCondition[pred,vars,pars] represents a thermal surface boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatTemperatureCondition[pred,vars,pars,lkey] represents a thermal surface boundary condition with local parameters specified in pars[lkey].
HeatTransferPDEComponent
HeatTransferPDEComponent[vars,pars] yields a heat transfer PDE term with variables vars and parameters pars.
HeatTransferValue
HeatTransferValue[pred,vars,pars] represents a thermal transfer boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
HeatTransferValue[pred,vars,pars,lkey] represents a thermal transfer boundary condition with local parameters specified in pars[lkey].
HeavisideLambda
HeavisideLambda[x] represents the triangle distribution Λ(x) which is nonzero for x<1.
HeavisideLambda[x1,x2,…] represents the multidimensional triangle distribution Λ(x1,x2,…) which is nonzero for xi<1.
HeavisidePi
HeavisidePi[x] represents the box distribution Π(x), equal to 1 for x<1/2 and 0 for x>1/2.
HeavisidePi[x1,x2,…] represents the multidimensional box distribution Π(x1,x2,…) which is 1 if all xi<1/2.
HeavisideTheta
HeavisideTheta[x] represents the Heaviside theta function θ(x), equal to 0 for x<0 and 1 for x>0.
HeavisideTheta[x1,x2,…] represents the multidimensional Heaviside theta function, which is 1 only if all of the xi are positive.
HeldGroupHe
HeldGroupHe[] represents the sporadic simple Held group He.
HelmholtzPDEComponent
HelmholtzPDEComponent[vars,pars] yields a Helmholtz PDE term ∇2{x1,…,xn}u+k2u with model variables vars and model parameters pars.
HelpBrowserSettings
HelpBrowserSettings is a global option that specifies settings for the legacy Help Browser.
Here
Here represents the current deduced geo location.
HermiteDecomposition
HermiteDecomposition[m] gives the Hermite normal form decomposition of an integer matrix m.
HermiteH
HermiteH[n,x] gives the Hermite polynomial Hn(x).
Hermitian
Hermitian[{1,2}] represents the symmetry of a Hermitian matrix.
HermitianMatrixQ
HermitianMatrixQ[m] gives True if m is explicitly Hermitian, and False otherwise.
HessenbergDecomposition
HessenbergDecomposition[m] gives the Hessenberg decomposition of a numerical matrix m.
HeunB
HeunB[q,α,γ,δ,ϵ,z] gives the bi-confluent Heun function.
HeunBPrime
HeunBPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunB function.
HeunC
HeunC[q,α,γ,δ,ϵ,z] gives the confluent Heun function.
HeunCPrime
HeunCPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunC function.
HeunD
HeunD[q,α,γ,δ,ϵ,z] gives the double-confluent Heun function.
HeunDPrime
HeunDPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunD function.
HeunG
HeunG[a,q,α,β,γ,δ,z] gives the general Heun function.
HeunGPrime
HeunGPrime[a,q,α,β,γ,δ,z] gives the z-derivative of the HeunG function.
HeunT
HeunT[q,α,γ,δ,ϵ,z] gives the tri-confluent Heun function.
HeunTPrime
HeunTPrime[q,α,γ,δ,ϵ,z] gives the z-derivative of the HeunT function.
HexadecimalCharacter
HexadecimalCharacter represents a hexadecimal digit character 0–9, a–f, A–F in StringExpression.
Hexahedron
Hexahedron[{p1,p2,…,p8}] represents a filled hexahedron with corners p1, p2, …, p8.
Hexahedron[{{p1,1,p1,2,…,p1,8},{p2,1,…},…}] represents a collection of hexahedra.
HiddenItems
HiddenItems is an option for Dataset that specifies which items to hide.
HiddenMarkovProcess
HiddenMarkovProcess[i0,m,em] represents a discrete-time, finite-state hidden Markov process with transition matrix m, emission matrix em, and initial hidden state i0.
HiddenMarkovProcess[…,m,{dist1,…}] represents a hidden Markov process with emission distributions disti.
HiddenMarkovProcess[p0,m,…] represents a hidden Markov process with initial hidden state probability vector p0.
HiddenSurface
HiddenSurface is an option for SurfaceGraphics which specifies whether hidden surfaces are to be eliminated.
Highlighted
Highlighted[expr] displays a highlighted version of expr.
Highlighted[expr,effect] uses the effect effect to highlight plot elements representing expr.
HighlightGraph
HighlightGraph[g,{a1,a2,…}] highlights the ai that can be vertices, edges, or subgraphs of g.
HighlightGraph[g,{…,wj[aj],…}] highlights using the symbolic wrappers wj.
HighlightGraph[{v->w,…},…] uses rules v->w to specify the graph g.
HighlightImage
HighlightImage[image,roi] highlights the specified region of interest roi in image.
HighlightImage[image,{roi1,roi2,…}] highlights several regions of interest roii.
HighlightImage[image,{…,w[roii],…}] highlights using a feature defined by the symbolic wrapper w.
HighlightImage[image,fg,bgstyle] applies the styling bgstyle to the complement of all the regions of interest.
HighpassFilter
HighpassFilter[data,ωc] applies a highpass filter with a cutoff frequency ωc to an array of data.
HighpassFilter[data,ωc,n] uses a filter kernel of length n.
HighpassFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.
HigmanSimsGroupHS
HigmanSimsGroupHS[] represents the sporadic simple Higman–Sims group HS.
HilbertCurve
HilbertCurve[n] gives the line segments representing the nth-step Hilbert curve.
HilbertCurve[n,d] gives the nth-step Hilbert curve in dimension d.
HilbertFilter
HilbertFilter[data,ωc] applies a Hilbert filter with a cutoff frequency ωc to an array of data.
HilbertFilter[data,ωc,n] uses a filter kernel of length n.
HilbertFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.
HilbertMatrix
HilbertMatrix[n] gives the n×n Hilbert matrix with elements of the form 1/(i+j-1).
HilbertMatrix[{m,n}] gives the m×n Hilbert matrix.
Histogram
Histogram[{x1,x2,…}] plots a histogram of the values xi.
Histogram[{x1,x2,…},bspec] plots a histogram with bin width specification bspec.
Histogram[{x1,x2,…},bspec,hspec] plots a histogram with bin heights computed according to the specification hspec.
Histogram[{data1,data2,…},…] plots histograms for multiple datasets datai.
Histogram3D
Histogram3D[{{x1,y1},{x2,y2},…}] plots a 3D histogram of the values {xi,yi}.
Histogram3D[{{x1,y1},{x2,y2},…},bspec] plots a 3D histogram with bins specified by bspec.
Histogram3D[{{x1,y1},{x2,y2},…},bspec,hspec] plots a 3D histogram with bin heights computed according to the specification hspec.
Histogram3D[{data1,data2,…}] plots 3D histograms for multiple datasets datai.
HistogramDistribution
HistogramDistribution[{x1,x2,…}] represents the probability distribution corresponding to a histogram of the data values xi.
HistogramDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate histogram distribution based on data values {xi,yi,…}.
HistogramDistribution[…,bspec] represents a histogram distribution with bins specified by bspec.
HistogramList
HistogramList[{x1,x2,…}] gives a list of bins and histogram heights of the values xi.
HistogramList[{{x1,y1,…},{x2,y2,…},…}] gives a list of bins and histogram heights of the values {xi,yi,…}.
HistogramList[…,bspec] gives a list of bins and histogram heights with bins specified by bspec.
HistogramList[…,bspec,hspec] gives a list of bins and histogram heights with bin heights computed according to the specification hspec.
HistogramPointDensity
HistogramPointDensity[pdata] estimates the histogram point density function μ(x) for point data pdata.
HistogramPointDensity[pdata,bspec] estimates the histogram point density function μ(x) with histogram bins specified by bspec.
HistogramPointDensity[bdata,…,…] estimates the histogram point density function μ(x) for binned data bdata.
HistogramPointDensity[pproc,…,…] computes the histogram point density function μ(x) for the point process pproc.
HistogramTransform
HistogramTransform[image] transforms pixel values of image so that its histogram is nearly flat.
HistogramTransform[image,ref] modifies pixel values of image so that its histogram would have nearly the same distribution as ref.
HistogramTransform[image,ref,n] uses n equally spaced quantiles.
HistogramTransform[{x1,x2,…},…] transforms values xi.
HistogramTransformInterpolation
HistogramTransformInterpolation[{x1,x2,…}] finds a function f so that the transformed values f(xi) are distributed nearly uniformly.
HistogramTransformInterpolation[{x1,x2,…},ref] finds f so that f(xi) are distributed with distribution ref.
HistogramTransformInterpolation[{x1,x2,…},ref,n] finds a function with n equally spaced quantiles.
HistogramTransformInterpolation[image,…] finds a function that reshapes the histogram of image.
HistoricalPeriodData
HistoricalPeriodData[entity,property] gives the value of the specified property for the historical period entity.
HistoricalPeriodData[{entity1,entity2,…},property] gives a list of property values for the specified historical period entities.
HistoricalPeriodData[entity,property,annotation] gives the specified annotation associated with the given property.
HitMissTransform
HitMissTransform[image,ker] gives the hit-or-miss transform of image with respect to the composite structuring element ker.
HitMissTransform[image,{ker1,ker2,…}] gives the union of the hit-or-miss transforms for all the structuring elements keri.
HitMissTransform[image,{ker1,ker2,…},t] treats values above t as foreground.
HITSCentrality
HITSCentrality[g] gives a list of authority and hub centralities for the vertices in the graph g.
HITSCentrality[{v->w,…}] uses rules v->w to specify the graph g.
HjorthDistribution
HjorthDistribution[m,s,f] represents the Hjorth distribution with location parameter m, scale parameter s, and shape parameter f.
HodgeDual
HodgeDual[tensor] gives the Hodge dual of the tensor
HodgeDual[tensor,dim] dualizes tensor in the slots with dimension dim
HodgeDual[tensor,dim,slots] dualizes tensor in the given slots.
HoeffdingDTest
HoeffdingDTest[v1,v2] tests whether the vectors v1 and v2 are independent.
HoeffdingDTest[…,"property"] returns the value of "property".
Hold
Hold[expr] maintains expr in an unevaluated form.
HoldAll
HoldAll is an attribute that specifies that all arguments to a function are to be maintained in an unevaluated form.
HoldAllComplete
HoldAllComplete is an attribute which specifies that all arguments to a function are not to be modified or looked at in any way in the process of evaluation.
HoldComplete
HoldComplete[expr] shields expr completely from the standard Wolfram Language evaluation process, preventing even upvalues associated with expr from being used.
HoldFirst
HoldFirst is an attribute that specifies that the first argument to a function is to be maintained in an unevaluated form.
HoldForm
HoldForm[expr] prints as the expression expr, with expr maintained in an unevaluated form.
HoldPattern
HoldPattern[expr] is equivalent to expr for pattern matching, but maintains expr in an unevaluated form.
HoldRest
HoldRest is an attribute which specifies that all but the first argument to a function are to be maintained in an unevaluated form.
HolidayCalendar
HolidayCalendar is an option that specifies the holiday calendar schedule in business day functions.
HornerForm
HornerForm[poly] puts the polynomial poly in Horner form.
HornerForm[poly,vars] puts poly in Horner form with respect to the variable or variable list vars.
HornerForm[poly1/poly2] puts the rational function poly1/poly2 in Horner form by nesting poly1 and poly2.
HornerForm[poly1/poly2,vars1,vars2] puts poly1/poly2 in Horner form using the variables or variable lists vars1 and vars2 for poly1 and poly2, respectively.
HostLookup
HostLookup[name] gives the IP address for the host with the specified name.
HostLookup[address] gives the host name for the host at the specified IP address.
HostLookup[spec,prop] gives a specified property of the host.
HostLookup[spec,All] gives an association of properties found for the host.
HotellingTSquareDistribution
HotellingTSquareDistribution[p,m] represents Hotelling's T2 distribution with dimensionality parameter p and m degrees of freedom.
HoytDistribution
HoytDistribution[q,ω] represents a Hoyt distribution with shape parameter q and spread parameter ω.
HTTPErrorResponse
HTTPErrorResponse[code] is an object that represents an error response to an HTTP request, with specified error code.
HTTPRedirect
HTTPRedirect[uri] represents an HTTP redirect to the specified uri.
HTTPRedirect[uri,metadata] represents an HTTP redirect to uri with the specified metadata.
HTTPRequest
HTTPRequest[url] represents an HTTP request for the specified URL.
HTTPRequest[assoc] represents an HTTP request built from the components in the association assoc.
HTTPRequest[url,assoc] represents an HTTP request for the specified URL with additional elements such as headers given by assoc.
HTTPRequestData
HTTPRequestData["prop"] gives the value of the specified property of the current HTTP request.
HTTPRequestData[] gives an association with values of properties of the current HTTP request.
HTTPResponse
HTTPResponse[body] is an object that represents a successful response to an HTTP request, with the specified body and default metadata.
HTTPResponse[body,metadata] represents a response to an HTTP request, including the specified body and metadata.
Hue
Hue[h] represents a color in the HSB color space with hue h.
Hue[h,s,b] specifies colors in terms of hue, saturation and brightness.
Hue[h,s,b,a] specifies opacity a.
Hue["string"] returns a color from an HTML color name etc.
Hue[color] returns the HSB representation of color.
HumanGrowthData
HumanGrowthData[spec] returns the range of values within one standard deviation of the mean for all properties of human growth at the specification spec.
HumanGrowthData[spec,property] returns the range of values within one standard deviation of the mean of a property for the specification spec.
HumanGrowthData[spec,index] returns the values for all properties of human growth for spec at the specified percentile.
HumanGrowthData[spec,property,index] returns the value at a specific index of a property for spec at the specified percentile.
HumanGrowthData[spec,property,quantity] returns the percentile and probability density for a specific value quantity of the property at spec.
HumpDownHump
HumpDownHump[x,y,…] displays as x≎y≎….
HumpEqual
HumpEqual[x,y,…] displays as x≏y≏….
HurwitzLerchPhi
HurwitzLerchPhi[z,s,a] gives the Hurwitz–Lerch transcendent Φ(z,s,a).
HurwitzZeta
HurwitzZeta[s,a] gives the Hurwitz zeta function ζ(s,a).
HyperbolicDistribution
HyperbolicDistribution[α,β,δ,μ] represents a hyperbolic distribution with location parameter μ, scale parameter δ, shape parameter α, and skewness parameter β.
HyperbolicDistribution[λ,α,β,δ,μ] represents a generalized hyperbolic distribution with shape parameter λ.
HypercubeGraph
HypercubeGraph[n] gives the n-dimensional hypercube graph Qn.
HyperexponentialDistribution
HyperexponentialDistribution[{α1,…,αm},{λ1,…,λm}] represents an m-phase hyperexponential distribution with phase probabilities αi and rates λi.
Hyperfactorial
Hyperfactorial[n] gives the hyperfactorial function H(n).
Hypergeometric0F1
Hypergeometric0F1[a,z] is the confluent hypergeometric function 0F1(;a;z).
Hypergeometric0F1Regularized
Hypergeometric0F1Regularized[a,z] is the regularized confluent hypergeometric function 0F1(;a;z)/Γ(a).
Hypergeometric1F1
Hypergeometric1F1[a,b,z] is the Kummer confluent hypergeometric function 1F1(a;b;z).
Hypergeometric1F1Regularized
Hypergeometric1F1Regularized[a,b,z] is the regularized confluent hypergeometric function 1F1(a;b;z)/Γ(b).
Hypergeometric2F1
Hypergeometric2F1[a,b,c,z] is the hypergeometric function 2F1(a,b;c;z).
Hypergeometric2F1Regularized
Hypergeometric2F1Regularized[a,b,c,z] is the regularized hypergeometric function 2F1(a,b;c;z)/Γ(c).
HypergeometricDistribution
HypergeometricDistribution[n,nsucc,ntot] represents a hypergeometric distribution.
HypergeometricPFQ
HypergeometricPFQ[{a1,…,ap},{b1,…,bq},z] is the generalized hypergeometric function pFq(a;b;z).
HypergeometricPFQRegularized
HypergeometricPFQRegularized[{a1,…,ap},{b1,…,bq},z] is the regularized generalized hypergeometric function pFq(a;b;z)/(Γ(b1)…Γ(bq)).
HypergeometricU
HypergeometricU[a,b,z] is the Tricomi confluent hypergeometric function U(a,b,z).
Hyperlink
Hyperlink[uri] represents a hyperlink that jumps to the specified URI when clicked.
Hyperlink[label,uri] represents a hyperlink to be displayed as label.
Hyperplane
Hyperplane[n,p] represents the hyperplane with normal n passing through the point p.
Hyperplane[n,c] represents the hyperplane with normal n given by the points x that satisfy n.xc.
Hyphenation
Hyphenation is an option for Cell that specifies whether to allow hyphenation for words of text.
HypoexponentialDistribution
HypoexponentialDistribution[{λ1,…,λm}] represents an m-phase hypoexponential distribution with rates λ1, …, λm.
HypothesisTestData
HypothesisTestData[…] represents hypothesis test data such as generated by DistributionFitTest, AndersonDarlingTest, etc.
I
I represents the imaginary unit @-1.
IconData
IconData[type,value] generates an icon of the specified type assuming the value given.
Iconize
Iconize[expr] gives an iconized form that can be used to stand in for expr in notebook input.
Iconize[expr,"name"] displays with the specified name in the icon.
IconRules
IconRules is an option for CloudObject and related objects that specifies icons to use in different environments to represent an object.
Icosahedron
Icosahedron[] represents a regular icosahedron centered at the origin with unit edge length.
Icosahedron[l] represents an icosahedron with edge length l.
Icosahedron[{θ,ϕ},…] represents an icosahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
Icosahedron[{x,y,z},…] represents an icosahedron centered at {x,y,z}.
Identity
Identity[expr] gives expr (the identity operation).
IdentityMatrix
IdentityMatrix[n] gives the nn identity matrix.
IdentityMatrix[{m,n}] gives the mn identity matrix.
If
If[condition,t,f] gives t if condition evaluates to True, and f if it evaluates to False.
If[condition,t,f,u] gives u if condition evaluates to neither True nor False.
IgnoreCase
IgnoreCase is an option for string manipulation and searching functions that specifies whether lowercase and uppercase letters should be treated as equivalent.
IgnoreDiacritics
IgnoreDiacritics is an option for string, grammar, and related functions that specifies whether diacritics should be ignored in strings.
IgnoreIsotopes
IgnoreIsotopes is an option for MoleculeMatchQ that determines whether isotopes should be ignored for pattern matching.
IgnorePunctuation
IgnorePunctuation is an option for AlphabeticSort and related functions that specifies whether to consider punctuation in determining sorting order.
IgnoreStereochemistry
IgnoreStereochemistry is an option for MoleculeMatchQ that determines whether stereochemistry should be ignored for pattern matching.
IgnoringInactive
IgnoringInactive[patt] is a pattern object that, for purposes of pattern matching, ignores occurrences of Inactive in both patt and the expression being matched.
Im
Im[z] gives the imaginary part of the complex number z.
Image
Image[data] represents a raster image with pixel values given by the array data.
Image[graphics] creates a raster image from a graphics object.
Image[obj,options] gives an image that uses the specified options.
Image3D
Image3D[data] represents a 3D image with pixel values given by the array data.
Image3D[{image1,image2,…}] creates a 3D image from a list of 2D images.
Image3D[obj,"type"] creates a 3D image of the specified data type.
Image3DProjection
Image3DProjection[image] takes a 3D image and returns a 2D image of maximum projection onto the x-y plane.
Image3DProjection[image,dir] performs a projection in the direction specified by dir.
Image3DProjection[image,dir,mode] specifies the projection mode.
ImageAccumulate
ImageAccumulate[image] gives an image in which each pixel represents a sum of all pixels below and to the left of that pixel in image.
ImageAdd
ImageAdd[image,x] adds an amount x to each channel value in image.
ImageAdd[image1,image2] gives an image in which each pixel is the sum of the corresponding pixels in image1 and image2.
ImageAdd[image,expr1,expr2,…] adds all expri to image, where each expri can be either an image, a number, or a color value.
ImageAdjust
ImageAdjust[image] adjusts the levels in image, rescaling them to cover the range 0 to 1.
ImageAdjust[image,corr] adjusts the image according to the correction specification corr.
ImageAdjust[image,corr,{inmin,inmax}] first rescales so that the range of input values inmin to inmax is mapped to 0 to 1.
ImageAdjust[image,corr,{inmin,inmax},{outmin,outmax}] rescales so that the range of input values inmin to inmax is mapped to outmin to outmax.
ImageAlign
ImageAlign[ref,image] returns a version of image that is aligned with the reference image ref.
ImageAlign[ref,{image1,…,imagen}] gives the result of aligning each of the imagei with the reference image ref.
ImageAlign[{image1,…,imagen}] uses image1 as the reference image.
ImageApply
ImageApply[f,image] applies the function f to the list of channel values for each pixel in image.
ImageApply[f,{image1,image2,…}] applies f to the sequence of corresponding pixel values taken from each imagei.
ImageApplyIndexed
ImageApplyIndexed[f,image] applies the function f to the list of channel values for each pixel in image, giving the row and column index of each pixel as a second argument to f.
ImageApplyIndexed[f,{image1,image2,…}] applies f to the sequence of corresponding pixel values taken from each imagei, giving the corresponding row and column index of pixels as the last argument to f.
ImageAspectRatio
ImageAspectRatio[image] gives the ratio of height to width for image.
ImageAspectRatio[video] gives the aspect ratio of video frames.
ImageAssemble
ImageAssemble[{{im11,…,im1n},…,{imm1,…,immn}}] assembles a single image from an array of images.
ImageAssemble[{{im11,…,im1n},…,{imm1,…,immn}},fitting] assembles images using the fitting method.
ImageAugmentationLayer
ImageAugmentationLayer[{h,w}] represents a net layer that applies random image transformations to produce images of height h and width w.
ImageCapture
ImageCapture[] opens a graphical user interface for capturing images from connected cameras.
ImageCaptureFunction
ImageCaptureFunction is an option for ImageCapture that specifies the function to apply to images acquired by the imaging device.
ImageCases
ImageCases[image] gives an association of lists of subimages for each identified category of objects in image.
ImageCases[image,category] gives a list of subimages identified as an instance of the specified category.
ImageCases[image,category->prop] gives the specified property prop for each identified subimage.
ImageCases[image,{category1,category2,…}] gives an association with lists of subimages identified as being instances of each of the categoryi.
ImageCases[video,…] gives a time series of detected objects in frames of video.
ImageChannels
ImageChannels[image] gives the number of channels present in the data for the Image or Image3D object image.
ImageChannels[video] gives the number of channels present in frames of a video.
ImageClip
ImageClip[image] clips all channel values in image to lie in the default range.
ImageClip[image,{min,max}] clips channel values to lie in the range from min to max.
ImageClip[image,{min,max},{vmin,vmax}] gives vmin for values below min and vmax for values above max.
ImageCollage
ImageCollage[{image1,image2,…}] creates a collage of images imagei.
ImageCollage[{w1->image1,w2->image2,…}] creates a collage of images imagei based on their corresponding weights wi.
ImageCollage[<|image1->w1,image2->w2,…|>] also creates a collage of images imagei based on their corresponding weights wi.
ImageCollage[{w1,w2,…}->{image1,image2,…}] also creates a collage of images imagei based on their corresponding weights wi.
ImageCollage[{{image1,w1},{image2,w2},…}] also creates a collage of images imagei based on their corresponding weights wi.
ImageCollage[…,fitting] uses the fitting method to create the collage.
ImageCollage[…,fitting,size] creates a collage of the specified size.
ImageColorSpace
ImageColorSpace[image] gives the name of the color space of image.
ImageCompose
ImageCompose[image,overlay] gives the result of overlaying overlay onto image.
ImageCompose[image,{overlay,α}] gives the result of alpha blending overlay into image using blending fraction α.
ImageCompose[image,overlay,pos] places the center of overlay at position pos in image.
ImageCompose[image,overlay,pos,opos] places the point opos in overlay at position pos in image.
ImageCompose[image,overlay,pos,opos,{fi,fo,mode}] uses the compositing fractions fk and the specified compositing mode.
ImageContainsQ
ImageContainsQ[image,category] returns True if an instance of the specified category is detected in image.
ImageContainsQ[image,{category1,category2,…}] returns True if at least one instance of each of the categoryi is detected in image.
ImageContainsQ[image,category1|category2|…] returns True if image contains an instance of at least one of categoryi.
ImageContainsQ[video,…] returns a time series of Boolean values for every frame of video.
ImageContents
ImageContents[image] gives a dataset of identified entities in image.
ImageContents[image,category] gives a dataset that only contains entities in the specified category.
ImageContents[image,category,prop] includes the properties prop for each identified object.
ImageContents[video,…] gives a time series of detected objects in frames of video.
ImageConvolve
ImageConvolve[image,ker] gives the convolution of image with kernel ker.
ImageCooccurrence
ImageCooccurrence[image,n] gives the n×n co-occurrence matrix for image.
ImageCooccurrence[image,n,ker] computes a co-occurrence matrix for arbitrary spatial relationships specified by a kernel ker.
ImageCorners
ImageCorners[image] finds corners in image and returns their coordinates.
ImageCorners[image,r] finds corners at a pixel range r.
ImageCorners[image,r,t] uses a threshold t for selecting corners.
ImageCorners[image,r,t,d] returns corners that are at least d+1 pixels apart.
ImageCorners[video,…] returns corners in frames of video.
ImageCorrelate
ImageCorrelate[image,ker] gives the correlation of image with kernel ker.
ImageCorrelate[image,ker,f] computes a generalized correlation in which the function f is used in place of Dot.
ImageCorrespondingPoints
ImageCorrespondingPoints[image1,image2] finds a set of matching interest points in image1 and image2 and returns their pixel coordinates.
ImageCrop
ImageCrop[image] crops image by removing borders of uniform color.
ImageCrop[image,size] crops image based on the size specification size.
ImageCrop[image,size,spec] crops image by removing pixels from sides specified by spec.
ImageCrop[video,…] crops frames of video.
ImageData
ImageData[image] gives the array of pixel values in an Image or Image3D object image.
ImageData[image,"type"] gives the array of pixel values converted to the specified type.
ImageDeconvolve
ImageDeconvolve[image,ker] gives a deconvolution of image using kernel ker.
ImageDemosaic
ImageDemosaic[image,cfa] reconstructs a color image using the specified color filter array cfa.
ImageDemosaic[image,{"cfa",{row,col}}] aligns the top-left pixel of the pattern with the {row,col} pixel of image.
ImageDifference
ImageDifference[image1,image2] gives an image in which each pixel is the absolute difference of the corresponding pixels in image1 and image2.
ImageDimensions
ImageDimensions[image] gives the pixel dimensions of an Image or Image3D object image.
ImageDimensions[video] gives the pixel dimensions of the first video track of the Video object video.
ImageDisplacements
ImageDisplacements[{image1,image2,…,imagen}] gives estimated horizontal and vertical displacements between consecutive images.
ImageDisplacements[{image1,image2,…,imagen},flow] uses flow as an initial estimate for displacement between image1 and image2.
ImageDistance
ImageDistance[image1,image2] returns a distance measure between image1 and image2.
ImageDistance[image1,image2,pos] places the center of image2 at position pos in image1.
ImageDistance[image1,image2,pos1,pos2] places the point pos2 of image2 at position pos1 in image1.
ImageEffect
ImageEffect[image,"effect"] applies the specified image effect to image.
ImageEffect[image,{"effect",params}] uses parameters params.
ImageEffect[video,…] applies the image effect to frames of video.
ImageExposureCombine
ImageExposureCombine[{image1,image2,…}] combines differently exposed images imagei of the same scene into a single image with overall good exposure.
ImageExposureCombine[{image1,image2,…},mode] creates a low or a high dynamic range image based on the specified mode.
ImageFeatureTrack
ImageFeatureTrack[{image1,image2,…,imagen}] tracks features from image1 through imagen.
ImageFeatureTrack[{image1,image2,…,imagen},pts] tracks features starting from the initial set of points pts in image1.
ImageFileApply
ImageFileApply[f,inputfile,outputfile] applies the function f to the list of channel values for each pixel of the image stored in inputfile and stores the result in outputfile.
ImageFileFilter
ImageFileFilter[f,inputfile,r,outputfile] applies the function f to the range r neighborhood of each pixel in each channel of the image stored in inputfile and stores the result in outputfile.
ImageFileScan
ImageFileScan[f,inputfile] applies the function f to the list of channel values for each pixel of the image stored in inputfile.
ImageFilter
ImageFilter[f,image,r] applies the function f to the range-r neighborhood of each pixel in each channel of image.
ImageFocusCombine
ImageFocusCombine[{image1,image2,…}] combines differently focused images imagei of the same scene to obtain a single well-focused image.
ImageForestingComponents
ImageForestingComponents[image] finds a segmentation of image, returning an integer matrix in which positive integers label different components.
ImageForestingComponents[image,marker] tries to find a segmentation into components that include pixels indicated by marker.
ImageForestingComponents[image,marker,r] finds components that are connected at a pixel scale given by r.
ImageForestingComponents[video,…] computes components for each frame in video.
ImageForwardTransformation
ImageForwardTransformation[image,f] gives an image in which each pixel at position f[{x,y}] corresponds to the position {x,y} in image.
ImageForwardTransformation[image,f,size] gives an image of the specified size.
ImageForwardTransformation[video,…] transforms frames of a video.
ImageGraphics
ImageGraphics[image] returns the content of image in the form of scalable vector graphics.
ImageGraphics[image,n] uses up to n colors for the vector graphics.
ImageGraphics[image,colors] creates vector graphics containing the specified colors.
ImageHistogram
ImageHistogram[image] plots a histogram of the pixel levels for each channel in image.
ImageHistogram[image,bspec] uses bin specification bspec.
ImageHistogram[image,bspec,range] plots the histogram of the pixel values in the given range.
ImageIdentify
ImageIdentify[image] yields the result of attempting to identify what image is a picture of.
ImageIdentify[image,category] restricts the identification of image to objects within the specified category.
ImageIdentify[image,category,n] gives a list of up to n possible identifications.
ImageIdentify[image,category,n,"prop"] gives the specified property for each identification.
ImageInstanceQ
ImageInstanceQ[image,obj] gives True if image appears to be an instance of the object obj, and gives False otherwise.
ImageInstanceQ[image,obj,cat] assumes that the image is of something in the category cat.
ImageKeypoints
ImageKeypoints[image] finds key features in image and returns their coordinates.
ImageKeypoints[image,prop] gives the specified property prop for each keypoint.
ImageKeypoints[video,…] finds keypoints in frames of video.
ImageLabels
ImageLabels is an option for image highlighting that specifies what labels to use for each highlighted feature.
ImageLegends
ImageLegends is an option for image highlighting that specifies what legends to use.
ImageLevels
ImageLevels[image] gives a list of pixel values and counts for each channel in image.
ImageLevels[image,bspec] bins pixel values using bin specification bspec.
ImageLevels[image,bspec,range] gives counts for bins in the given range.
ImageLines
ImageLines[image] finds line segments in image and returns the coordinates of their endpoints.
ImageLines[image,t] uses the threshold t for selecting image lines.
ImageLines[image,t,d] uses the parameter d to control the distinctness of the detected lines.
ImageLines[video,…] finds lines in frames of video.
ImageMargins
ImageMargins is an option that specifies the absolute margins to leave around the image displayed for an object.
ImageMarker
ImageMarker[pos] is a HighlightImage specification that represents a marker at position pos.
ImageMarker[pos,marker] represents a custom marker at position pos.
ImageMarker[{pos1,pos2,…},…] represents multiple marker positions posi.
ImageMeasurements
ImageMeasurements[image,"prop"] returns the value of property "prop" for the entire image.
ImageMeasurements[image,"prop",format] returns the values in the specified output format.
ImageMeasurements[{image1, image2, …},…] returns measurements for all imagei.
ImageMesh
ImageMesh[image] returns the foreground region in image as a BoundaryMeshRegion object.
ImageMultiply
ImageMultiply[image,x] multiplies each channel value in image by a factor x.
ImageMultiply[image1,image2] gives an image in which each pixel is the product of the corresponding pixels in image1 and image2.
ImageMultiply[image,expr1,expr2,…] multiplies all expri with image, where each expri can be either an image, a number, or a color value.
ImagePad
ImagePad[image,m] pads image on all sides with m background pixels.
ImagePad[image,m,padding] pads image on all sides using the value or method specified by padding.
ImagePad[image,{{left,right},{bottom,top}},…] pads image with the specified numbers of pixels on each side.
ImagePad[image,{{left,right},{front,back},{bottom,top}},…] pads a 3D image with the specified numbers of pixels.
ImagePad[video,…] pads frames of video.
ImagePadding
ImagePadding is an option for graphics functions that specifies what absolute extra padding should be left for extended objects such as thick lines and annotations such as tick and axis labels.
ImagePartition
ImagePartition[image,s] partitions an image into an array of ss-pixel subimages.
ImagePartition[image,{w,h}] partitions an image into an array of subimages of pixel width w and pixel height h.
ImagePartition[image,{w,h},{dw,dh}] uses pixel offsets dw and dh.
ImagePeriodogram
ImagePeriodogram[image] shows the squared magnitude of the discrete Fourier transform (power spectrum) of image.
ImagePeriodogram[image,n] shows the average of power spectra of non-overlapping partitions of size n×n.
ImagePeriodogram[image,n,d] uses partitions with offset d.
ImagePeriodogram[image,n,d,wfun] applies a smoothing window wfun to each partition.
ImagePeriodogram[image,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
ImagePerspectiveTransformation
ImagePerspectiveTransformation[image,m] applies a linear fractional transform specified by a matrix m to the positions of each pixel in image.
ImagePerspectiveTransformation[image,tf] uses the TransformationFunction given by tf.
ImagePerspectiveTransformation[image,…,size] gives an image of the specified size.
ImagePerspectiveTransformation[video,…] transforms frames of a video.
ImagePosition
ImagePosition[image] gives an association of image positions for each identified category of objects in image.
ImagePosition[image,obj] gives a list of image positions for subimages identified as instances of the specified category.
ImagePosition[video,…] gives a time series of detected object positions in frames of video.
ImagePreviewFunction
ImagePreviewFunction is an option for CurrentImage and similar functions that specifies the function to apply to images before being displayed.
ImagePyramid
ImagePyramid[image] creates a Gaussian image pyramid formed from image.
ImagePyramid[image,pyrtype] returns a Gaussian or Laplacian pyramid depending of the specified pyrtype.
ImagePyramid[image,pyrtype,n] returns up to n levels of the pyramid.
ImagePyramid[image,pyrtype,{size}] returns pyramid levels down to image dimensions given by size.
ImagePyramid[image,pyrtype,n,s] returns a pyramid with successive levels downsampled by factor s.
ImagePyramidApply
ImagePyramidApply[f,pyr] applies f to all images in the ImagePyramid object pyr.
ImagePyramidApply[f,{pyr1,pyr2,…}] applies f to the sequence of corresponding levels taken from each pyri.
ImageQ
ImageQ[image] yields True if image has the form of a valid Image or Image3D object, and False otherwise.
ImageRecolor
ImageRecolor[image,region->color] recolors pixels in image specified by region using the specified color.
ImageRecolor[image,{region1->color1,…}] recolors multiple regions.
ImageRecolor[video,…] recolors frames of a video.
ImageReflect
ImageReflect[image] reverses image by top-bottom mirror reflection.
ImageReflect[image,side] reverses image by reflecting it so that the specified side goes to the opposite side.
ImageReflect[image,side1->side2] reflects image so that side1 is interchanged with side2.
ImageReflect[video,…] reflects frames of video.
ImageResize
ImageResize[image,width] gives a resized version of image that is width pixels wide.
ImageResize[image,{size}] gives a resized version of image with a maximum pixel width or height given by size.
ImageResize[image,{width,height}] gives a resized version of image that has exactly the specified pixel width and height.
ImageResize[video,…] gives a video in which every frame is resized.
ImageResize[image,{width,depth,height}] gives a resized version of a 3D image with the specified dimensions.
ImageResolution
ImageResolution is an option for Export, Rasterize, and related functions that specifies at what resolution bitmap images should be rendered.
ImageRestyle
ImageRestyle[image,sample] attempts to restyle image so as to follow the graphical style of sample.
ImageRestyle[image,w->sample] uses restyle weighting w.
ImageRestyle[image,{sample1,…}] attempts to restyle image using a blend of the graphical styles of the samplei.
ImageRestyle[image,{w1->sample1,…}] uses weightings wi for the samplei.
ImageRotate
ImageRotate[image] rotates image by 90° about its center in the x-y plane.
ImageRotate[image,θ] rotates image by θ radians.
ImageRotate[image,{θ,w}] rotates a 3D image around the 3D vector w.
ImageRotate[image,…,size] gives an image of the specified size.
ImageRotate[video,…] rotate frames of video.
ImageRotated
ImageRotated is an option for Export that specifies whether images should be rotated into landscape mode.
ImageSaliencyFilter
ImageSaliencyFilter[image] returns a saliency map for image.
ImageScaled
ImageScaled[{x,y}] gives the position of a graphical object in terms of coordinates scaled to run from 0 to 1 across the whole image region in each direction.
ImageScaled[{dx,dy},{x0,y0}] gives a position obtained by starting at ordinary coordinates {x0,y0}, then moving by an image‐scaled offset {dx,dy}.
ImageScan
ImageScan[f,image] evaluates f applied to each pixel of image in turn.
ImageSize
ImageSize is an option that specifies the overall size of an image to display for an object.
ImageSizeAction
ImageSizeAction is an option for Pane and related constructs that specifies what to do if the specified ImageSize setting does not match the size of the contents.
ImageSizeMultipliers
ImageSizeMultipliers is an option that specifies how much smaller to render graphics that appear within other constructs.
ImageStitch
ImageStitch[{image1,image2,…}] gives a composed image from an unordered list of imagei.
ImageStitch[{{image11,image12,…},{image21,image22,…},…}] returns a stitched image from a matrix of images imageij, according to their array position.
ImageStitch[images,canvas] projects the stitched image onto the geometry specified by canvas.
ImageSubtract
ImageSubtract[image,x] subtracts a constant amount x from each channel value in image.
ImageSubtract[image1,image2] gives an image in which each pixel is obtained by subtracting the values of the corresponding pixels in image1 and image2.
ImageSubtract[image,expr1,expr2,…] subtracts all expri from image, where each expri can be either an image, a number, or a color value.
ImageTake
ImageTake[image,n] gives an image consisting of the first n rows of image.
ImageTake[image,-n] gives an image consisting of the last n rows of image.
ImageTake[image,{row1,row2}] gives rows row1 through row2.
ImageTake[image,{row1,row2},{col1,col2}] gives the image that spans row1 to row2 and col1 to col2.
ImageTake[video,…] returns a video in which every frame consists of the specified region of interest.
ImageTake[image3d,{slice1,slice2},{row1,row2},{col1,col2}] gives the 3D image consisting of the specified slices, rows, and columns.
ImageTransformation
ImageTransformation[image,f] gives an image in which each pixel at position p corresponds to the position f[p] in image.
ImageTransformation[image,f,size] gives an image of the specified size.
ImageTransformation[video,…] transforms frames of a video.
ImageTrim
ImageTrim[image,roi] gives the smallest subimage of image that includes the specified region of interest roi.
ImageTrim[image,roi,r] adds a margin of size r back to the resulting image.
ImageTrim[image,{roi1,roi2,…},…] extracts multiple subimages specified by roii from image.
ImageTrim[video,…] extracts the subimages from video.
ImageType
ImageType[image] gives the underlying type of values used for each pixel element in the Image or Image3D object image.
ImageValue
ImageValue[image,pos] gives the interpolated value of image at position pos.
ImageValue[image,pos,"type"] gives the value converted to the specified type.
ImageValuePositions
ImageValuePositions[image,val] returns a list of pixel positions in image that exactly match the value val.
ImageValuePositions[image,val,d] returns all pixel positions that have values within a distance d from val.
ImageVectorscopePlot
ImageVectorscopePlot[image] plots the chrominance of image.
ImageWaveformPlot
ImageWaveformPlot[image] plots the waveform of image.
ImageWaveformPlot[image,colorspace] plots the waveform of image in colorspace.
ImageWaveformPlot[image,channel] plots the waveform for the specified channel.
ImagingDevice
ImagingDevice is an option to specify what device to use for capturing images.
ImplicitRegion
ImplicitRegion[cond,{x1,…,xn}] represents a region in n that satisfies the conditions cond.
ImplicitRegion[cond,{{x1,a1,b1},…}] represents a region in n that satisfies the conditions cond as well as a1≤x1≤b1 etc.
Implies
Implies[p,q] represents the logical implication p⇒q.
Import
Import[source] imports data from source, returning a Wolfram Language representation of it.
Import[source,"fmt"] takes the file to be in the specified format "fmt".
Import[source,elements] imports the specified elements from a file.
Import[source,…,options] uses the specified options.
ImportByteArray
ImportByteArray[ba,"format"] imports data in the specified format from a ByteArray object.
ImportByteArray[ba,elements] imports the specified elements.
ImportByteArray[ba] attempts to determine the format automatically.
ImportedObject
ImportedObject[…] represents a piece of imported data that has no special representation in the Wolfram Language.
ImportOptions
ImportOptions is an option for Interpreter and related functions that specifies what options should be used in importing data.
ImportString
ImportString["data","format"] imports data in the specified format from a string.
ImportString["data",elements] imports the specified elements.
ImportString["data"] attempts to determine the format of the string from its contents.
ImprovementImportance
ImprovementImportance[rdist,t] gives the improvement importances for all components in the ReliabilityDistribution rdist at time t.
ImprovementImportance[fdist,t] gives the improvement importances for all components in the FailureDistribution fdist at time t.
In
In[n] is a global object that is assigned to have a delayed value of the nth input line.
Inactivate
Inactivate[expr] replaces all instances of f with Inactive[f] for symbols f used as heads in expr.
Inactivate[expr,patt] inactivates all symbols in expr that match the pattern patt.
Inactive
Inactive[f] is an inactive form of f.
IncidenceGraph
IncidenceGraph[m] gives the graph with incidence matrix m.
IncidenceGraph[{v1,v2,…},m] gives the graph with vertices vi and incidence matrix m.
IncidenceList
IncidenceList[g,v] gives a list of edges incident to vertex v.
IncidenceList[g,patt] gives a list of edges incident to vertices that match the pattern patt.
IncidenceList[g,patt,d] gives a list of incident edges d steps away.
IncidenceList[{v->w,…},…] uses rules v->w to specify the graph g.
IncidenceMatrix
IncidenceMatrix[g] gives the vertex-edge incidence matrix of the graph g.
IncidenceMatrix[{v->w,…}] uses rules v->w to specify the graph g.
IncludeAromaticBonds
IncludeAromaticBonds is an option for Molecule that specifies whether aromatic bonds should be detected and labeled.
IncludeConstantBasis
IncludeConstantBasis is an option for LinearModelFit and other fitting functions that specifies whether a constant term should be included if not explicitly given in the list of basis functions.
IncludedContexts
IncludedContexts is an option for FullDefinition, Manipulate and related symbols that gives contexts whose symbols will have their definitions recursively saved.
IncludeDirectories
IncludeDirectories is an option that specifies whether directories are included in evaluations.
IncludeGeneratorTasks
IncludeGeneratorTasks is an option controlling the scope of scheduled task listings.
IncludeHydrogens
IncludeHydrogens is an option that specifies whether hydrogen atoms should be explicitly included in the results.
IncludeInflections
IncludeInflections is an option for linguistic functions that specifies whether inflected forms of words should be included in results.
IncludeMetaInformation
IncludeMetaInformation is an option for Import, Thumbnail, and other functions to specify what types of metadata to include.
IncludePods
IncludePods is an option for WolframAlpha that determines specific pod IDs to include in the results.
IncludeQuantities
IncludeQuantities is an option for DimensionalCombinations for additional quantities to include in the result.
IncludeRelatedTables
IncludeRelatedTables is an option for RelationalDatabase that specifies whether to include tables specified in foreign keys.
IncludeWindowTimes
IncludeWindowTimes is an option to TimeSeriesWindow that specifies whether the endpoints in the time window should be included.
Increment
x++ increases the value of x by 1, returning the old value of x.
IndefiniteMatrixQ
IndefiniteMatrixQ[m] gives True if m is explicitly indefinite, and False otherwise.
IndependenceTest
IndependenceTest[v1,v2] tests whether the vectors v1 and v2 are independent.
IndependenceTest[m1,m2] tests whether the matrices m1 and m2 are independent.
IndependenceTest[…,"property"] returns the value of "property".
IndependentEdgeSetQ
IndependentEdgeSetQ[g,elist] yields True if the edge list elist is an independent edge set of the graph g, and False otherwise.
IndependentPhysicalQuantity
IndependentPhysicalQuantity[string] represents a physical quantity string with no relationship to other physical quantities used in QuantityVariable.
IndependentUnit
IndependentUnit[string] represents a unit string with no relationship to other units within a Quantity.
IndependentUnitDimension
IndependentUnitDimension[dim] represents the base dimension dim associated with an independent physical quantity or unit.
IndependentVertexSetQ
IndependentVertexSetQ[g,vlist] yields True if the vertex list vlist is an independent vertex set in the graph g, and False otherwise.
Indeterminate
Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined.
IndeterminateThreshold
IndeterminateThreshold is an option for Classify, Predict, and related functions that specifies below what probability or probability density a result should be considered indeterminate.
Indexed
Indexed[expr,i] represents the component of expr with index i and formats as expri.
Indexed[expr,{i,j,…}] represents the component with indices i, j, … and formats as expri,j,….
IndexEdgeTaggedGraph
IndexEdgeTaggedGraph[g] sets tags of edges in the graph g to their edge indices.
IndexEdgeTaggedGraph[g,r] sets tags of edges to r,r+1,…
IndexGraph
IndexGraph[g] replaces the vertices of the graph g by its vertex indices.
IndexGraph[g,r] replaces the vertices with integers r, r+1, ….
IndexGraph[{v->w,…},…] uses rules v->w to specify the graph g.
Inequality
Inequality represents a sequence of relational statements.
InexactNumberQ
InexactNumberQ[expr] returns True if expr is an inexact real or complex number, and returns False otherwise.
InfiniteFuture
InfiniteFuture returns a DateObject expression representing infinite future in time.
InfiniteLine
InfiniteLine[{p1,p2}] represents the infinite straight line passing through the points p1 and p2.
InfiniteLine[p,v] represents the infinite straight line passing through the point p in the direction v.
InfinitePast
InfinitePast returns a DateObject expression representing infinite past in time.
InfinitePlane
InfinitePlane[{p1,p2,p3}] represents the plane passing through the points p1, p2, and p3.
InfinitePlane[p,{v1,v2}] represents the plane passing through the point p in the directions v1 and v2.
Infinity
Infinity or ∞ is a symbol that represents a positive infinite quantity.
Infix
Infix[f[e1,e2,…]] prints with f[e1,e2,…] given in default infix form: e1~f~e2~f~e3….
Infix[expr,h] prints with arguments separated by h: e1 h e2 h e3….
InflationAdjust
InflationAdjust[quantity,targetdate] attempts to adjust the specified quantity purchasing power to targetdate.
InflationAdjust[quantity] uses the current year as targetdate.
InflationAdjust[quantity,targetunit] converts the currency to targetunit after adjusting to the current year.
InflationAdjust[timeseries,targetdate] attempts to adjust the specified timeseries data purchasing power to targetdate.
InflationMethod
InflationMethod is an option for InflationAdjust that specifies what time series data is to be used for adjustment in time.
Information
Information[expr] gives information about the expression expr.
Information[expr,prop] gives the value of the property prop for expr.
Information[{expr1,expr2,…},…] gives information about all of the expri.
InformationData
InformationData[assoc] is generated by Information[expr] and handle typesetting and element extraction.
Inherited
Inherited represents an option value to be inherited from an enclosing style, cell, or notebook.
InhomogeneousPoissonProcess
InhomogeneousPoissonProcess[λ[t],t] represents an inhomogeneous Poisson process with intensity λ[t] given as a function of t.
Initialize
Initialize[sym] initializes the symbol sym from persistent values on the default persistence path.
Initialize[sym,{loc1,…}] initializes the symbol sym from persistent values on the persistence path {loc1,…}.
Initialize["patt"] initializes all variables matching the string pattern "patt".
InitialSeeding
InitialSeeding is an option for NDSolve and other functions that specifies equations that specify initial seeding values for variables that may be used by iterative algorithms.
Inner
Inner[f,list1,list2,g] is a generalization of Dot in which f plays the role of multiplication and g of addition.
InnerPolygon
InnerPolygon[poly] gives the inner polygon of the polygon poly.
InnerPolyhedron
InnerPolyhedron[poly] gives the inner polyhedron of the polyhedron poly.
Inpaint
Inpaint[image,region] retouches parts of image that correspond to nonzero elements in region.
Input
Input[] interactively reads in one Wolfram Language expression.
Input[prompt] requests input, displaying prompt as a "prompt".
Input[prompt,init] in a notebook front end uses init as the initial contents of the input field.
InputAssumptions
InputAssumptions is an option for WolframAlpha that specifies assumptions for current query input.
InputForm
InputForm[expr] prints as a version of expr suitable for input to the Wolfram Language.
InputNamePacket
InputNamePacket[string] is a WSTP packet that contains in string the name to be assigned to the next input.
InputPacket
InputPacket[] is a WSTP packet that indicates a prompt for input as generated by Input.
InputPorts
InputPorts is an option to specify the number, names or shapes of input ports for some neural net layers.
InputStream
InputStream["name",n] is an object that represents an input stream for functions such as Read and Find.
InputString
InputString[] interactively reads in a character string.
InputString[prompt] requests input, displaying prompt as a "prompt".
InputString[prompt,init] in a notebook front end uses init as the initial contents of the input field.
InputStringPacket
InputStringPacket[] is a WSTP packet that requests input in string form.
Insert
Insert[list,elem,n] inserts elem at position n in list. If n is negative, the position is counted from the end.
Insert[expr,elem,{i,j,…}] inserts elem at position {i,j,…} in expr.
Insert[expr,elem,{{i1,j1,…},{i2,j2,…},…}] inserts elem at several positions.
Insert[elem,pos] represents an operator form of Insert that can be applied to an expression.
InsertionFunction
InsertionFunction is an option for template functions that specifies how expressions are to be processed before they are inserted when the template is applied.
InsertLinebreaks
InsertLinebreaks["string"] inserts newline characters into string to make a string in which no line is longer than 78 characters.
InsertLinebreaks["string",n] inserts newline characters to make no line longer than n characters.
Inset
Inset[obj] represents an object obj inset in a graphic.
Inset[obj,pos] specifies that the inset should be placed at position pos in the graphic.
Inset[obj,pos,opos] aligns the inset so that position opos in the object (anchor point)
Install
Install["name"] starts a WSTP-compatible external program and installs Wolfram Language definitions to call functions in it.
InstallService
InstallService["url"] installs the web service operations in the WSDL description at the URL given.
InstallService["url", "context`"] installs web service operations, creating functions in the specified context.
InstanceNormalizationLayer
InstanceNormalizationLayer[] is equivalent to NormalizationLayer[].
InString
InString[n] is a global object that is assigned to be the text of the nth input line.
Integer
Integer is the head used for integers.
IntegerDigits
IntegerDigits[n] gives a list of the decimal digits in the integer n.
IntegerDigits[n,b] gives a list of the base b digits in the integer n.
IntegerDigits[n,b,len] pads the list on the left with zeros to give a list of length len.
IntegerDigits[n,MixedRadix[blist]] uses the mixed radix with list of bases blist.
IntegerExponent
IntegerExponent[n,b] gives the highest power of b that divides n.
IntegerLength
IntegerLength[n] gives the number of digits in the base 10 representation of the integer n.
IntegerLength[n,b] gives the number of digits in the base b representation of n.
IntegerName
IntegerName[n] gives a string containing the full English name of the integer n.
IntegerName[n,qualifier] gives a string conforming to the given qualifications.
IntegerPart
IntegerPart[x] gives the integer part of x.
IntegerPartitions
IntegerPartitions[n] gives a list of all possible ways to partition the integer n into smaller integers.
IntegerPartitions[n,k] gives partitions into at most k integers.
IntegerPartitions[n,{k}] gives partitions into exactly k integers.
IntegerPartitions[n,{kmin,kmax}] gives partitions into between kmin and kmax integers.
IntegerPartitions[n,kspec,{s1,s2,…}] gives partitions involving only the si.
IntegerPartitions[n,kspec,sspec,m] limits the result to the first m partitions.
IntegerQ
IntegerQ[expr] gives True if expr is an integer, and False otherwise.
IntegerReverse
IntegerReverse[n] gives the integer whose digits are reversed with respect to those of the integer n.
IntegerReverse[n,b] gives the integer whose digits in base b are reversed with respect to those of n.
IntegerReverse[n,b,len] gives the integer with reversed digits after padding n with zeros on the left to have len digits.
Integers
Integers represents the domain of integers, as in x∈Integers.
IntegerString
IntegerString[n] gives a string consisting of the decimal digits in the integer n.
IntegerString[n,b] gives a string consisting of the base-b digits in the integer n.
IntegerString[n,b,len] pads the string on the left with zero digits to give a string of length len.
IntegerString[n,MixedRadix[blist]] uses the mixed radix with a list of bases blist.
IntegerString[n,"numsys"] gives the numeral form of n based on the numeric system defined by "numsys".
Interactive
Interactive is an option that specifies whether a function should create a user prompt when mimicking an action that would have created a user prompt if invoked manually.
InteractiveTradingChart
InteractiveTradingChart[{{date1,{open1,high1,low1,close1,volume1}},…}] makes a chart showing prices and volume for each date.
InteractiveTradingChart[{"name",daterange}] makes a financial chart for the financial entity "name" over the daterange.
InteractiveTradingChart[{…},{ind1,ind2,…}] makes a financial chart with indicators ind1, ind2, … .
InterfaceSwitched
InterfaceSwitched[<|size1->expr1,size2->expr2,…|>] is a construct that behaves as if it were expri when it is in an interface environment with width sizei.
InterfaceSwitched["param",<|key1->expr1,key2->expr2,…|>] behaves as if it were expri when the value of the interface parameter param corresponds to keyi.
Interleaving
Interleaving is an option for Image and related functions that specifies whether data corresponding to different channels in an object such as an image should be interleaved.
InternallyBalancedDecomposition
InternallyBalancedDecomposition[ssm] yields the internally balanced decomposition of the state-space model ssm.
InterpolatingFunction
InterpolatingFunction[domain,table] represents an approximate function whose values are found by interpolation.
InterpolatingPolynomial
InterpolatingPolynomial[{f1,f2,…},x] constructs an interpolating polynomial in x which reproduces the function values fi at successive integer values 1, 2, … of x.
InterpolatingPolynomial[{{x1,f1},{x2,f2},…},x] constructs an interpolating polynomial for the function values fi corresponding to x values xi.
InterpolatingPolynomial[{{{x1,y1,…},f1},{{x2,y2,…},f2},…},{x,y,…}] constructs a multidimensional interpolating polynomial in the variables x, y, ….
InterpolatingPolynomial[{{{x1,…},f1,df1,…},…},{x,…}] constructs an interpolating polynomial that reproduces derivatives as well as function values.
Interpolation
Interpolation[{f1,f2,…}] constructs an interpolation of the function values fi, assumed to correspond to x values 1, 2, … .
Interpolation[{{x1,f1},{x2,f2},…}] constructs an interpolation of the function values fi corresponding to x values xi.
Interpolation[{{{x1,y1,…},f1},{{x2,y2,…},f2},…}] constructs an interpolation of multidimensional data.
Interpolation[{{{x1,…},f1,df1,…},…}] constructs an interpolation that reproduces derivatives as well as function values.
Interpolation[data,x] find an interpolation of data at the point x.
InterpolationOrder
InterpolationOrder is an option for Interpolation, as well as ListLinePlot, ListPlot3D, ListContourPlot, and related functions, that specifies what order of interpolation to use.
InterpolationPoints
InterpolationPoints is an option to SmoothKernelDistribution and FunctionInterpolation that specifies the initial number of interpolation points to use.
Interpretation
Interpretation[e,expr] represents an object that displays as e, but is interpreted as the unevaluated form of expr if supplied as input.
Interpretation[{x=x0,y=y0,…},e,expr] allows local variables x, y, … in e and expr.
Interpreter
Interpreter[form] represents an interpreter object that can be applied to an input to try to interpret it as an object of the specified form.
Interpreter[form,test] returns the interpreted object only if applying test to it yields True; otherwise it returns a Failure object.
Interpreter[form,test,fail] returns the result of applying the function fail if the test fails.
InterpretTemplate
InterpretTemplate is an experimental function used for interpreting Mathematica input.
InterquartileRange
InterquartileRange[data] gives the difference between the upper and lower quartiles q&^3/4-q&^1/4 for the elements in data.
InterquartileRange[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.
InterquartileRange[dist] gives the difference between the upper and lower quartiles q3/4-q1/4 for the distribution dist.
Interrupt
Interrupt[] generates an interrupt.
IntersectedEntityClass
IntersectedEntityClass[class1,class2,…] represents an entity class containing all the entities common to all classi.
IntersectingQ
IntersectingQ[list1,list2] yields True if list1 and list2 have at least one element in common, and False otherwise.
Intersection
Intersection[list1,list2,…] gives a sorted list of the elements common to all the listi.
Interval
Interval[{min,max}] represents the range of values between min and max.
Interval[{min1,max1},{min2,max2},…] represents the union of the ranges min1 to max1, min2 to max2, ….
IntervalIntersection
IntervalIntersection[interval1,interval2,…] gives the interval representing all points common to each of the intervali.
IntervalMarkers
IntervalMarkers is an option for plotting functions such as ListPlot and BarChart that specifies how to represent uncertainty intervals.
IntervalMarkersStyle
IntervalMarkersStyle is an option for plotting functions that specifies styles in which uncertainty intervals are drawn.
IntervalMemberQ
IntervalMemberQ[interval,x] gives True if the number x lies within the specified interval, and False otherwise.
IntervalMemberQ[interval1,interval2] gives True if interval2 is completely contained within interval1.
IntervalMemberQ[interval] represents an operator form of IntervalMemberQ that can be applied to a number.
IntervalUnion
IntervalUnion[interval1,interval2,…] gives an interval containing the set of all points in any of the intervali.
Inverse
Inverse[m] gives the inverse of a square matrix m.
InverseBetaRegularized
InverseBetaRegularized[s,a,b] gives the inverse of the regularized incomplete beta function.
InverseBilateralLaplaceTransform
InverseBilateralLaplaceTransform[expr,s,t] gives the inverse bilateral Laplace transform of expr.
InverseBilateralLaplaceTransform[expr,{s1,s2,…,sn},{t1,t2,…,tn}] gives the multidimensional inverse bilateral Laplace transform of expr.
InverseBilateralZTransform
InverseBilateralZTransform[expr,z,n] gives the inverse bilateral Z transform of expr.
InverseBilateralZTransform[expr,{z1,…,zk},{n1,…,nk}] gives the multidimensional inverse bilateral Z transform of expr.
InverseCDF
InverseCDF[dist,q] gives the inverse of the cumulative distribution function for the distribution dist as a function of the variable q.
InverseChiSquareDistribution
InverseChiSquareDistribution[ν] represents an inverse χ2 distribution with ν degrees of freedom.
InverseChiSquareDistribution[ν,ξ] represents a scaled inverse χ2 distribution with ν degrees of freedom and scale ξ.
InverseContinuousWaveletTransform
InverseContinuousWaveletTransform[cwd] gives the inverse continuous wavelet transform of a ContinuousWaveletData object cwd.
InverseContinuousWaveletTransform[cwd,wave] gives the inverse transform using the wavelet wave.
InverseContinuousWaveletTransform[cwd,wave,octvoc] gives the inverse transform from the wavelet coefficients specified by octvoc.
InverseDistanceTransform
InverseDistanceTransform[image] gives the inverse distance transform of image, returning the result as a binary image.
InverseEllipticNomeQ
InverseEllipticNomeQ[q] gives the parameter m corresponding to the nome q in an elliptic function.
InverseErf
InverseErf[s] gives the inverse error function obtained as the solution for z in s=erf(z).
InverseErfc
InverseErfc[s] gives the inverse complementary error function obtained as the solution for z in s=erfc(z).
InverseFourier
InverseFourier[list] finds the discrete inverse Fourier transform of a list of complex numbers.
InverseFourier[list,{p1,p2,…}] returns the specified positions of the discrete inverse Fourier transform.
InverseFourierCosTransform
InverseFourierCosTransform[expr,ω,t] gives the symbolic inverse Fourier cosine transform of expr.
InverseFourierCosTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier cosine transform of expr.
InverseFourierSequenceTransform
InverseFourierSequenceTransform[expr,ω,n] gives the inverse discrete-time Fourier transform of expr.
InverseFourierSequenceTransform[expr,{ω1,ω2,…},{n1,n2,…}] gives the multidimensional inverse Fourier sequence transform.
InverseFourierSinTransform
InverseFourierSinTransform[expr,ω,t] gives the symbolic inverse Fourier sine transform of expr.
InverseFourierSinTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier sine transform of expr.
InverseFourierTransform
InverseFourierTransform[expr,ω,t] gives the symbolic inverse Fourier transform of expr.
InverseFourierTransform[expr,{ω1,ω2,…},{t1,t2,…}] gives the multidimensional inverse Fourier transform of expr.
InverseFunctions
InverseFunctions is an option for Solve and related functions that specifies whether inverse functions should be used.
InverseGammaDistribution
InverseGammaDistribution[α,β] represents an inverse gamma distribution with shape parameter α and scale parameter β.
InverseGammaDistribution[α,β,γ,μ] represents a generalized inverse gamma distribution with shape parameters α and γ, scale parameter β, and location parameter μ.
InverseGammaRegularized
InverseGammaRegularized[a,s] gives the inverse of the regularized incomplete gamma function.
InverseGaussianDistribution
InverseGaussianDistribution[μ,λ] represents an inverse Gaussian distribution with mean μ and scale parameter λ.
InverseGaussianDistribution[μ,λ,θ] represents a generalized inverse Gaussian distribution with parameters μ, λ, and θ.
InverseGudermannian
InverseGudermannian[z] gives the inverse Gudermannian function gd-1(z).
InverseHankelTransform
InverseHankelTransform[expr,s,r] gives the inverse Hankel transform of order 0 for expr.
InverseHankelTransform[expr,s,r,ν] gives the inverse Hankel transform of order ν for expr.
InverseHaversine
InverseHaversine[z] gives the inverse haversine function hav-1(z).
InverseImagePyramid
InverseImagePyramid[pyr] reconstructs an image from an ImagePyramid object pyr.
InverseImagePyramid[pyr,pyrtype] assumes the specified pyramid type pyrtype.
InverseImagePyramid[pyr,pyrtype,n] reconstructs up to pyramid level n.
InverseImagePyramid[pyr,pyrtype,{size}] reconstructs up to the smallest pyramid level larger than the specified size.
InverseJacobiCD
InverseJacobiCD[v,m] gives the inverse Jacobi elliptic function cd-1(vm).
InverseJacobiCN
InverseJacobiCN[v,m] gives the inverse Jacobi elliptic function cn-1(vm).
InverseJacobiCS
InverseJacobiCS[v,m] gives the inverse Jacobi elliptic function cs-1(vm).
InverseJacobiDC
InverseJacobiDC[v,m] gives the inverse Jacobi elliptic function dc-1(vm).
InverseJacobiDN
InverseJacobiDN[v,m] gives the inverse Jacobi elliptic function dn-1(vm).
InverseJacobiDS
InverseJacobiDS[v,m] gives the inverse Jacobi elliptic function ds-1(vm).
InverseJacobiNC
InverseJacobiNC[v,m] gives the inverse Jacobi elliptic function nc-1(vm).
InverseJacobiND
InverseJacobiND[v,m] gives the inverse Jacobi elliptic function nd-1(vm).
InverseJacobiNS
InverseJacobiNS[v,m] gives the inverse Jacobi elliptic function ns-1(vm).
InverseJacobiSC
InverseJacobiSC[v,m] gives the inverse Jacobi elliptic function sc-1(vm).
InverseJacobiSD
InverseJacobiSD[v,m] gives the inverse Jacobi elliptic function sd-1(vm).
InverseJacobiSN
InverseJacobiSN[v,m] gives the inverse Jacobi elliptic function sn-1(vm).
InverseMellinTransform
InverseMellinTransform[expr,s,x] gives the inverse Mellin transform of expr.
InversePermutation
InversePermutation[perm] returns the inverse of permutation perm.
InverseRadon
InverseRadon[image] gives the inverse discrete Radon transform of image.
InverseRadon[image,{w,h}] specifies the width w and the height h of the resulting image.
InverseRadonTransform
InverseRadonTransform[expr,{p,ϕ},{x,y}] gives the inverse Radon transform of expr.
InverseSeries
InverseSeries[s] takes the series s, and gives a series for the inverse of the function represented by s.
InverseSeries[s,x] uses the variable x in the inverse series.
InverseShortTimeFourier
InverseShortTimeFourier[input] reconstructs the signal from short-time Fourier data.
InverseShortTimeFourier[input,n] assumes the spectrogram data was computed with partitions of length n.
InverseShortTimeFourier[input,n,d] assumes partitions with offset d.
InverseShortTimeFourier[input,n,d,wfun] assumes a smoothing window wfun was applied to each partition.
InverseSpectrogram
InverseSpectrogram[data] reconstructs the signal from the magnitude spectrogram data.
InverseSpectrogram[img] reconstructs the signal, assuming that the image img is the magnitude spectrogram.
InverseSpectrogram[input,n] assumes the spectrogram data was computed with partitions of length n.
InverseSpectrogram[input,n,d] assumes partitions with offset d.
InverseSpectrogram[input,n,d,wfun] assumes a smoothing window wfun was applied to each partition.
InverseSurvivalFunction
InverseSurvivalFunction[dist,q] gives the inverse of the survival function for the distribution dist as a function of the variable q.
InverseTransformedRegion
InverseTransformedRegion[reg,f,n] represents the inverse transformed region {p∈n|f(p)∈reg}, where reg is a region and f is a function.
InverseWaveletTransform
InverseWaveletTransform[dwd] gives the inverse wavelet transform of a DiscreteWaveletData object dwd.
InverseWaveletTransform[dwd,wave] gives the inverse transform using the wavelet wave.
InverseWaveletTransform[dwd,wave,wind] gives the inverse transform from the wavelet coefficients specified by wind.
InverseWeierstrassP
InverseWeierstrassP[p,{g2,g3}] gives a value of u for which the Weierstrass function ℘(u;g2,g3) is equal to p.
InverseWishartMatrixDistribution
InverseWishartMatrixDistribution[ν,Σ] represents an inverse Wishart matrix distribution with ν degrees of freedom and covariance matrix Σ.
InverseZTransform
InverseZTransform[expr,z,n] gives the inverse Z transform of expr.
InverseZTransform[expr,{z1,…,zm},{n1,…,nm}] gives the multiple inverse Z transform of expr.
Invisible
Invisible[expr] displays as space that is the same size as the formatted version of expr.
IPAddress
IPAddress["address"] is a symbolic representation of an IPv4 or IPv6 IP address.
IrreduciblePolynomialQ
IrreduciblePolynomialQ[poly] tests whether poly is an irreducible polynomial over the rationals.
IrreduciblePolynomialQ[poly,Modulus->p] tests whether poly is irreducible modulo a prime p.
IrreduciblePolynomialQ[poly,Extension->{a1,a2,…}] tests whether poly is irreducible over the field extension generated by the algebraic numbers ai.
IrreduciblePolynomialQ[poly,Extension->All] tests whether poly is absolutely irreducible over the complex numbers.
IslandData
IslandData[entity,property] gives the value of the specified property for the island entity.
IslandData[{entity1,entity2,…},property] gives a list of property values for the specified island entities.
IslandData[entity,property,annotation] gives the specified annotation associated with the given property.
IsolatingInterval
IsolatingInterval[a] gives a rational isolating interval for the algebraic number a.
IsolatingInterval[a,dx] gives an isolating interval of width at most dx.
IsomorphicGraphQ
IsomorphicGraphQ[g1,g2] yields True if the graphs g1 and g2 are isomorphic, and False otherwise.
IsomorphicSubgraphQ
IsomorphicSubgraphQ[g1,g2] yields True if the graph g1 is isomorphic to a subgraph of the graph g2.
IsotopeData
IsotopeData[{Z,A},"property"] gives the value of the specified property for the isotope with atomic number Z and mass number A.
IsotopeData["name","property"] gives the value of the property for the named isotope.
Italic
Italic represents an italic font slant.
ItoProcess
ItoProcess[{a,b},x,t] represents an Ito process x(t), where x(t)a(t,x(t))t+b(t,x(t)).w(t).
ItoProcess[{a,b,c},x,t] represents an Ito process y(t)c(t,x(t)), where x(t)a(t,x(t))t+b(t,x(t)).w(t) .
ItoProcess[…,{x,x0},{t,t0}] uses initial condition x(t0)x0.
ItoProcess[…,…,…,Σ] uses a Wiener process w(t), with covariance Σ.
ItoProcess[proc] converts proc to a standard Ito process whenever possible.
ItoProcess[sdeqns,expr,x,t,wdproc] represents an Ito process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc.
JaccardDissimilarity
JaccardDissimilarity[u,v] gives the Jaccard dissimilarity between Boolean vectors u and v.
JacobiAmplitude
JacobiAmplitude[u,m] gives the amplitude am(um) for Jacobi elliptic functions.
Jacobian
Jacobian is an option for FindRoot. Jacobian -> Automatic attempts symbolic computation of the Jacobian of the system of functions whose root is being sought. A typical setting is Jacobian -> {{2 x, Sign[y]}, {y, x}}.
JacobiCD
JacobiCD[u,m] gives the Jacobi elliptic function cd(u|m).
JacobiCN
JacobiCN[u,m] gives the Jacobi elliptic function cn(u|m).
JacobiCS
JacobiCS[u,m] gives the Jacobi elliptic function cs(u|m).
JacobiDC
JacobiDC[u,m] gives the Jacobi elliptic function dc(u|m).
JacobiDN
JacobiDN[u,m] gives the Jacobi elliptic function dn(u|m).
JacobiDS
JacobiDS[u,m] gives the Jacobi elliptic function ds(u|m).
JacobiEpsilon
JacobiEpsilon[u,m] gives the Jacobi epsilon function ℰ(um).
JacobiNC
JacobiNC[u,m] gives the Jacobi elliptic function nc(u|m).
JacobiND
JacobiND[u,m] gives the Jacobi elliptic function nd(u|m).
JacobiNS
JacobiNS[u,m] gives the Jacobi elliptic function ns(u|m).
JacobiP
JacobiP[n,a,b,x] gives the Jacobi polynomial Pn(a,b)(x).
JacobiSC
JacobiSC[u,m] gives the Jacobi elliptic function sc(u|m).
JacobiSD
JacobiSD[u,m] gives the Jacobi elliptic function sd(u|m).
JacobiSN
JacobiSN[u,m] gives the Jacobi elliptic function sn(um).
JacobiSymbol
JacobiSymbol[n,m] gives the Jacobi symbol (n/m).
JacobiZeta
JacobiZeta[ϕ,m] gives the Jacobi zeta function Ζ(ϕm).
JacobiZN
JacobiZN[u,m] gives the Jacobi zeta function zn(um).
JankoGroupJ1
JankoGroupJ1[] represents the sporadic simple Janko group J1.
JankoGroupJ2
JankoGroupJ2[] represents the sporadic simple Janko group J2.
JankoGroupJ3
JankoGroupJ3[] represents the sporadic simple Janko group J3.
JankoGroupJ4
JankoGroupJ4[] represents the sporadic simple Janko group J4.
JarqueBeraALMTest
JarqueBeraALMTest[data] tests whether data is normally distributed using the Jarque–Bera ALM test.
JarqueBeraALMTest[data,"property"] returns the value of "property".
JohnsonDistribution
JohnsonDistribution["SB",γ,δ,μ,σ] represents a bounded Johnson distribution with shape parameters γ, δ, location parameter μ, and scale parameter σ.
JohnsonDistribution["SL",γ,δ,μ,σ] represents a semi-bounded Johnson distribution.
JohnsonDistribution["SU",γ,δ,μ,σ] represents an unbounded Johnson distribution.
JohnsonDistribution["SN",γ,δ,μ,σ] represents a normal Johnson distribution.
Join
Join[list1,list2,…] concatenates lists or other expressions that share the same head.
Join[list1,list2,…,n] joins the objects at level n in each of the listi.
JoinAcross
JoinAcross[{a1,a2,…},{b1,b2,…},key] gives a list of associations obtained by joining those pairs of associations ai and bj in which the values associated with key are the same.
JoinAcross[{a1,a2,…},{b1,b2,…},{key1,key2,…}] joins pairs of associations only when the values associated with all keys keyi are the same.
JoinAcross[{a1,a2,…},{b1,b2,…},keya->keyb] joins pairs of associations ai, bj in which the values associated with keya in the ai are the same as those associated with keyb in the bj.
JoinAcross[{a1,a2,…},{b1,b2,…},{keya1->keyb1,…}] joins pairs of associations in which pairs of corresponding values agree.
JoinAcross[alist,blist,keyspec,"joinspec"] uses joinspec to determine when to allow associations that contain missing elements to be generated.
Joined
Joined is an option for ListPlot and related functions that specifies whether points in each dataset should be joined into a line, or should be plotted as separate points.
JoinedCurve
JoinedCurve[{segment1,segment2,…}] represents a curve consisting of segment1 followed by segment2 etc.
JoinedCurve[{component1,component2,…}] represents a list of separate component curves component1, component2, etc.
JoinForm
JoinForm[type] is a graphics directive that specifies what type of joins should be used to connect segments of lines, tubes, edges, and related primitives.
JordanDecomposition
JordanDecomposition[m] yields the Jordan decomposition of a square matrix m. The result is a list {s,j} where s is a similarity matrix and j is the Jordan canonical form of m.
JordanModelDecomposition
JordanModelDecomposition[ssm] yields the Jordan decomposition of the state-space model ssm.
JulianDate
JulianDate[] gives the current number of days since noon on November 24, 4714 BCE in the GMT time zone.
JulianDate[date] gives the number of days for the specified date.
JulianDate["type"] gives the Julian date variant of the specified type.
JulianDate["type",date] gives the variant for the specified date.
JuliaSetBoettcher
JuliaSetBoettcher[c,z] gives the Böttcher coordinate of z with respect to the quadratic Julia set Jc.
K
K is a default generic name for a summation index in a symbolic sum.
KagiChart
KagiChart[{{date1,p1},{date2,p2},…}] makes a Kagi chart with prices pi at date datei.
KagiChart[{"name",daterange}] makes a Kagi chart of closing prices for the financial entity "name" over the date range daterange.
KagiChart[{…},rt] makes a Kagi chart with reversal threshold rt.
KaiserBesselWindow
KaiserBesselWindow[x] represents a Kaiser–Bessel window function of x.
KaiserWindow
KaiserWindow[x] represents a Kaiser window function of x.
KaiserWindow[x,α] uses the parameter α.
KalmanEstimator
KalmanEstimator[ssm,{w,v}] constructs the Kalman estimator for the StateSpaceModel ssm with process and measurement noise covariance matrices w and v.
KalmanEstimator[ssm,{w,v,h}] includes the cross-covariance matrix h.
KalmanEstimator[{ssm,sensors},{…}] specifies sensors as the noisy measurements of ssm.
KalmanEstimator[{ssm,sensors,dinputs},{…}] specifies dinputs as the deterministic inputs of ssm.
KalmanFilter
KalmanFilter[tproc,data] filters data using the time series model given by tproc.
KarhunenLoeveDecomposition
KarhunenLoeveDecomposition[{a1,a2,…}] gives the Karhunen–Loeve transform {{b1,b2,…},m} of the numerical arrays {a1,a2,…}, where m.aibi.
KarhunenLoeveDecomposition[{b1,b2,…},m] uses the inverse of the matrix m for transforming bi to ai.
KaryTree
KaryTree[n] gives a binary tree with n vertices.
KaryTree[n,k] gives a k-ary tree with n vertices.
KatzCentrality
KatzCentrality[g,α] gives a list of Katz centralities for the vertices in the graph g and weight α.
KatzCentrality[g,α,β] gives a list of Katz centralities using weight α and initial centralities β.
KatzCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
KCoreComponents
KCoreComponents[g,k] gives the k-core components of the underlying simple graph of g.
KCoreComponents[g,k,"In"] gives the k-core components with vertex in-degrees at least k.
KCoreComponents[g,k,"Out"] gives the k-core components with vertex out-degrees at least k.
KCoreComponents[{v->w,…},…] uses rules v->w to specify the graph g.
KDistribution
KDistribution[ν,w] represents a K distribution with shape parameters ν and w.
KEdgeConnectedComponents
KEdgeConnectedComponents[g,k] gives the k-edge-connected components of the graph g.
KEdgeConnectedComponents[g,k,{v1,v2,…}] gives the k-edge-connected components that include at least one of the vertices v1, v2, ….
KEdgeConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g.
KEdgeConnectedGraphQ
KEdgeConnectedGraphQ[g,k] yields True if the graph g is k-edge-connected and False otherwise.
KeepExistingVersion
KeepExistingVersion is an option for PacletInstall and PacletInstallSubmit that specifies whether an older version of a paclet should remain installed when a newer one gets installed.
KelvinBei
KelvinBei[z] gives the Kelvin function bei(z).
KelvinBei[n,z] gives the Kelvin function bein(z).
KelvinBer
KelvinBer[z] gives the Kelvin function ber(z).
KelvinBer[n,z] gives the Kelvin function bern(z).
KelvinKei
KelvinKei[z] gives the Kelvin function kei(z).
KelvinKei[n,z] gives the Kelvin function kein(z).
KelvinKer
KelvinKer[z] gives the Kelvin function ker(z).
KelvinKer[n,z] gives the Kelvin function kern(z).
KendallTauTest
KendallTauTest[v1,v2] tests whether the vectors v1 and v2 are independent.
KendallTauTest[m1,m2] tests whether the matrices m1 and m2 are independent.
KendallTauTest[…,"property"] returns the value of "property".
KernelFunction
KernelFunction[f] represents a function to be evaluated in the Wolfram Language kernel, even when called from compiled code.
KernelMixtureDistribution
KernelMixtureDistribution[{x1,x2,…}] represents a kernel mixture distribution based on the data values xi.
KernelMixtureDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate kernel mixture distribution based on data values {xi,yi,…}.
KernelMixtureDistribution[…,bw] represents a kernel mixture distribution with bandwidth bw.
KernelMixtureDistribution[…,bw,ker] represents a kernel mixture distribution with bandwidth bw and smoothing kernel ker.
KernelObject
KernelObject[…] represents a kernel available for parallel computing.
Kernels
Kernels[] gives the list of running kernels available for parallel computing.
Key
Key[key] represents a key used to access a value in an association or a column in a Tabular object.
Key[key][assoc] extracts the value corresponding to key in the association assoc.
KeyCollisionFunction
KeyCollisionFunction is an option for JoinAcross that specifies how to handle pairs of elements that are not being joined but nevertheless have the same key.
KeyComplement
KeyComplement[{assocall,assoc1,assoc2,…}] generates an association in which only elements whose keys appear in assocall but not in any of the associ are retained.
KeyDrop
KeyDrop[assoc,{key1,key2,…}] yields an association from which elements with keys keyi have been dropped.
KeyDrop[{assoc1,assoc2,…},keys] gives a list of associations.
KeyDrop[keys] represents an operator form of KeyDrop that can be applied to an expression.
KeyDropFrom
KeyDropFrom[a,key] changes the association a by dropping the element with the specified key.
KeyDropFrom[a,{key1,key2,…}] drops the elements with keys keyi.
KeyExistsQ
KeyExistsQ[assoc,key] returns True if the specified key exists in the association assoc, and False otherwise.
KeyExistsQ[key] represents an operator form of KeyExistsQ that can be applied to an expression.
KeyFreeQ
KeyFreeQ[assoc,form] yields True if no key in the association assoc matches form, and yields False otherwise.
KeyFreeQ[form] represents an operator form of KeyFreeQ that can be applied to an expression.
KeyIntersection
KeyIntersection[{assoc1,assoc2,…}] generates a list of associations in which only elements whose keys appear in all the associ are retained.
KeyMap
KeyMap[f,<|key1->val1,key2->val2,…|>] maps f over the keys in an association, giving <|f[key1]->val1,f[key2]->val2,…|>.
KeyMap[f] represents an operator form of KeyMap that can be applied to an expression.
KeyMemberQ
KeyMemberQ[assoc,form] yields True if a key in the association assoc matches form, and False otherwise.
KeyMemberQ[form] represents an operator form of KeyMemberQ that can be applied to an expression.
KeypointStrength
KeypointStrength is an option for ImageKeypoints and related functions to specify a minimum strength of detected keypoints.
Keys
Keys[<|key1->val1,key2->val2,…|>] gives a list of the keys keyi in an association.
Keys[{key1->val1,key2->val2,…}] gives a list of the keyi in a list of rules.
Keys[expr,h] gives a list of keys in expr, wrapping each of them with head h before evaluation.
KeySelect
KeySelect[assoc,crit] selects elements in the association assoc for which crit applied to their keys is True.
KeySelect[crit] represents an operator form of KeySelect that can be applied to an expression.
KeySort
KeySort[assoc] orders the elements of an association by sorting its keys.
KeySort[assoc,p] orders the elements of an association using the ordering function p.
KeySortBy
KeySortBy[assoc,f] sorts the elements of an association in the order defined by applying f to each of their keys.
KeySortBy[f] represents an operator form of KeySortBy that can be applied to an expression.
KeyTake
KeyTake[assoc,{key1,key2,…}] yields an association containing only the elements with keys keyi.
KeyTake[{assoc1,assoc2,…},keys] gives a list of associations.
KeyTake[{key1,key2,…}] represents an operator form of KeyTake that can be applied to an expression.
KeyUnion
KeyUnion[{assoc1,assoc2,…}] generates a list of associations in which each association has the union of the keys of the associ, padding by inserting values of Missing[…] if necessary.
KeyUnion[{assoc1,assoc2,…},f] uses f[key] as the value associated with a missing key.
KeyValueMap
KeyValueMap[f,<|key1->val1,key2->val2,…|>] gives the list {f[key1,val1],f[key2,val2],…}.
KeyValueMap[f] represents an operator form of KeyValueMap that can be applied to an expression.
KeyValuePattern
KeyValuePattern[{patt1,…}] is a pattern object that represents an association or list of rules that includes elements matching each of the patti.
Khinchin
Khinchin is Khinchin's constant, with numerical value ≃2.68545.
KillProcess
KillProcess[proc] kills the external process represented by the ProcessObject proc.
KirchhoffGraph
KirchhoffGraph[kmat] gives the graph with Kirchhoff matrix kmat.
KirchhoffGraph[{v1,v2,…},kmat] gives the graph with vertices vi and Kirchhoff matrix kmat.
KirchhoffMatrix
KirchhoffMatrix[g] gives the Kirchhoff matrix of the graph g.
KirchhoffMatrix[{v->w,…}] uses rules v->w to specify the graph g.
KleinInvariantJ
KleinInvariantJ[τ] gives the Klein invariant modular elliptic function J(τ).
KnapsackSolve
KnapsackSolve[{cost1,cost2,…},maxtotalcost] solves the knapsack problem of finding the maximum number of items associated with each of the costi, subject to the constraint that the total cost is not larger than maxtotalcost.
KnapsackSolve[{{payoff1,cost1},{payoff2,cost2},…},maxtotalcost] finds a number of items that maximizes the total payoff, while satisfying the constraint on the total cost.
KnapsackSolve[{{payoff1,cost1,maxcount1},…},maxtotalcost] allows at most maxcounti copies of item i.
KnapsackSolve[items,{maxtotalpayoff,maxtotalcost}] finds a result that gives a total payoff not larger than maxtotalpayoff.
KnapsackSolve[items,{maxtotalpayoff,maxtotalcost,maxtotalcount}] adds the constraint of having no more than maxtotalcount items in total.
KnapsackSolve[<|label1->itemspec1,…|>,maxtotals] labels each type of item and gives the result as an association.
KnightTourGraph
KnightTourGraph[m,n] gives a Knight's tour graph on an mn chessboard.
KnotData
KnotData[knot,"property"] gives the specified property for a knot.
KnotData[knot] gives an image of the knot.
KnotData["class"] gives a list of knots in the specified class.
KnownUnitQ
KnownUnitQ[expr] returns True if expr is a canonical unit, and False otherwise.
KnownUnitQ[expr,dims] gives True if expr is a canonical unit with physical dimensions dims, and False otherwise.
KochCurve
KochCurve[n] gives the line segments representing the nth-step Koch curve.
KochCurve[n,{θ1,θ2,…}] takes a series of steps of unit length at successive relative angles θi.
KochCurve[n,{{r1,θ1},{r2,θ2},…}] takes successive steps of lengths proportional to ri.
KolmogorovSmirnovTest
KolmogorovSmirnovTest[data] tests whether data is normally distributed using the Kolmogorov–Smirnov test.
KolmogorovSmirnovTest[data,dist] tests whether data is distributed according to dist using the Kolmogorov–Smirnov test.
KolmogorovSmirnovTest[data,dist,"property"] returns the value of "property".
KroneckerDelta
KroneckerDelta[n1,n2,…] gives the Kronecker delta δn1 n2 …, equal to 1 if all the ni are equal, and 0 otherwise.
KroneckerModelDecomposition
KroneckerModelDecomposition[ssm] yields the Kronecker decomposition of a descriptor state-space model ssm.
KroneckerProduct
KroneckerProduct[m1,m2,…] constructs the Kronecker product of the arrays mi.
KroneckerSymbol
KroneckerSymbol[n,m] gives the Kronecker symbol (n/m).
KuiperTest
KuiperTest[data] tests whether data is normally distributed using the Kuiper test.
KuiperTest[data,dist] tests whether data is distributed according to dist using the Kuiper test.
KuiperTest[data,dist,"property"] returns the value of "property".
KumaraswamyDistribution
KumaraswamyDistribution[α,β] represents a Kumaraswamy distribution with shape parameters α and β.
Kurtosis
Kurtosis[data] gives the coefficient of kurtosis for the elements in data.
Kurtosis[dist] gives the coefficient of kurtosis for the distribution dist.
KuwaharaFilter
KuwaharaFilter[data,r] computes for each element p in data the variance of the values in the four (r+1)×(r+1) squares that have p as a corner, and replaces p with the mean of the values of the square with least variance.
KVertexConnectedComponents
KVertexConnectedComponents[g,k] gives the k-vertex-connected components of the graph g.
KVertexConnectedComponents[g,k,{v1,v2,…}] gives the k-vertex-connected components that include at least one of the vertices v1, v2, … .
KVertexConnectedGraphQ
KVertexConnectedGraphQ[g,k] yields True if the graph g is k-vertex-connected and False otherwise.
LABColor
LABColor[l,a,b] represents a color in the CIELAB color space with lightness l and color components a and b.
LABColor[l,a,b,α] specifies opacity α.
LABColor["string"] returns a color from an HTML color name etc.
LABColor[color] returns the CIELAB representation of color.
Label
Label[tag] represents a point in a compound expression to which control can be transferred using Goto.
Labeled
Labeled[expr,lbl] displays expr labeled with lbl.
Labeled[expr,lbl,pos] places lbl at a position specified by pos.
Labeled[expr,{lbl1,lbl2,…},{pos1,…}] places the lbli at positions posi.
Labeled[expr,{lbl1,lbl2,lbl3,lbl4},All] places the lbli at the bottom, left, top, and right, respectively.
LabelingFunction
LabelingFunction is an option for data visualization functions to automatically label elements of a visualization.
LabelingSize
LabelingSize is an option to visualization functions that specifies the size to be used for labels and callouts.
LabelVisibility
LabelVisibility is an option for Callout and Labeled in plotting functions that determines which labels are shown.
LakeData
LakeData[entity,property] gives the value of the specified property for the lake entity.
LakeData[{entity1,entity2,…},property] gives a list of property values for the specified lake entities.
LakeData[entity,property,annotation] gives the specified annotation associated with the given property.
LambdaComponents
LambdaComponents[g] gives the lambda components of the graph g.
LambdaComponents[g,{v1,v2,…}] gives the lambda components that include at least one of the vertices {v1,v2,…}.
LambdaComponents[{v->w,…},…] uses rules v->w to specify the graph g.
LameC
LameC[ν,j,z,m] gives the jth Lamé function Ecν(j)(zm) of order ν with elliptic parameter m.
LameCPrime
LameCPrime[ν,j,z,m] gives the z-derivative of the jth Lamé function Ecν(j)(zm) of order ν with elliptic parameter m.
LameEigenvalueA
LameEigenvalueA[ν,j,m] gives the jth Lamé eigenvalue aν(j)(m) of order ν with elliptic parameter m for the function LameC[ν,j,z,m].
LameEigenvalueB
LameEigenvalueB[ν,j,m] gives the jth Lamé eigenvalue bν(j)(m) of order ν with elliptic parameter m for the Lamé function LameS[ν,j,z,m].
LameS
LameS[ν,j,z,m] gives the jth Lamé function Esν(j)(zm) of order ν with elliptic parameter m.
LameSPrime
LameSPrime[ν,j,z,m] gives the z-derivative of the jth Lamé function Esν(j)(zm) of order ν with elliptic parameter m.
LaminaData
LaminaData[entity,property] gives the value of the specified property for the lamina entity.
LaminaData[{entity1,entity2,…},property] gives a list of property values for the specified lamina entities.
LaminaData[entity,property,annotation] gives the specified annotation associated with the given property.
LanczosWindow
LanczosWindow[x] represents a Lanczos window function of x.
LandauDistribution
LandauDistribution[μ,σ] represents a Landau distribution with location parameter μ and scale parameter σ.
LandauDistribution[] represents a Landau distribution with location parameter 0 and scale parameter 1.
Language
Language is an option that specifies the language to use.
LanguageCategory
LanguageCategory is an option for Cell that determines in what category of language the contents of the cell should be assumed to be for purposes of spell checking and hyphenation.
LanguageData
LanguageData[entity,property] gives the value of the specified property for the language entity.
LanguageData[{entity1,entity2,…},property] gives a list of property values for the specified language entities.
LanguageData[entity,property,annotation] gives the specified annotation associated with the given property.
LanguageIdentify
LanguageIdentify["string"] attempts to determine what human language text in string is in, predominantly.
LanguageIdentify[audio] performs language identification in audio recording audio.
LanguageIdentify[video] performs language identification of the audio track in video.
LaplaceDistribution
LaplaceDistribution[μ,β] represents a Laplace double-exponential distribution with mean μ and scale parameter β.
LaplaceDistribution[] represents a Laplace double-exponential distribution with mean 0 and scale parameter 1.
Laplacian
Laplacian[f,{x1,…,xn}] gives the Laplacian ∂2f/∂x12+…+∂2f/∂xn2.
Laplacian[f,{x1,…,xn},chart] gives the Laplacian in the given coordinates chart.
LaplacianFilter
LaplacianFilter[data,r] convolves data with a radius-r Laplacian kernel.
LaplacianFilter[data,{r1,r2,…}] uses radius ri at level i in data.
LaplacianGaussianFilter
LaplacianGaussianFilter[data,r] convolves data with a Laplacian of Gaussian kernel of pixel radius r.
LaplacianGaussianFilter[data,{r,σ}] convolves data with a Laplacian of Gaussian kernel of radius r and standard deviation σ.
LaplacianPDETerm
LaplacianPDETerm[vars] represents a Laplacian term ∇2{x1,…,xn}u with model variables vars.
LaplacianPDETerm[vars,pars] uses model parameters pars.
Large
Large is a style or option setting that specifies that objects should be large.
Larger
Larger is a style or option setting that specifies that objects should be larger.
Last
Last[expr] gives the last element in expr.
Last[expr,def] gives the last element if there are any elements, or def otherwise.
Latitude
Latitude[pos] gives the latitude in degrees of a geographic position specified by pos.
Latitude[pos,datum] gives the latitude referring to the specified geodetic datum.
LatitudeLongitude
LatitudeLongitude[pos] gives a list of the latitude and longitude in degrees of a geographic position specified by pos.
LatitudeLongitude[pos,datum] gives the latitude and longitude referring to the specified geodetic datum.
LatticeData
LatticeData[lattice,"property"] gives the specified property for a lattice.
LatticeData[n] gives a list of named lattices of dimension n.
LatticeReduce
LatticeReduce[{v1,v2,…}] gives a reduced basis for the set of vectors vi.
Launch
Launch is a setting for the LinkMode option of LinkOpen. LinkMode->Launch causes a link to be created by launching another program.
LaunchKernels
LaunchKernels[] launches all currently configured parallel subkernels.
LaunchKernels[n] launches n local subkernels on the current computer.
LaunchKernels[ker] launches the kernel specified by ker.
LaunchKernels[{ker1,ker2,…}] launches the kernels keri.
LayeredGraphPlot
LayeredGraphPlot[g] generates a layered plot of the graph g.
LayeredGraphPlot[{e1,e2,…}] generates a layered plot of the graph with edges ej.
LayeredGraphPlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
LayeredGraphPlot[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.
LayeredGraphPlot[m] uses the adjacency matrix m to specify the graph g.
LayeredGraphPlot[…,v->pos] places the dominant vertex v in the plot at position pos.
LayeredGraphPlot3D
LayeredGraphPlot3D[g] generates a 3D layered plot of the graph g.
LayeredGraphPlot3D[{e1,e2,…}] generates a 3D layered plot of the graph with edges ei.
LayeredGraphPlot3D[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
LayeredGraphPlot3D[{vi1->vj1,…}] uses rules vik->vjk to specify the graph g.
LayeredGraphPlot3D[m] uses the adjacency matrix m to specify the graph g.
LayeredGraphPlot3D[…,v->pos] places the dominant vertex v in the plot at position pos.
LayerSizeFunction
LayerSizeFunction is an option for TreePlot that gives a function to specify the relative height to allow for each layer.
LCHColor
LCHColor[l,c,h] represents a color in the LCH color space with lightness l, chroma c and hue h.
LCHColor[l,c,h,a] specifies opacity a.
LCHColor["string"] returns a color from an HTML color name etc.
LCHColor[color] returns the LCH representation of color.
LCM
LCM[n1,n2,…] gives the least common multiple of the ni.
LeaderSize
LeaderSize is an option for Callout that specifies what sizes to use for leader lines.
LeafCount
LeafCount[expr] gives the total number of indivisible subexpressions in expr.
LeapVariant
LeapVariant[n] represents a repeated calendar element caused by a leap period.
LeapYearQ
LeapYearQ[date] returns True if the year corresponding to date is a leap year.
LearnDistribution
LearnDistribution[{example1,example2,…}] generates a LearnedDistribution[…] that attempts to represent an underlying distribution for the examples given.
LearnedDistribution
LearnedDistribution[…] represents a distribution generated by LearnDistribution.
LearningRate
LearningRate is an option for NetTrain that specifies the rate at which to adjust neural net weights in order to minimize the training loss.
LearningRateMultipliers
LearningRateMultipliers is an option for net layers and for NetTrain, NetChain, NetGraph that specifies learning rate multipliers to apply during training.
LeastSquares
LeastSquares[m,b] finds an x that solves the linear least-squares problem for the matrix equation m.x==b.
LeastSquares[a,b] finds an x that solves the linear least-squares problem for the array equation a.x==b.
LeastSquaresFilterKernel
LeastSquaresFilterKernel[{{ω1,…,ωk-1},{a1,…,ak}},n] creates a k-band finite impulse response (FIR) filter kernel of length n designed using a least squares method, given the specified frequencies ωi and amplitudes ai.
LeastSquaresFilterKernel[{"type",spec},n] uses the full filter specification {"type",spec}.
Left
Left is a symbol that represents the left-hand side for purposes of alignment and positioning.
LeftArrow
LeftArrow[x,y,…] displays as x←y←….
LeftArrowBar
LeftArrowBar[x,y,…] displays as x⇤y⇤….
LeftArrowRightArrow
LeftArrowRightArrow[x,y,…] displays as x⇆y⇆….
LeftDownTeeVector
LeftDownTeeVector[x,y,…] displays as x⥡y⥡….
LeftDownVector
LeftDownVector[x,y,…] displays as x⇃y⇃….
LeftDownVectorBar
LeftDownVectorBar[x,y,…] displays as x⥙y⥙….
LeftRightArrow
LeftRightArrow[x,y,…] displays as x↔y↔….
LeftRightVector
LeftRightVector[x,y,…] displays as x⥎y⥎….
LeftTee
LeftTee[x,y] displays as x⊣y.
LeftTeeArrow
LeftTeeArrow[x,y,…] displays as x↤y↤….
LeftTeeVector
LeftTeeVector[x,y,…] displays as x⥚y⥚….
LeftTriangle
LeftTriangle[x,y,…] displays as x⊲y⊲….
LeftTriangleBar
LeftTriangleBar[x,y,…] displays as x⧏y⧏….
LeftTriangleEqual
LeftTriangleEqual[x,y,…] displays as x⊴y⊴….
LeftUpDownVector
LeftUpDownVector[x,y,…] displays as x⥑y⥑….
LeftUpTeeVector
LeftUpTeeVector[x,y,…] displays as x⥠y⥠….
LeftUpVector
LeftUpVector[x,y,…] displays as x↿y↿….
LeftUpVectorBar
LeftUpVectorBar[x,y,…] displays as x⥘y⥘….
LeftVector
LeftVector[x,y,…] displays as x↼y↼….
LeftVectorBar
LeftVectorBar[x,y,…] displays as x⥒y⥒….
LegendAppearance
LegendAppearance is an option for charting functions that specifies the appearance of any legends that are generated.
Legended
Legended[expr,leg] displays expr with legend leg.
Legended[expr,lbl] indicates in plotting and charting functions that a legend entry for expr should be created, with label lbl.
LegendFunction
LegendFunction is an option for legends that specifies an overall function to apply to the generated legend.
LegendLabel
LegendLabel is an option for legends that specifies an overall label for a legend.
LegendLayout
LegendLayout is an option for legends that specifies how to format the legend content.
LegendMargins
LegendMargins is an option for legends that specifies the margins to leave around the legend.
LegendMarkers
LegendMarkers is an option for legends such as PointLegend that specifies markers for each element.
LegendMarkerSize
LegendMarkerSize is an option for legends such as PointLegend that specifies the size of marker regions for each element.
Length
Length[expr] gives the number of elements in expr.
LengthWhile
LengthWhile[list,crit] gives the number of contiguous elements ei starting at the beginning of list for which crit[ei] is True.
LerchPhi
LerchPhi[z,s,a] gives the Lerch transcendent Φ(z,s,a).
Less
x<y yields True if x is determined to be less than y.
x1<x2<x3 yields True if the xi form a strictly increasing sequence.
LessEqual
x<=y or x≤y yields True if x is determined to be less than or equal to y.
x1≤x2≤x3 yields True if the xi form a nondecreasing sequence.
LessEqualGreater
LessEqualGreater[x,y,…] displays as x⋚y⋚….
LessEqualThan
LessEqualThan[y] is an operator form that yields x≤y when applied to an expression x.
LessFullEqual
LessFullEqual[x,y,…] displays as x≦y≦….
LessGreater
LessGreater[x,y,…] displays as x≶y≶….
LessLess
LessLess[x,y,…] displays as x≪y≪….
LessSlantEqual
LessSlantEqual[x,y,…] displays as x⩽y⩽….
LessThan
LessThan[y] is an operator form that yields x<y when applied to an expression x.
LessTilde
LessTilde[x,y,…] displays as x≲y≲….
LetterCharacter
LetterCharacter represents a letter character in StringExpression.
LetterCounts
LetterCounts["string"] gives an association whose keys are the distinct letters in string, and whose values give the number of times those letters appear in string.
LetterCounts["string",n] gives counts of the distinct n-grams consisting of runs of n letters in string.
LetterCounts["string",n,{c1,c2,…}] allows the characters ci to appear in n-grams, in addition to ordinary letters.
LetterCounts[{string1,string2,…},…] gives the counts for each of the stringi.
LetterNumber
LetterNumber["c"] gives the position of the character c in the English alphabet.
LetterNumber["c",alpha] gives the position of c in the alphabet specified by alpha.
LetterNumber["string",…] gives a list of the positions of characters in string.
LetterQ
LetterQ[string] yields True if all the characters in the string are letters, and yields False otherwise.
Level
Level[expr,levelspec] gives a list of all subexpressions of expr on levels specified by levelspec.
Level[expr,levelspec,f] applies f to the sequence of subexpressions.
LeviCivitaTensor
LeviCivitaTensor[d] gives the d-dimensional Levi-Civita totally antisymmetric tensor.
LevyDistribution
LevyDistribution[μ,σ] represents a Lévy distribution with location parameter μ and dispersion parameter σ.
LexicographicOrder
LexicographicOrder[{a1,a2,…},{b1,b2,…}] gives Order[ai,bi] for the first non-coinciding pair ai,bi of elements, and 0 if the lists are identical.
LexicographicOrder[{a1,a2,…},{b1,b2,…},p] uses the ordering function p to compare ai with bi.
LexicographicOrder[p] represents an operator form that compares lists when applied to {a1,a2,…}, {b1,b2,…}.
LexicographicSort
LexicographicSort[{e1,e2,…}] sorts the list of expressions ei in lexicographic order.
LexicographicSort[{e1,e2,…},p] compares elements of the ei expressions using the ordering function p.
LibraryDataType
LibraryDataType[datatype] specifies the data type for a LibraryFunction argument or result to be datatype.
LibraryDataType[datatype,etype] specifies an element type etype for data structures.
LibraryDataType[datatype,etype,d] specifies an array depth d for array data types.
LibraryFunction
LibraryFunction[args] represents a function that has been loaded from a Wolfram Library.
LibraryFunctionError
LibraryFunctionError[name,code] represents an error returned from a LibraryFunction.
LibraryFunctionInformation
LibraryFunctionInformation[fun] returns information about a LibraryFunction.
LibraryFunctionLoad
LibraryFunctionLoad[lib,fun,argtype,rettype] loads Wolfram Library lib and makes the library function fun available in the Wolfram Language.
LibraryFunctionUnload
LibraryFunctionUnload[fun] unloads a LibraryFunction so that it cannot be used.
LibraryUnload
LibraryUnload[lib] unloads all functions that have been loaded from a Wolfram Library, then it unloads the library.
LicenseEntitlementObject
LicenseEntitlementObject[…] represents an on-demand license entitlement.
LicenseEntitlementObject[id] gives the entitlement object representing the entitlement specified by id.
LicenseEntitlements
LicenseEntitlements[] gives a list of on-demand license entitlements owned by you.
LicenseID
LicenseID is an option to Encode which specifies the required value of $LicenseID on the computer that reads the encoded file. If no value is specified, any value of $LicenseID is allowed on the file-reading computer. A setting for LicenseID must be a string.
LicensingSettings
LicensingSettings is an option for RemoteBatchSubmit and related functions to configure licensing for remote kernels.
LiftingFilterData
LiftingFilterData[…] represents lifting-filter data used to compute forward and inverse lifting wavelet transforms.
LiftingWaveletTransform
LiftingWaveletTransform[data] gives the lifting wavelet transform (LWT) of an array of data.
LiftingWaveletTransform[data,wave] gives the lifting wavelet transform using the wavelet wave.
LiftingWaveletTransform[data,wave,r] gives the lifting wavelet transform using r levels of refinement.
LightBlue
LightBlue represents a light blue color in graphics or style specifications.
LightBrown
LightBrown represents a light brown color in graphics or style specifications.
LightCyan
LightCyan represents a light cyan color in graphics or style specifications.
Lighter
Lighter[color] represents a lighter version of the specified color.
Lighter[color,f] represents a version of the specified color lightened by a fraction f.
Lighter[image,…] gives a lighter version of an image.
Lighter[video,…] gives a version of a video with lighter frames.
LightGray
LightGray represents a light gray color in graphics or style specifications.
LightGreen
LightGreen represents a light green color in graphics or style specifications.
Lighting
Lighting is an option for Graphics3D and related functions that specifies what simulated lighting to use in coloring 3D surfaces.
LightingAngle
LightingAngle is an option for ReliefPlot and related functions that specifies the angle from which simulated illumination is taken to come.
LightMagenta
LightMagenta represents a light magenta color in graphics or style specifications.
LightOrange
LightOrange represents a light orange color in graphics or style specifications.
LightPink
LightPink represents a light pink color in graphics or style specifications.
LightPurple
LightPurple represents a light purple color in graphics or style specifications.
LightRed
LightRed represents a light red color in graphics or style specifications.
LightSources
LightSources is an option for Graphics3D and related functions that specifies the properties of point light sources for simulated illumination.
LightYellow
LightYellow represents a light yellow color in graphics or style specifications.
Likelihood
Likelihood[dist,{x1,x2,…}] gives the likelihood function for observations x1, x2, … from the distribution dist.
Likelihood[proc,{{t1,x1},{t2,x2},…}] gives the likelihood function for the observations xi at time ti from the process proc.
Likelihood[proc,{path1,path2,…}] gives the likelihood function for observations from path1, path2, … from the process proc.
Limit
Limit[f,x->x*] gives the limit x->x*f(x).
Limit[f,{x1->x1*,…,xn->xn*}] gives the nested limit +x1->x1*⋯ +xn->xn*f(x1,…,xn).
Limit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).
LimitsPositioningTokens
LimitsPositioningTokens is an option for selections that specifies a set of characters for which the option LimitsPositioning is set to True by default.
LindleyDistribution
LindleyDistribution[δ] represents a Lindley distribution with shape parameter δ.
Line
Line[{p1,p2,…}] represents the line segments joining a sequence for points pi.
Line[{{p11,p12,…},{p21,…},…}] represents a collection of lines.
LinearFractionalOptimization
LinearFractionalOptimization[f,cons,vars] finds values of variables vars that minimize the linear fractional objective f subject to linear constraints cons.
LinearFractionalOptimization[{α,β,γ,δ},{a,b}] finds a vector x that minimizes the linear fractional function (α.x+β)/(γ.x+δ) subject to the linear inequality constraints a.x+b⪰0.
LinearFractionalOptimization[{α,β,γ,δ},{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.
LinearFractionalOptimization[{α,β,γ,δ},…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.
LinearFractionalOptimization[…,"prop"] specifies what solution property "prop" should be returned.
LinearFractionalTransform
LinearFractionalTransform[m] gives a TransformationFunction that represents a linear fractional transformation defined by the homogeneous matrix m.
LinearFractionalTransform[{a,b,c,d}] represents a linear fractional transformation that maps r to (a.r+b)/(c.r+d).
LinearGradientFilling
LinearGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using a progressive transition between colors coli along a straight horizontal line.
LinearGradientFilling[{pos1,pos2,…,posn}->{col1,col2,…,coln}] uses the colors coli at the scaled positions posi.
LinearGradientFilling[{pos1,pos2,…,posn}->{col1,col2,…,coln},dir] draws along the straight line with a direction dir.
LinearGradientFilling[{pos1,…,posn}->{col1,…,coln},dir,padding] uses the specified padding when drawing beyond the boundary positions pos1 and posn.
LinearGradientImage
LinearGradientImage[gcol] returns an image with values linearly changing from left to right based on gradient color gcol.
LinearGradientImage[{pos1,pos2}->gcol] returns an image where the gradient starts at pos1 and ends at pos2.
LinearGradientImage[…,size] returns a linear gradient image of the specified size.
LinearGradientImage[…,size,"type"] gives an image converted to the specified type.
LinearizingTransformationData
LinearizingTransformationData[…] represents data of an AffineStateSpaceModel linearized by functions such as FeedbackLinearize and StateTransformationLinearize using transformation of variables.
LinearLayer
LinearLayer[n] represents a trainable, fully connected net layer that computes w.x+b with output vector of size n.
LinearLayer[{n1,n2,…}] represents a layer that outputs an array of dimensions n1×n2×….
LinearLayer[] leaves the dimensions of the output array to be inferred from context.
LinearLayer[n,opts] includes options for initial weights and other parameters.
LinearModelFit
LinearModelFit[{{x1,y1},{x2,y2},…},{f1,f2,…},x] constructs a linear model of the form β0+β1f1+β2f2+… that fits the yi for successive xi values.
LinearModelFit[data,{f1,f2,…},{x1,x2,…}] constructs a linear model where the fi depend on the variables xk.
LinearModelFit[{m,v}] constructs a linear model from the design matrix m and response vector v.
LinearOffsetFunction
LinearOffsetFunction is an option for linear and generalized linear model fitting functions that specifies a component for the model that is to be assumed known.
LinearOptimization
LinearOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to linear constraints cons.
LinearOptimization[c,{a,b}] finds a real vector x that minimizes the linear objective c.x subject to the linear inequality constraints a.x+b⪰0.
LinearOptimization[c,{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.
LinearOptimization[c,…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.
LinearOptimization[…,"prop"] specifies what solution property "prop" should be returned.
LinearProgramming
LinearProgramming[c,m,b] finds a vector x that minimizes the quantity c.x subject to the constraints m.x≥b and x≥0.
LinearProgramming[c,m,{{b1,s1},{b2,s2},…}] finds a vector x that minimizes c.x subject to x≥0 and linear constraints specified by the matrix m and the pairs {bi,si}. For each row mi of m, the corresponding constraint is mi.x≥bi if si==1, or mi.x==bi if si==0, or mi.x≤bi if si==-1.
LinearProgramming[c,m,b,l] minimizes c.x subject to the constraints specified by m and b and x≥l.
LinearProgramming[c,m,b,{l1,l2,…}] minimizes c.x subject to the constraints specified by m and b and xi≥li.
LinearProgramming[c,m,b,{{l1,u1},{l2,u2},…}] minimizes c.x subject to the constraints specified by m and b and li≤xi≤ui.
LinearProgramming[c,m,b,lu,dom] takes the elements of x to be in the domain dom, either Reals or Integers.
LinearProgramming[c,m,b,lu,{dom1,dom2,…}] takes xi to be in the domain domi.
LinearSolve
LinearSolve[m,b] finds an x that solves the matrix equation m.x==b.
LinearSolve[m] generates a LinearSolveFunction[…] that can be applied repeatedly to different b.
LinearSolve[a,b] finds an x that solves the array equation a.x==b.
LinearSolveFunction
LinearSolveFunction[dimensions,data] represents a function for providing solutions to a matrix equation.
LinebreakAdjustments
LinebreakAdjustments is an option for selections that sets parameters used for calculating where automatic line breaks should be inserted.
LineBreakChart
LineBreakChart[{{date1,p1},{date2,p2},…}] makes a line break chart with prices pi at date datei.
LineBreakChart[{"name",daterange}] makes a line break chart of closing prices for the financial entity "name" over the date range daterange.
LineBreakChart[{…},n] makes a line break chart where n bars in a row cause a reversal.
LineBreakWithin
LineBreakWithin is an option for selections that specifies whether line breaks occur automatically when the end of a line is reached.
LineGraph
LineGraph[g] gives the line graph of the graph g.
LineGraph[{v->w,…}] uses rules v->w to specify the graph g.
LineIndent
LineIndent is an option for Style and Cell that specifies how many ems of indentation to add at the beginnings of lines for each level of nesting in an expression.
LineIntegralConvolutionPlot
LineIntegralConvolutionPlot[{{vx,vy},image},{x,xmin,xmax},{y,ymin,ymax}] generates a line integral convolution plot of image convolved with the vector field {vx,vy} as a function of x and y.
LineIntegralConvolutionPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a line integral convolution plot of white noise with the vector field {vx,vy}.
LineIntegralConvolutionScale
LineIntegralConvolutionScale is an option to LineIntegralConvolutionPlot and related functions that determines the scale of the line integral convolution to be used.
LineLegend
LineLegend[{col1,…},{lbl1,…}] generates a legend that associates color coli with label lbli.
LineLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.
LineLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.
LineSpacing
LineSpacing is an option for Style and Cell that specifies the spacing between successive lines of text.
LinkActivate
LinkActivate[lnk] activates a WSTP connection, waiting for the program at the other end to respond.
LinkClose
LinkClose[link] closes an open WSTP connection.
LinkConnect
LinkConnect["name"] connects to a WSTP link created by another program.
LinkCreate
LinkCreate["name"] creates a WSTP link with the specified name for another program to connect to.
LinkCreate[] creates a WSTP link and picks an unused name for the link.
LinkError
LinkError[link] returns error information for link in the form { errorNumber, errorExplanation }.
LinkFlush
LinkFlush[link] transmits immediately any locally buffered outgoing expressions.
LinkFunction
LinkFunction is an option for GeneralizedLinearModelFit that specifies the link function for the generalized linear model.
LinkHost
LinkHost is an option for LinkOpen that specifies on what computer a program should be launched or on what computer a listening link will be found.
LinkInterrupt
LinkInterrupt[link] sends an interrupt to the program at the other end of the specified WSTP connection.
LinkLaunch
LinkLaunch["prog"] starts the external program prog and opens a WSTP connection to it.
LinkMode
LinkMode is an option for LinkOpen that specifies how the link is to be established and connected. The possible settings for LinkMode are Launch, Listen, Connect, and Loopback.
LinkObject
LinkObject["name",n1,n2] is an object that represents an active WSTP connection for functions such as LinkRead and LinkWrite.
LinkOpen
LinkOpen["prog"] starts the external program prog and opens a MathLink connection to it.
LinkPatterns
LinkPatterns[link] gives a list of the patterns for which definitions were set up when the external program associated with the specified WSTP connection was installed.
LinkProtocol
LinkProtocol is an option to LinkLaunch, Install, and related functions that specifies the underlying data transport protocol to use for a new WSTP link.
LinkRankCentrality
LinkRankCentrality[g,α] gives the link-rank centralities for edges in the graph g and weight α.
LinkRankCentrality[g,α,β] gives the link-rank centralities, using weight α and initial vertex page-rank centralities β.
LinkRankCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
LinkRead
LinkRead[link] reads one expression from the specified WSTP connection.
LinkRead[link,h] wraps h around the expression read before evaluating it.
LinkReadHeld
LinkReadHeld[link] reads an expression via WSTP from link and returns it wrapped in Hold.
LinkReadyQ
LinkReadyQ[link] tests whether there is an expression ready to read from the specified WSTP connection.
LinkReadyQ[link,t] waits for up to t seconds to see if an expression becomes ready to read.
LinkReadyQ[{link1,link2,…},t] tests all the linki in parallel, returning as soon as any of them are ready to read from.
Links
Links[] gives a list of all WSTP connections that are currently open.
Links[patt] lists only links whose names match the specified string pattern.
LinkService
LinkService["service", l] is an object that represents an active connection to the WSTP service.
LinkWrite
LinkWrite[link,expr] writes expr to the specified WSTP connection.
LinkWriteHeld
LinkWriteHeld[link, Hold[expr], (flush:True)] writes expr (without the Hold) via WSTP to link (synchronizing unless flush is False).
LiouvilleLambda
LiouvilleLambda[n] gives the Liouville function λ(n).
List
{e1,e2,…} is a list of elements.
Listable
Listable is an attribute that can be assigned to a symbol f to indicate that the function f should automatically be threaded over lists that appear as its arguments.
ListAnimate
ListAnimate[{expr1,expr2,…}] generates an animation whose frames are images expr_Imagei.
ListContourPlot
ListContourPlot[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a contour plot from an array of values fij.
ListContourPlot[{{x1,y1,f1},…,{xk,yk,fk}}] generates a contour plot from values fi specified at points {xi,yi}.
ListContourPlot3D
ListContourPlot3D[farr] generates a contour plot from an array farr with values farr[[i,j,k]] at points {k,j,i}.
ListContourPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…}] generates a contour plot from values fi at point {xi,yi,zi}.
ListCurvePathPlot
ListCurvePathPlot[{{x1,y1},{x2,y2},…}] plots a curve that corresponds to a smooth path through the specified points.
ListDeconvolve
ListDeconvolve[ker,list] gives a deconvolution of list using kernel ker.
ListDensityPlot
ListDensityPlot[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a smooth density plot from an array of values fij.
ListDensityPlot[{{x1,y1,f1},…,{xk,yk,fk}}] generates a density plot with values fi defined at specified points {xi,yi}.
ListDensityPlot3D
ListDensityPlot3D[farr] generates a smooth density plot from an array of values farr.
ListDensityPlot3D[{{x1,y1,z1,f1},…,{xn,yn,zn,fn}}] generates a density plot with values fi at the specified points {xi,yi,zi}.
Listen
Listen is a setting for the LinkMode option of LinkOpen. LinkMode->Listen causes a link to be created that listens on a named port for an incoming connection request.
ListFormat
ListFormat is an option to TextString and related functions that determines how lists are formatted.
ListFourierSequenceTransform
ListFourierSequenceTransform[list,ω] gives the discrete-time Fourier transform (DTFT) of a list as a function of the parameter ω.
ListFourierSequenceTransform[list,ω,k] places the first element of list at integer time k on the infinite time axis.
ListFourierSequenceTransform[list,{ω1,ω2,…},{k1,k2,…}] gives the multidimensional discrete-time Fourier transform
ListInterpolation
ListInterpolation[array] constructs an InterpolatingFunction object that represents an approximate function that interpolates the array of values given.
ListInterpolation[array,{{xmin,xmax},{ymin,ymax},…}] specifies the domain of the grid from which the values in array are assumed to come.
ListLineIntegralConvolutionPlot
ListLineIntegralConvolutionPlot[{array,image}] generates a line integral convolution plot of image convolved with the vector field defined by an array of vector field values.
ListLineIntegralConvolutionPlot[array] generates a line integral convolution plot of white noise convolved with the vector field defined by array.
ListLineIntegralConvolutionPlot[{{{{x1,y1},{vx1,vy1}},…},image}] generates a line integral convolution plot of image convolved with the vector field defined by vectors {vxi,vyi} at specified points {xi,yi}.
ListLineIntegralConvolutionPlot[{{{x1,y1},{vx1,vy1}},…}] generates a line integral convolution plot of white noise convolved with the vector field defined by {vxi,vyi}.
ListLinePlot
ListLinePlot[{y1,…,yn}] plots a line through the points {1,y1}, …, {n,yn}.
ListLinePlot[{{x1,y1},…,{xn,yn}}] plots a line through the points {x1,y1}, …, {xn,yn}.
ListLinePlot[{data1,data2,…}] plots lines from all the datai.
ListLinePlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListLinePlot3D
ListLinePlot3D[{{x1,y1,z1},{x2,y2,z2},…,{xn,yn,zn}}] plots a curve through the 3D points {xi,yi,zi}.
ListLinePlot3D[{{z11,z12,…,z1n},…,{zm1,zm2,…,zmn}}] plots each row {zi1,zi2,…,zin} as a curve in the x direction, with successive curves stacked in the y direction.
ListLinePlot3D[{data1,data2,…}] plots curves through multiple sets of {x,y,z} points.
ListLogLinearPlot
ListLogLinearPlot[{y1,y2,…}] makes a log-linear plot of the yi, assumed to correspond to x coordinates 1, 2, ….
ListLogLinearPlot[{{x1,y1},{x2,y2},…}] makes a log-linear plot of the specified list of x and y values.
ListLogLinearPlot[{list1,list2,…}] plots several lists of values.
ListLogLinearPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListLogLogPlot
ListLogLogPlot[{y1,y2,…}] makes a log-log plot of the yi, assumed to correspond to x coordinates 1, 2, ….
ListLogLogPlot[{{x1,y1},{x2,y2},…}] makes a log-log plot of the specified list of x and y values.
ListLogLogPlot[{data1,data2,…}] plots data from all the datai.
ListLogLogPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListLogPlot
ListLogPlot[{y1,y2,…}] makes a log plot of the yi, assumed to correspond to x coordinates 1, 2, ….
ListLogPlot[{{x1,y1},{x2,y2},…}] makes a log plot of the specified list of x and y values.
ListLogPlot[{data1,data2,…}] plots data from all the datai.
ListLogPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListPlay
ListPlay[{a1,a2,…}] creates an object that plays as a sound whose amplitude is given by the sequence of levels ai.
ListPlot
ListPlot[{y1,…,yn}] plots regularly spaced points {i,yi}.
ListPlot[{{x1,y1},…,{xn,yn}}] generates a scatter plot with points {xi,yi}.
ListPlot[{data1,data2,…}] plots points from all the datai.
ListPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListPlot3D
ListPlot3D[{{f11,…,f1n},…,{fm1,…,fmn}}] generates a surface with height fij at {x,y} position {j,i}.
ListPlot3D[{{x1,y1,f1},…,{xk,yk,fk}}] generates a surface with height fi at {x,y} position {xi,yi}.
ListPlot3D[{data1,data2,…}] plots the surfaces corresponding to each of the datai.
ListPointPlot3D
ListPointPlot3D[{{x1,y1,z1},{x2,y2,z2},…}] generates a 3D scatter plot of points with coordinates {xi,yi,zi}.
ListPointPlot3D[array] generates a 3D scatter plot of points with a 2D array of height values.
ListPointPlot3D[{data1,data2,…}] plots several collections of points, by default in different colors.
ListPolarPlot
ListPolarPlot[{r1,r2,…}] plots points equally spaced in angle at radii ri.
ListPolarPlot[{{θ1,r1},{θ2,r2},…}] plots points at polar coordinates θi, ri.
ListPolarPlot[{list1,list2,…}] plots several lists of values.
ListQ
ListQ[expr] gives True if the head of expr is List, and False otherwise.
ListSliceContourPlot3D
ListSliceContourPlot3D[farr,surf] generates a contour plot of the three-dimensional farr of values sliced to the surface surf.
ListSliceContourPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…},surf] generates a slice contour plot for the values fi at points {xi,yi,zi}.
ListSliceContourPlot3D[…,{surf1,surf2,…}] generates slice contour plots over several slices surf1, surf2, ….
ListSliceDensityPlot3D
ListSliceDensityPlot3D[farr,surf] generates a density plot of the three-dimensional farr of values sliced to the surface surf.
ListSliceDensityPlot3D[{{x1,y1,z1,f1},{x2,y2,z2,f2},…},surf] generates a slice density plot for the values fi at points {xi,yi,zi}.
ListSliceDensityPlot3D[…,{surf1,surf2,…}] generates slice density plots over several slices surf1, surf2, ….
ListSliceVectorPlot3D
ListSliceVectorPlot3D[varr,surf] generates a vector plot from a 3D array varr of vector field values over the slice surface surf.
ListSliceVectorPlot3D[…,{surf1,surf2,…}] generates a slice vector plot over several surfaces surf1, surf2, ….
ListStepPlot
ListStepPlot[{y1,y2,…}] plots the values y1, y2, … in steps at points 1, 2, ….
ListStepPlot[{{x1,y1},{x2,y2},…}] plots the values y1, y2, … in steps at points x1, x2, ….
ListStepPlot[{data1,data2,…}] plots data from all the datai.
ListStepPlot[data,step] plots using steps specified by step.
ListStepPlot[{…,w[datai,…],…}] plots datai with features defined by the symbolic wrapper w.
ListStreamDensityPlot
ListStreamDensityPlot[varr] generates a stream density plot from an array varr of vector and scalar field values {{vxij,vyij},rij}.
ListStreamDensityPlot[{{{x1,y1},{{vx1,vy1},r1}},…}] generates a stream density plot from vector and scalar field values {{vxi,vyi},ri} given at specified points {xi,yi}.
ListStreamDensityPlot[{data1,data2,…}] plots data for several vector and scalar fields.
ListStreamPlot
ListStreamPlot[varr] generates a stream plot from an array varr of vectors.
ListStreamPlot[{{{x1,y1},{vx1,vy1}},…}] generates a stream plot from vectors {vxi,vyi} given at points {xi,yi}.
ListStreamPlot[{data1,data2,…}] plots data for several vector fields.
ListStreamPlot3D
ListStreamPlot3D[varr] plots streamlines for the vector field given as an array of vectors.
ListSurfacePlot3D
ListSurfacePlot3D[{{x1,y1,z1},{x2,y2,z2},…}] plots a three-dimensional surface constructed to fit the specified points.
ListVectorDensityPlot
ListVectorDensityPlot[varr] generates a vector density plot from an array varr of vector and scalar field values {{vxij,vyij},rij}.
ListVectorDensityPlot[{{{x1,y1},{{vx1,vy1},r1}},…}] generates a vector density plot from vector and scalar field values {{vxi,vyi},ri} given at specified points {xi,yi}.
ListVectorDensityPlot[{data1,data2,…}] plots data for several vector and scalar fields.
ListVectorDisplacementPlot
ListVectorDisplacementPlot[{{{vx11,vy11},…,{vx1n,vy1n}},…,{{vxm1,vym1},…,{vxmn,vymn}}}] generates a displacement plot from an array of vector displacements {vxij,vyij}.
ListVectorDisplacementPlot[{{{x1,y1},{vx1,vy1}},…,{{x1,y1},{vx1,vy1}}}] generates a displacement plot from displacements {vxi,vyi} at point {xi,yi}.
ListVectorDisplacementPlot[{{ {{vx11,vy11},s11},…,{{vx1n,vy1n},s1n}},…,{ {{vxmi,vym1},sm1},…,{{vxmn,vymn},smn}}}] uses the scalar values sij to color the displaced region.
ListVectorDisplacementPlot[{ {{vx1,vy1},s1},…,{{vxn,vyn},sn}}] uses the scalar values si at point {xi,yi} to color the displaced region.
ListVectorDisplacementPlot[…,reg] plots the displacement over the region reg.
ListVectorDisplacementPlot3D
ListVectorDisplacementPlot3D[{{{vx11,vy11,vz11},…,{vx1n,vy1n,vz1n}},…,{{vxm1,vym1,vzm1},…,{vxmn,vymn,vzmn}}}] generates a displacement plot from an array of vector displacements {vxij,vyij,vzij}.
ListVectorDisplacementPlot3D[{{{x1,y1,z1},{vx1,vy1,vz1}},…,{{xn,yn,zn},{vxn,vyn,vzn}}}] generates a displacement plot from displacements {vxi,vyi,vzi} at point {xi,yi,zi}.
ListVectorDisplacementPlot3D[{{{{vx11,vy11,vz11},s11},…,{{vx1n,vy1n,vz1n},s1n}},…,{{{vxm1,vym1,vzm1},sm1},…,{{vxmn,vymn,vzmn},smn}}] uses the scalar values sij to color the displaced region.
ListVectorDisplacementPlot3D[{{{x1,y1,z1},{{vx1,vy1,vz1},s1}},…,{{xn,yn,zn},{{vxn,vyn,vzn},sn}}}] uses the scalar values si at point {xi,yi,zi} to color the displaced region.
ListVectorDisplacementPlot3D[…,reg] plots the displacement over the region reg.
ListVectorPlot
ListVectorPlot[varr] generates a vector plot from an array varr of vectors.
ListVectorPlot[{{{x1,y1},{vx1,vy1}},…}] generates a vector plot from vectors {vxi,vyi} given at specified points {xi,yi}.
ListVectorPlot[{data1,data2,…}] plots data for several vector fields.
ListVectorPlot3D
ListVectorPlot3D[varr] generates a 3D vector plot from a 3D array of vector field values.
ListVectorPlot3D[{data1,data2,…}] plots data for several vector fields.
ListZTransform
ListZTransform[list,z] gives the Z transform of list as a function of z.
ListZTransform[list,z,k] places the first element of list at integer time k on the infinite time axis.
ListZTransform[list,{z1,z2,…},{k1,k2,…}] gives the multidimensional Z transform.
LocalAdaptiveBinarize
LocalAdaptiveBinarize[image,r] creates a binary image from image by replacing values above the mean of the range-r neighborhood with 1 and others with 0.
LocalAdaptiveBinarize[image,r,{α,β,γ}] replaces values above α μ+β σ+γ with 1 and others with 0, where μ and σ are the local mean and standard deviation.
LocalClusteringCoefficient
LocalClusteringCoefficient[g] gives the list of local clustering coefficients of all vertices in the graph g.
LocalClusteringCoefficient[g,v] gives the local clustering coefficient of the vertex v in the graph g.
LocalClusteringCoefficient[{v->w,…},…] uses rules v->w to specify the graph g.
LocalizeVariables
LocalizeVariables is an option to Manipulate that determines whether the values of variables associated with controls should be localized.
LocalObject
LocalObject[] represents a new anonymous local object.
LocalObject["file:///…"] represents a local object with a given file path.
LocalObject["relpath"] represents a local object with the given relative path.
LocalObject["relpath","lbase"] represents a local object relative to the base lbase.
LocalObjects
LocalObjects[] gives a list of local objects in your current local base directory.
LocalObjects[dir] gives a list of local objects in the local directory dir.
LocalResponseNormalizationLayer
LocalResponseNormalizationLayer[] represents a net layer that normalizes its input by averaging across neighboring input channels.
LocalSubmit
LocalSubmit[expr] submits a task to evaluate expr in a separate kernel.
LocalSubmit[ScheduledTask[expr, spec]] submits a task to evaluate expr in a separate kernel on the schedule defined by spec.
LocalSymbol
LocalSymbol["name"] represents a symbol whose value is persistently stored in the local file system.
LocalSymbol[obj] represents a persistent symbol corresponding to the local object obj.
LocalTime
LocalTime[] gives a DateObject corresponding to the current local time at the current geo location.
LocalTime[loc] gives the current local time at the geo location specified by loc.
LocalTime[loc,time] gives the local time corresponding to the date object time at the geo location loc.
LocalTime[loc,time,func] uses func to determine what to return for extended geographic regions.
LocalTimeZone
LocalTimeZone[] gives the current time zone for the current geo location.
LocalTimeZone[loc] gives the current time zone for the geo location specified by loc.
LocalTimeZone[loc,date] gives the time zone for the geo location loc on the specified date.
LocalTimeZone[loc,date,"prop"] gives the specified property of the time zone.
LocationEquivalenceTest
LocationEquivalenceTest[{data1,data2,…}] tests whether the means or medians of the datai are equal.
LocationEquivalenceTest[{data1,…},"property"] returns the value of "property".
LocationTest
LocationTest[data] tests whether the mean or median of the data is zero.
LocationTest[{data1,data2}] tests whether the means or medians of data1 and data2 are equal.
LocationTest[dspec,μ0] tests a location measure against μ0.
LocationTest[dspec,μ0,"property"] returns the value of "property".
LocatorAutoCreate
LocatorAutoCreate is an option for LocatorPane, Manipulate, and related functions that specifies whether new locators should be created when clicking away from existing locators.
LocatorRegion
LocatorRegion is an option for Locator that specifies where the locator object should by default be allowed to go when it is dragged.
Locked
Locked is an attribute that, once assigned, prevents modification of any attributes of a symbol.
Log
Log[z] gives the natural logarithm of z (logarithm to base e).
Log[b,z] gives the logarithm to base b.
Log10
Log10[x] gives the base-10 logarithm of x.
Log2
Log2[x] gives the base-2 logarithm of x.
LogBarnesG
LogBarnesG[z] gives the logarithm of the Barnes G-function logG(z).
LogGamma
LogGamma[z] gives the logarithm of the gamma function log Γ(z).
LogGammaDistribution
LogGammaDistribution[α,β,μ] represents a log-gamma distribution with shape parameters α and β and location parameter μ.
LogicalExpand
LogicalExpand[expr] expands out logical combinations of equations, inequalities, and other functions.
LogIntegral
LogIntegral[z] is the logarithmic integral function li(z).
LogisticDistribution
LogisticDistribution[μ,β] represents a logistic distribution with mean μ and scale parameter β.
LogisticDistribution[] represents a logistic distribution with mean 0 and scale parameter 1.
LogisticSigmoid
LogisticSigmoid[z] gives the logistic sigmoid function.
LogLikelihood
LogLikelihood[dist,{x1,x2,…}] gives the log‐likelihood function for observations x1, x2, … from the distribution dist.
LogLikelihood[proc,{{t1,x1},{t2,x2},…}] gives the log-likelihood function for the observations xi at time ti from the process proc.
LogLikelihood[proc,{path1,path2,…}] gives the log-likelihood function for the observations from path1, path2, … from the process proc.
LogLinearPlot
LogLinearPlot[f,{x,xmin,xmax}] generates a log-linear plot of f as a function of x from xmin to xmax.
LogLinearPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi.
LogLinearPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
LogLinearPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
LogLogisticDistribution
LogLogisticDistribution[γ,σ] represents a log-logistic distribution with shape parameter γ and scale parameter σ.
LogLogPlot
LogLogPlot[f,{x,xmin,xmax}] generates a log-log plot of f as a function of x from xmin to xmax.
LogLogPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi.
LogLogPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
LogLogPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
LogMultinormalDistribution
LogMultinormalDistribution[μ,Σ] represents a log-multinormal distribution with parameters μ and Σ.
LogNormalDistribution
LogNormalDistribution[μ,σ] represents a lognormal distribution derived from a normal distribution with mean μ and standard deviation σ.
LogPlot
LogPlot[f,{x,xmin,xmax}] generates a log plot of f as a function of x from xmin to xmax.
LogPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi.
LogPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
LogPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
LogRankTest
LogRankTest[{data1,data2,…}] tests for equal hazard rates among the datai using a log-rank type test.
LogRankTest[{data1,data2,…},wspec] performs a weighted log-rank test with weights wspec.
LogRankTest[{data1,…},wspec,"property"] returns the value of "property".
LogSeriesDistribution
LogSeriesDistribution[θ] represents a logarithmic series distribution with parameter θ.
Longest
Longest[p] is a pattern object that matches the longest sequence consistent with the pattern p.
LongestCommonSequence
LongestCommonSequence[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings or lists s1 and s2.
LongestCommonSequence[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings, lists or biomolecular sequences s1 and s2.
LongestCommonSequencePositions
LongestCommonSequencePositions[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings or lists s1 and s2 and returns their positions.
LongestCommonSequencePositions[s1,s2] finds the longest sequence of contiguous or disjoint elements common to the strings, lists or biomolecular sequences s1 and s2 and returns their positions.
LongestCommonSubsequence
LongestCommonSubsequence[s1,s2] finds the longest contiguous subsequence of elements common to the strings or lists s1 and s2.
LongestCommonSubsequence[s1,s2] finds the longest contiguous subsequence of elements common to the strings, biomolecular sequences or lists s1 and s2.
LongestCommonSubsequencePositions
LongestCommonSubsequencePositions[s1,s2] finds the longest contiguous subsequence of elements common to the strings or lists s1 and s2 and returns their positions {pos1,pos2} in s1 and s2.
LongestCommonSubsequencePositions[s1,s2] finds the longest contiguous subsequence of elements common to the strings, biomolecular sequences or lists s1 and s2 and returns their positions {pos1,pos2} in s1 and s2.
LongestMatch
LongestMatch[p] is a string pattern object matching the longest sequence of characters consistent with the string pattern p.
LongestOrderedSequence
LongestOrderedSequence[list] finds the longest ordered sequence of contiguous or disjoint elements in list.
LongestOrderedSequence[list,p] finds the longest ordered sequence using the ordering function p.
LongForm
LongForm is an option for Information. With LongForm -> True, the full information of a symbol is printed. With LongForm -> False the usage of a symbol is printed.
Longitude
Longitude[pos] gives the longitude in degrees of a geographic position specified by pos.
Longitude[pos,datum] gives the longitude referring to the specified geodetic datum.
LongLeftArrow
LongLeftArrow[x,y,…] displays as x⟵y⟵….
LongLeftRightArrow
LongLeftRightArrow[x,y,…] displays as x⟷y⟷….
LongRightArrow
LongRightArrow[x,y,…] displays as x⟶y⟶….
LongShortTermMemoryLayer
LongShortTermMemoryLayer[n] represents a trainable recurrent layer that takes a sequence of vectors and produces a sequence of vectors, each of size n.
LongShortTermMemoryLayer[n,opts] includes options for weights and other parameters.
Lookup
Lookup[assoc,key] looks up the value associated with key in the association assoc; if the key is not present, Missing["KeyAbsent",key] is returned.
Lookup[assoc,{key1,key2,…}] gives a list of the values associated with the keyi.
Lookup[{assoc1,assoc2,…},key] gives a list corresponding to the value of key in each associ.
Lookup[assoc,key,default] gives default if the key is not present.
Lookup[assoc,keys,default,h] looks up the values associated with keys, wrapping each of them with head h before evaluation.
Lookup[key] represents an operator form of Lookup that can be applied to an expression.
Loopback
Loopback is a setting for the LinkMode option of LinkOpen. LinkMode->Loopback causes a link to be created that is not connected to another program. Expressions written to the link are read back from the same link.
LoopFreeGraphQ
LoopFreeGraphQ[g] yields True if the graph g has no self-loops, and False otherwise.
Looping
Looping is an option for VideoStream, AudioStream and related functions to specify the playback looping.
LossFunction
LossFunction is an option for NetTrain that specifies how to compare actual and requested outputs from a neural net.
LowerCaseQ
LowerCaseQ[string] yields True if all the characters in the string are lowercase letters, and yields False otherwise.
LowerLeftArrow
LowerLeftArrow[x,y,…] displays as x↙y↙….
LowerRightArrow
LowerRightArrow[x,y,…] displays as x↘y↘….
LowpassFilter
LowpassFilter[data,ωc] applies a lowpass filter with a cutoff frequency ωc to an array of data.
LowpassFilter[data,ωc,n] uses a filter kernel of length n.
LowpassFilter[data,ωc,n,wfun] applies a smoothing window wfun to the filter kernel.
LQEstimatorGains
LQEstimatorGains[ssm,{w,v}] gives the optimal estimator gain matrix for the StateSpaceModel ssm, with process and measurement noise covariance matrices w and v.
LQEstimatorGains[ssm,{w,v,h}] includes the cross-covariance matrix h.
LQEstimatorGains[{ssm,sensors},{…}] specifies sensors as the noisy measurements of ssm.
LQEstimatorGains[{ssm,sensors,dinputs},{…}] specifies dinputs as the deterministic inputs of ssm.
LQGRegulator
LQGRegulator[sspec,cvs,wts] gives the optimal output feedback controller for the stochastic system specification sspec with noise covariance matrices cvs that minimizes a cost function with weights wts.
LQGRegulator[…,"prop"] gives the value of the property "prop".
LQOutputRegulatorGains
LQOutputRegulatorGains[sspec,wts] gives the state feedback gains for the system specification sspec that minimizes an output cost function with weights wts.
LQOutputRegulatorGains[…,"prop"] gives the value of the property "prop".
LQRegulatorGains
LQRegulatorGains[sspec,wts] gives the state feedback gains for the system specification sspec that minimizes a cost function with weights wts.
LQRegulatorGains[…,"prop"] gives the value of the property "prop".
LucasL
LucasL[n] gives the Lucas number Ln.
LucasL[n,x] gives the Lucas polynomial Ln(x).
LuccioSamiComponents
LuccioSamiComponents[g] gives the Luccio–Sami components of the graph g.
LuccioSamiComponents[g,{v1,v2,…}] gives the components that include at least one of the vertices v1, v2, … .
LuccioSamiComponents[{v->w,…},…] uses rules v->w to specify the graph g.
LUDecomposition
LUDecomposition[m] generates a representation of the LU decomposition of a square matrix m.
LunarEclipse
LunarEclipse[] gives the time of the next lunar eclipse.
LunarEclipse[datespec] gives the time for the next lunar eclipse after the specified date.
LunarEclipse[propertyspec] gives the specified property value for the next lunar eclipse.
LunarEclipse[datespec,propertyspec] gives the specified property value for the next lunar eclipse after the specified date.
LUVColor
LUVColor[l,u,v] represents a color in the LUV color space with lightness l and color components u and v.
LUVColor[l,u,v,a] specifies opacity a.
LUVColor["string"] returns a color from an HTML color name etc.
LUVColor[color] returns the LUV representation of color.
LyapunovSolve
LyapunovSolve[a,c] finds a solution x of the matrix Lyapunov equation a.x+x.ac.
LyapunovSolve[a,b,c] solves a.x+x.bc.
LyapunovSolve[{a,d},c] solves a.x.d+d.x.ac.
LyapunovSolve[{a,d},{b,e},c] solves a.x.e+d.x.bc.
LyonsGroupLy
LyonsGroupLy[] represents the sporadic simple Lyons group Ly.
MachineID
MachineID is an option to Encode which specifies the required value of $MachineID on the computer that reads the encoded file. If no value is specified, any value of $MachineID is allowed on the file-reading computer. A setting for MachineID must be a string.
MachineName
MachineName is an option to Encode which specifies the required value of $MachineName on the computer that reads the encoded file. If no value is specified, any value of $MachineName is allowed on the file-reading computer. A setting for MachineName must be a string.
MachineNumberQ
MachineNumberQ[expr] returns True if expr is a machine‐precision real or complex number, and returns False otherwise.
MachinePrecision
MachinePrecision is a symbol used to indicate machine‐number precision.
Magenta
Magenta represents the color magenta in graphics or style specifications.
Magnification
Magnification is an option for Style and Cell that specifies what magnification to use for display.
Magnify
Magnify[expr,r] represents an object to be displayed with magnification r.
Magnify[expr] displays with expr magnified by a fixed factor.
MailAddressValidation
MailAddressValidation is an option for SendMail that specifies whether and how to validate email addresses.
MailExecute
MailExecute[cmd,target] executes the mail command cmd on the target mail server connection, folder, file or item(s).
MailFolder
MailFolder[…] represents a mail folder associated with an active mail server connection.
MailItem
MailItem[…] represents an item of mail associated with an active mail server connection.
MailReceiverFunction
MailReceiverFunction[fun] represents a mail receiver function that applies fun to any mail message it receives.
MailResponseFunction
MailResponseFunction is an option for MailReceiverFunction that specifies what function to apply to respond to the sender of mail received by a MailReceiverFunction.
MailSearch
MailSearch[folder,assoc] searches the specified mail folder for messages with properties matching elements in assoc.
MailSearch[assoc] searches the current default mail inbox.
MailSearch[] gives the list of unread messages in the current default mail inbox.
MailServerConnect
MailServerConnect[] connects to your default incoming mail server.
MailServerConnect["server"] connects to the specified incoming mail server "server".
MailServerConnect["server",userid] connects using the specified user ID userid.
MailServerConnect["server",userid,password] connects using userid and password.
MailServerConnection
MailServerConnection[…] is a symbolic representation of a connection to an incoming mail server.
MailSettings
MailSettings is an option for SendMail and MailServerConnect to specify mail settings.
MainSolve
MainSolve[eqns] is the underlying function for transforming systems of equations. Solve and Eliminate call it. The equations must be of the form lhs == rhs. They can be combined using && and ||. MainSolve returns False if no solutions to the equations exist, and True if all values of variables are solutions. MainSolve rearranges the equations using certain directives. MainSolve[eqns, vars, elim, rest] attempts to rearrange the equations eqns so as to solve for the variables vars, and eliminate the variables elim. The list rest can be included to specify the elimination order for any remaining variables.
Majority
Majority[e1,e2,…] gives True if the majority of the ei are True, and False if the majority are False.
MakeRules
MakeRules is an option to Solve and related functions. With MakeRules -> True, the result is presented as an AlgebraicRulesData object. With MakeRules -> False, the result is presented as a list of rules.
ManagedLibraryExpressionID
ManagedLibraryExpressionID[expr] returns the positive integer ID associated with expr if it is a managed library expression and $Failed otherwise.
ManagedLibraryExpressionID[expr,mname] only returns the ID if expr is associated with the registered manager having name mname.
ManagedLibraryExpressionQ
ManagedLibraryExpressionQ[expr] returns True if expr is a managed library expression and False otherwise.
ManagedLibraryExpressionQ[expr,mname] only returns True if expr is associated with the registered manager having name mname.
MandelbrotSetBoettcher
MandelbrotSetBoettcher[z] gives the Böttcher coordinate of z with respect to the Mandelbrot set.
MandelbrotSetDistance
MandelbrotSetDistance[c] estimates the distance from c to the nearest point in the Mandelbrot set.
MandelbrotSetDistance[c,"Interior"] estimates the distance from c to the nearest point in the complement of the Mandelbrot set.
MandelbrotSetIterationCount
MandelbrotSetIterationCount[c] returns the number of iterations of the function f(z)z2+c, beginning with z0, that are needed to determine whether c is in the Mandelbrot set.
MandelbrotSetMemberQ
MandelbrotSetMemberQ[z] returns True if z is in the Mandelbrot set, and False otherwise.
MandelbrotSetPlot
MandelbrotSetPlot[{zmin,zmax}] plots the portion of the Mandelbrot set inside the rectangle with corners zmin and zmax.
MandelbrotSetPlot[] plots the Mandelbrot set over a default rectangle.
MangoldtLambda
MangoldtLambda[n] gives the von Mangoldt function Λ(n).
ManhattanDistance
ManhattanDistance[u,v] gives the Manhattan or "city block" distance between vectors u and v.
Manipulate
Manipulate[expr,{u,umin,umax}] generates a version of expr with controls added to allow interactive manipulation of the value of u.
Manipulate[expr,{u,umin,umax,du}] allows the value of u to vary between umin and umax in steps du.
Manipulate[expr,{{u,uinit},umin,umax,…}] takes the initial value of u to be uinit.
Manipulate[expr,{{u,uinit,ulbl},…}] labels the controls for u with ulbl.
Manipulate[expr,{u,{u1,u2,…}}] allows u to take on discrete values u1,u2,….
Manipulate[expr,{u,…},{v,…},…] provides controls to manipulate each of the u,v,….
Manipulate[expr,cu->{u,…},cv->{v, …},…] links the controls to the specified controllers on an external device.
MannedSpaceMissionData
MannedSpaceMissionData[entity,property] gives the value of the specified property for the manned space mission entity.
MannedSpaceMissionData[{entity1,entity2,…},property] gives a list of property values for the specified manned space mission entities.
MannedSpaceMissionData[name,property,annotation] gives the specified annotation associated with the given property.
MannWhitneyTest
MannWhitneyTest[{data1,data2}] tests whether the medians of data1 and data2 are equal.
MannWhitneyTest[dspec,μ0] tests the median difference against μ0.
MannWhitneyTest[dspec,μ0,"property"] returns the value of "property".
MantissaExponent
MantissaExponent[x] gives a list containing the mantissa and exponent of a number x.
MantissaExponent[x,b] gives the base‐b mantissa and exponent of x.
Manual
Manual represents an option or other value that is to be selected manually, usually by some form of interactive manipulation.
Map
Map[f,expr] or f/@expr applies f to each element on the first level in expr.
Map[f,expr,levelspec] applies f to parts of expr specified by levelspec.
Map[f] represents an operator form of Map that can be applied to an expression.
MapAll
MapAll[f,expr] or f//@expr applies f to every subexpression in expr.
MapAt
MapAt[f,expr,n] applies f to the element at position n in expr. If n is negative, the position is counted from the end.
MapAt[f,expr,{i,j,…}] applies f to the part of expr at position {i,j,…}.
MapAt[f,expr,{{i1,j1,…},{i2,j2,…},…}] applies f to parts of expr at several positions.
MapAt[f,pos] represents an operator form of MapAt that can be applied to an expression.
MapIndexed
MapIndexed[f,expr] applies f to the elements of expr, giving the part specification of each element as a second argument to f.
MapIndexed[f,expr,levelspec] applies f to all parts of expr on levels specified by levelspec.
MapIndexed[f] represents an operator form of MapIndexed that can be applied to an expression.
MAProcess
MAProcess[{b1,…,bq},v] represents a moving-average process of order q with normal white noise variance v.
MAProcess[{b1,…,bq},Σ] represents a vector MA process with multinormal white noise covariance matrix Σ.
MAProcess[{b1,…,bq},v,init] represents an MA process with initial data init.
MAProcess[c,…] represents an MA process with a constant c.
MapThread
MapThread[f,{{a1,a2,…},{b1,b2,…},…}] gives {f[a1,b1,…],f[a2,b2,…],…}.
MapThread[f,{expr1,expr2,…},n] applies f to the parts of the expri at level n.
MapThread[f] represents an operator form of MapThread that can be applied to an expression.
MarchenkoPasturDistribution
MarchenkoPasturDistribution[λ,σ] represents a Marchenko–Pastur distribution with asymptotic ratio λ and scale parameter σ.
MarchenkoPasturDistribution[λ] represents a Marchenko–Pastur distribution with unit scale parameter.
MarcumQ
MarcumQ[m,a,b] gives Marcum's Q function Qm(a,b).
MarcumQ[m,a,b0,b1] gives Marcum's Q function Qm(a,b0)-Qm(a,b1).
MardiaCombinedTest
MardiaCombinedTest[data] tests whether data follows a MultinormalDistribution using the Mardia combined test.
MardiaCombinedTest[data,"property"] returns the value of "property".
MardiaKurtosisTest
MardiaKurtosisTest[data] tests whether data follows a MultinormalDistribution using the Mardia kurtosis test.
MardiaKurtosisTest[data,"property"] returns the value of "property".
MardiaSkewnessTest
MardiaSkewnessTest[data] tests whether data follows a MultinormalDistribution using the Mardia skewness test.
MardiaSkewnessTest[data,"property"] returns the value of "property".
MarginalDistribution
MarginalDistribution[dist,k] represents a univariate marginal distribution of the kth coordinate from the multivariate distribution dist.
MarginalDistribution[dist,{k1,k2,…}] represents a multivariate marginal distribution of the {k1,k2,…} coordinates.
MarkovProcessProperties
MarkovProcessProperties[mproc] gives a summary of properties for the finite state Markov process mproc.
MarkovProcessProperties[mproc,"property"] gives the specified "property" for the process mproc.
Masking
Masking is an option for various image and signal processing functions that specifies on which regions they should operate.
MassConcentrationCondition
MassConcentrationCondition[pred,vars,pars] represents a mass concentration boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassConcentrationCondition[pred,vars,pars,lkey] represents a thermal surface boundary condition with local parameters specified in pars[lkey].
MassFluxValue
MassFluxValue[pred,vars,pars] represents a mass flux boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassFluxValue[pred,vars,pars,lkey] represents a mass flux boundary condition with local parameters specified in pars[lkey].
MassImpermeableBoundaryValue
MassImpermeableBoundaryValue[pred,vars,pars] represents a mass impermeable boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassImpermeableBoundaryValue[pred,vars,pars,lkey] represents a mass impermeable boundary condition with local parameters specified in pars[lkey].
MassOutflowValue
MassOutflowValue[pred,vars,pars] represents a mass outflow boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassOutflowValue[pred,vars,pars,lkey] represents a mass outflow boundary condition with local parameters specified in pars[lkey].
MassSymmetryValue
MassSymmetryValue[pred,vars,pars] represents a mass symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassSymmetryValue[pred,vars,pars,lkey] represents a mass symmetry boundary condition with local parameters specified in pars[lkey].
MassTransferValue
MassTransferValue[pred,vars,pars] represents a mass transfer boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
MassTransferValue[pred,vars,pars,lkey] represents a mass transfer boundary condition with local parameters specified in pars[lkey].
MassTransportPDEComponent
MassTransportPDEComponent[vars,pars] yields a mass transport PDE term with variables vars and parameters pars.
MatchingDissimilarity
MatchingDissimilarity[u,v] gives the matching dissimilarity between Boolean vectors u and v.
MatchLocalNameQ
MatchLocalNameQ is an internal symbol.
MatchLocalNames
MatchLocalNames is an option for Trace and related functions that specifies whether symbols such as x should match symbols with local names of the form x$nnn.
MatchQ
MatchQ[expr,form] returns True if expr matches the pattern form, and returns False otherwise.
MatchQ[form] represents an operator form of MatchQ that can be applied to an expression.
MaterialShading
MaterialShading["material"] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn with the material "material" appearance.
MaterialShading[{"material",col}] uses the specified color col as the base color.
MaterialShading[<|parm1->val1,parm2->val2,…|>] uses the specified parameters parms.
MathematicalFunctionData
MathematicalFunctionData[entity,property] gives data corresponding to property for the mathematical function specified by entity.
MathematicalFunctionData[entprop,annotation] gives data corresponding to the given entity or property in the format specified by annotation.
MathematicalFunctionData[entity,property,annotation] gives data for the given entity-property pair in the format specified by annotation.
MathematicalFunctionData[entity,property,{qual1->val1,qual2->val2,…}] gives data for the given entity-property pair with property qualifiers qual1, qual2, … set to the given values.
MathematicalFunctionData[entity,property,annotation,{qual1->val1,qual2->val2,…}] gives data corresponding to the given entity, property and annotation format, with property qualifiers qual1, qual2, … set to the given values.
MathieuC
MathieuC[a,q,z] gives the even Mathieu function with characteristic value a and parameter q.
MathieuCharacteristicA
MathieuCharacteristicA[r,q] gives the characteristic value ar for even Mathieu functions with characteristic exponent r and parameter q.
MathieuCharacteristicB
MathieuCharacteristicB[r,q] gives the characteristic value br for odd Mathieu functions with characteristic exponent r and parameter q.
MathieuCharacteristicExponent
MathieuCharacteristicExponent[a,q] gives the characteristic exponent r for Mathieu functions with characteristic value a and parameter q.
MathieuCPrime
MathieuCPrime[a,q,z] gives the derivative with respect to z of the even Mathieu function with characteristic value a and parameter q.
MathieuGroupM11
MathieuGroupM11[] represents the sporadic simple Mathieu group M11.
MathieuGroupM12
MathieuGroupM12[] represents the sporadic simple Mathieu group M12.
MathieuGroupM22
MathieuGroupM22[] represents the sporadic simple Mathieu group M22.
MathieuGroupM23
MathieuGroupM23[] represents the sporadic simple Mathieu group M23.
MathieuGroupM24
MathieuGroupM24[] represents the sporadic simple Mathieu group M24.
MathieuS
MathieuS[a,q,z] gives the odd Mathieu function with characteristic value a and parameter q.
MathieuSPrime
MathieuSPrime[a,q,z] gives the derivative with respect to z of the odd Mathieu function with characteristic value a and parameter q.
MathMLForm
MathMLForm[expr] prints as a MathML form of expr.
Matrices
Matrices[{d1,d2}] represents the domain of matrices of dimensions d1×d2.
Matrices[{d1,d2},dom] represents the domain of matrices of dimensions d1×d2, with components in the domain dom.
Matrices[{d1,d2},dom,sym] represents the subdomain of matrices d1×d2 with symmetry sym.
MatrixExp
MatrixExp[m] gives the matrix exponential of m.
MatrixExp[m,v] gives the matrix exponential of m applied to the vector v.
MatrixForm
MatrixForm[list] prints with the elements of list arranged in a regular array.
MatrixFunction
MatrixFunction[f,m] gives the matrix generated by the scalar function f at the matrix argument m.
MatrixLog
MatrixLog[m] gives the matrix logarithm of a matrix m.
MatrixNormalDistribution
MatrixNormalDistribution[Σrow,Σcol] represents zero mean matrix normal distribution with row covariance matrix Σrow and column covariance matrix Σcol.
MatrixNormalDistribution[μ,Σrow,Σcol] represents matrix normal distribution with mean matrix μ.
MatrixPlot
MatrixPlot[m] generates a plot that gives a visual representation of the values of elements in a matrix.
MatrixPower
MatrixPower[m,n] gives the nth matrix power of the matrix m.
MatrixPower[m,n,v] gives the nth matrix power of the matrix m applied to the vector v.
MatrixPropertyDistribution
MatrixPropertyDistribution[expr,xmdist] represents the distribution of the matrix property expr where the matrix-valued random variable x follows the matrix distribution mdist.
MatrixPropertyDistribution[expr,{x1mdist1,x2mdist2,…}] represents the distribution where x1, x2, … are independent and follow the matrix distributions mdist1, mdist2, ….
MatrixQ
MatrixQ[expr] gives True if expr is a list of lists or a two-dimensional SparseArray object that can represent a matrix, and gives False otherwise.
MatrixQ[expr,test] gives True only if test yields True when applied to each of the matrix elements in expr.
MatrixRank
MatrixRank[m] gives the rank of the matrix m.
MatrixTDistribution
MatrixTDistribution[Σrow,Σcol,ν] represents zero mean matrix t distribution with row covariance matrix Σrow, column covariance matrix Σcol, and degrees of freedom parameter ν.
MatrixTDistribution[μ,Σrow,Σcol,ν] represents matrix t distribution with mean matrix μ.
Max
Max[x1,x2,…] yields the numerically largest of the xi.
Max[{x1,x2,…},{y1,…},…] yields the largest element of any of the lists.
MaxCellMeasure
MaxCellMeasure is an option for DiscretizeRegion and related functions that specifies the maximum cell measure for the result.
MaxColorDistance
MaxColorDistance is an option to specify the maximum distance allowed between colors.
MaxDate
MaxDate[{date1,date2,…}] gives the latest date of the datei.
MaxDate[interval] gives the endpoint of the date interval interval.
MaxDate[interval,gran] gives the endpoint of interval as specified by granularity gran.
MaxDetect
MaxDetect[image] gives a binary image in which white pixels correspond to constant extended maxima in image.
MaxDetect[image,h] finds extended maxima where the range of values is not greater than h.
MaxDetect[data,…] applies maxima detection to an array of data.
MaxDuration
MaxDuration is an option that specifies the maximum duration for audio playback or capture.
MaxExtraBandwidths
MaxExtraBandwidths is an option to SmoothKernelDistribution that controls the behavior outside that data range.
MaxExtraConditions
MaxExtraConditions is an option to Solve and related functions that specifies how many extra equational conditions on continuous parameters to allow in solutions that are given.
MaxFeatureDisplacement
MaxFeatureDisplacement is an option that specifies the maximum displacement allowed for any feature.
MaxFeatures
MaxFeatures is an option that specifies the maximum number of features that will be returned from feature detection algorithms.
MaximalBy
MaximalBy[data,f] returns a list of the elements ei of data for which the value of f[ei] is maximal.
MaximalBy[data,f,n] returns a list of the elements ei of data corresponding to the n largest f[ei].
MaximalBy[data,f,n,p] uses the ordering function p for sorting.
MaximalBy[f] represents an operator form of MaximalBy that can be applied to an expression.
Maximize
Maximize[f,x] maximizes f symbolically with respect to x.
Maximize[f,{x,y,…}] maximizes f symbolically with respect to x, y, ….
Maximize[{f,cons},{x,y,…}] maximizes f symbolically subject to the constraints cons.
Maximize[…,x∈rdom] constrains x to be in the region or domain rdom.
Maximize[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
MaxItems
MaxItems is an option that specifies the maximum number of items to be used or shown.
MaxIterations
MaxIterations is an option that specifies the maximum number of iterations that should be tried in various built-in functions and algorithms.
MaxLimit
MaxLimit[f,x->x*] gives the max limit x->x*f(x).
MaxLimit[f,{x1->x1*,…,xn->xn*}] gives the nested max limit +x1->x1*⋯ +xn->xn*f(x1,…,xn).
MaxLimit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate max limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).
MaxMemoryUsed
MaxMemoryUsed[] gives the maximum number of bytes used to store all data for the current Wolfram System session.
MaxMemoryUsed[expr] gives the maximum number of bytes used during the evaluation of expr.
MaxMixtureKernels
MaxMixtureKernels is an option for SmoothKernelDistribution and related functions that specifies the maximum number and location of kernel functions to use in the estimation.
MaxOverlapFraction
MaxOverlapFraction is an option that specifies the maximum acceptable overlap between different identifications.
MaxPlotPoints
MaxPlotPoints is an option for plotting functions like ArrayPlot and ListPlot3D that specifies the maximum number of points that will explicitly be included in the output.
MaxPoints
MaxPoints is an option for NIntegrate specifying the maximum total number of times to sample the integrand.
MaxRecursion
MaxRecursion is an option for functions like NIntegrate and Plot that specifies how many recursive subdivisions can be made.
MaxStableDistribution
MaxStableDistribution[μ,σ,ξ] represents a generalized maximum extreme value distribution with location parameter μ, scale parameter σ, and shape parameter ξ.
MaxStepFraction
MaxStepFraction is an option to functions like NDSolve that specifies the maximum fraction of the total range to cover in a single step.
MaxSteps
MaxSteps is an option to functions like NDSolve that specifies the maximum number of steps to take in generating a result.
MaxStepSize
MaxStepSize is an option to functions like NDSolve that specifies the maximum size of a single step used in generating a result.
MaxTrainingRounds
MaxTrainingRounds is an option for NetTrain and related functions that specifies the maximum number of rounds of training to do.
MaxValue
MaxValue[f,x] gives the maximum value of f with respect to x.
MaxValue[f,{x,y,…}] gives the maximum value of f with respect to x, y, ….
MaxValue[{f,cons},{x,y,…}] gives the maximum value of f subject to the constraints cons.
MaxValue[…,x∈rdom] constrains x to be in the region or domain rdom.
MaxValue[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
MaxwellDistribution
MaxwellDistribution[σ] represents a Maxwell distribution with scale parameter σ.
MaxWordGap
MaxWordGap is an option for SearchAdjustment that specifies the number of words that can occur between the terms of a phrase.
McLaughlinGroupMcL
McLaughlinGroupMcL[] represents the sporadic simple McLaughlin group McL.
Mean
Mean[data] gives the mean estimate of the elements in data.
Mean[dist] gives the mean of the distribution dist.
MeanAbsoluteLossLayer
MeanAbsoluteLossLayer[] represents a loss layer that computes the mean absolute loss between the "Input" port and "Target" port.
MeanAround
MeanAround[{x1,x2,x3,…}] gives an Around object describing the mean of the xi and its uncertainty.
MeanAround[{{x11,x12,…},{x21,…},…}] gives a VectorAround object describing the means of the vectors xi and their covariance.
MeanClusteringCoefficient
MeanClusteringCoefficient[g] gives the mean clustering coefficient of the graph g.
MeanClusteringCoefficient[{v->w,…}] uses rules v->w to specify the graph g.
MeanDegreeConnectivity
MeanDegreeConnectivity[g] gives a list of k-mean degree connectivity for the graph g for successive k=0,1,2… .
MeanDegreeConnectivity[g,"In"] gives a list of k-mean in-degree connectivity for the graph g.
MeanDegreeConnectivity[g,"Out"] gives a list of k-mean out-degree connectivity for the graph g.
MeanDegreeConnectivity[{v->w,…},…] uses rules v->w to specify the graph g.
MeanDeviation
MeanDeviation[data] gives the mean absolute deviation from the mean of the elements in data.
MeanGraphDistance
MeanGraphDistance[g] gives the mean distance between all pairs of vertices in the graph g.
MeanGraphDistance[{v->w,…}] uses rules v->w to specify the graph g.
MeanNeighborDegree
MeanNeighborDegree[g] gives a list of mean neighbor degrees of vertices for the graph g.
MeanNeighborDegree[g,"In"] gives a list of mean neighbor in-degrees.
MeanNeighborDegree[g,"Out"] gives a list of mean neighbor out-degrees.
MeanNeighborDegree[{v->w,…},…] uses rules v->w to specify the graph g.
MeanPointDensity
MeanPointDensity[pdata] estimates the mean point density λ from point data pdata in the observation region reg.
MeanPointDensity[bdata] estimates the mean point density λ from binned data bdata.
MeanPointDensity[pproc] computes the mean point density λ for point process pproc.
MeanShift
MeanShift[list,d] replaces each element in list by the mean of the values of all elements that differ by less than d.
MeanShift[list,d,{p1,p2,…}] returns the list where only the specified parts pi are replaced with mean-shifted values.
MeanShift[image,…] mean shift of the pixel values in image.
MeanSquaredLossLayer
MeanSquaredLossLayer[] represents a loss layer that computes the mean squared loss between its "Input" port and "Target" port.
Median
Median[data] gives the median estimate q&^1/4 of the elements in data.
Median[dist] gives the median of the distribution dist.
MedianDeviation
MedianDeviation[data] gives the median absolute deviation from the median q&^1/2 of the elements in data.
MedicalTestData
MedicalTestData[entity,property] gives the value of the specified property for the medical test entity.
MedicalTestData[{entity1,entity2,…},property] gives a list of property values for the specified medical test entities.
MedicalTestData[entity,property,annotation] gives the specified annotation associated with the given property.
Medium
Medium is a style or option setting that specifies that objects should be medium sized.
MeijerGReduce
MeijerGReduce[expr,x] attempts to reduce expr to a single MeijerG object as a function of x.
MeixnerDistribution
MeixnerDistribution[a,b,m,d] represents a Meixner distribution with location parameter m, scale parameter a, skew parameter b, and shape parameter d.
MellinConvolve
MellinConvolve[f,g,x,y] gives the Mellin convolution with respect to x of the expressions f and g.
MellinConvolve[f,g,{x1,x2,…},{y1,y2,…}] gives the multidimensional Mellin convolution.
MellinTransform
MellinTransform[expr,x,s] gives the Mellin transform of expr.
MellinTransform[expr,{x1,x2,…},{s1,s2,…}] gives the multidimensional Mellin transform of expr.
MemberQ
MemberQ[list,form] returns True if an element of list matches form, and False otherwise.
MemberQ[list,form,levelspec] tests all parts of list specified by levelspec.
MemberQ[form] represents an operator form of MemberQ that can be applied to an expression.
MemoryAvailable
MemoryAvailable[] gives the estimated number of bytes readily available for storing additional data in the current Wolfram Language kernel session.
MemoryConstrained
MemoryConstrained[expr,b] evaluates expr, stopping if more than b bytes of memory are requested.
MemoryConstrained[expr,b,failexpr] returns failexpr if the memory constraint is not met.
MemoryConstraint
MemoryConstraint is an option for TestReport and VerificationTest that specifies how much memory (in bytes) the test is allowed to use.
MemoryInUse
MemoryInUse[] gives the number of bytes currently being used to store all data in the current Wolfram Language kernel session.
MemoryInUse[$FrontEnd] gives the number of bytes used in the Wolfram System front end.
MengerMesh
MengerMesh[n] gives a mesh region representing the nth-step Menger sponge.
MengerMesh[n,d] gives the nth-step Menger sponge in dimension d.
Merge
Merge[{assoc1,assoc2,…},f] merges the associations associ, using the function f to combine values with the same key.
Merge[{key1->val1,key2->val2,…},f] gives an association in which values corresponding to identical keys are combined using f.
Merge[f] represents an operator form of Merge that can be applied to an expression.
MergingFunction
MergingFunction is an option for functions such as PersistentSymbol that specifies a function to apply to the list of values found.
MersennePrimeExponent
MersennePrimeExponent[n] gives the nth Mersenne prime exponent.
MersennePrimeExponentQ
MersennePrimeExponentQ[n] returns True if n is a Mersenne prime exponent, and False otherwise.
Mesh
Mesh is an option for Plot3D, DensityPlot, and other plotting functions that specifies what mesh should be drawn.
MeshCellCentroid
MeshCellCentroid is an annotation of MeshRegion and BoundaryMeshRegion objects that gives the centroids of mesh cells.
MeshCellHighlight
MeshCellHighlight is an option and annotation of MeshRegion, BoundaryMeshRegion, and related functions that specifies mesh cells to highlight.
MeshCellLabel
MeshCellLabel is an option to MeshRegion, BoundaryMeshRegion and related functions that specifies labels and placements for mesh cells.
MeshCellMarker
MeshCellMarker is an option to MeshRegion and BoundaryMeshRegion that specifies integer markers to associate with mesh cells.
MeshCellMeasure
MeshCellMeasure is an annotation of MeshRegion and BoundaryMeshRegion objects that gives the measures of mesh cells.
MeshCellQuality
MeshCellQuality is an annotation of MeshRegion and BoundaryMeshRegion objects that gives a quality measure for mesh cells.
MeshCellShapeFunction
MeshCellShapeFunction is an option and annotation for MeshRegion, BoundaryMeshRegion, and related functions that specifies functions to use to generate primitives for rendering mesh cells.
MeshCellStyle
MeshCellStyle is an option and annotation of MeshRegion, BoundaryMeshRegion, and related functions that specifies styles to use for mesh cells.
MeshConnectivityGraph
MeshConnectivityGraph[mr,0] gives a graph of points connected by lines.
MeshConnectivityGraph[mr,d] gives a graph between cells of dimension d that share a cell of dimension d-1.
MeshConnectivityGraph[mr,{d,e},r] gives a graph from cells of dimension d to cells of dimension e that share a cell of dimension r.
MeshCoordinates
MeshCoordinates[mreg] gives a list of coordinates in the mesh region mreg.
MeshFunctions
MeshFunctions is an option for plotting functions that specifies functions to use to determine the placement of mesh divisions.
MeshRefinementFunction
MeshRefinementFunction is an option for DiscretizeRegion and related functions that specifies a function to indicate whether mesh cells should be refined or not.
MeshRegionQ
MeshRegionQ[reg] yields True if the region reg is a valid MeshRegion object and False otherwise.
MeshShading
MeshShading is an option for plotting functions that gives lists of colors to use for regions between mesh divisions.
MeshStyle
MeshStyle is an option for Plot3D, DensityPlot, and other plotting functions that specifies the style in which to draw a mesh.
Message
Message[symbol::tag] prints the message symbol::tag unless it has been switched off.
Message[symbol::tag,e1,e2,…] prints a message, inserting the values of the ei as needed.
MessageDialog
MessageDialog[expr] puts up a standard message dialog that displays expr together with an OK button.
MessageDialog[expr,{lbl1:>act1,lbl2:>act2,…}] includes buttons with labels lbli that evaluate the corresponding acti if clicked.
MessageName
symbol::tag is a name for a message.
MessagePacket
MessagePacket[symbol,string] is a WSTP packet containing a Wolfram Language message identifier of the form symbol::string.
Messages
Messages[symbol] gives all the messages assigned to a particular symbol.
MetaCharacters
MetaCharacters is an option to StringPosition. With MetaCharacters -> None, no strings have special meanings. MetaCharacters -> {c1, c2, c3} specifies the metacharacters for pattern escape, single character matching and multiple character matching. MetaCharacters -> Automatic is equivalent to MetaCharacters -> {"\\", ".", "*"}.
MetaInformation
MetaInformation is an option giving metainformation for Image, CloudObject, and other objects.
MeteorShowerData
MeteorShowerData[entity,property] gives the value of the specified property for the meteor shower entity.
MeteorShowerData[{entity1,entity2,…},property] gives a list of property values for the specified meteor shower entities.
MeteorShowerData[name,property,annotation] gives the specified annotation associated with the given property.
Method
Method is an option for various algorithm-intensive functions that specifies what internal methods they should use.
MexicanHatWavelet
MexicanHatWavelet[] represents the Mexican hat wavelet of width 1.
MexicanHatWavelet[σ] represents the Mexican hat wavelet of width σ.
MeyerWavelet
MeyerWavelet[] represents the Meyer wavelet of order 3.
MeyerWavelet[n] represents the Meyer wavelet of order n evaluated on the equally spaced interval {-10,10}.
MeyerWavelet[n,lim] represents the Meyer wavelet of order n evaluated on the equally spaced interval {-lim,lim}.
Midpoint
Midpoint[{p1,p2}] gives the midpoint of the line segment connecting the points p1 and p2.
Midpoint[Line[{p1,p2}]] gives the midpoint of a line.
MIMETypeToFormatList
MIMETypeToFormatList[] returns lists of file formats corresponding to all registered MIME types.
MIMETypeToFormatList[mime] returns a list of file formats that matches the MIME type mime.
Min
Min[x1,x2,…] yields the numerically smallest of the xi.
Min[{x1,x2,…},{y1,…},…] yields the smallest element of any of the lists.
MinColorDistance
MinColorDistance is an option for DominantColors that specifies the minimum distance between returned colors.
MinDate
MinDate[{date1,date2,…}] gives the earliest date of the datei.
MinDate[interval] gives the beginning of the date interval interval.
MinDate[interval,gran] gives the beginning of interval as specified by granularity gran.
MinDetect
MinDetect[image] gives a binary image in which white pixels correspond to constant extended minima in image.
MinDetect[image,h] finds extended minima where the range of values is not greater than h.
MinDetect[data,…] applies minima detection to an array of data.
MineralData
MineralData[entity,property] gives the value of the specified property for the mineral entity.
MineralData[{entity1,entity2,…},property] gives a list of property values for the specified mineral entities.
MineralData[entity,property,annotation] gives the specified annotation associated with the given property.
MinimalBy
MinimalBy[data,f] returns a list of the elements ei of data for which the value of f is minimal.
MinimalBy[data,f,n] returns a list of the elements ei of data corresponding to the n smallest f[ei].
MinimalBy[data,f,n,p] uses the ordering function p for sorting.
MinimalBy[f] represents an operator form of MinimalBy that can be applied to an expression.
MinimalPolynomial
MinimalPolynomial[s,x] gives the minimal polynomial in x for which the algebraic number s is a root.
MinimalPolynomial[u,x] gives the minimal polynomial of the finite field element u over p.
MinimalPolynomial[u,x,k] gives the minimal polynomial of u over the pk-element subfield of the ambient field of u.
MinimalPolynomial[u,x,emb] gives the minimal polynomial of u relative to the finite field embedding emb.
MinimalStateSpaceModel
MinimalStateSpaceModel[sys] gives the minimal state-space model of the state-space model sys.
MinimalStateSpaceModel[sys,{z1,…}] specifies the new coordinates zi.
Minimize
Minimize[f,x] minimizes f symbolically with respect to x.
Minimize[f,{x,y,…}] minimizes f symbolically with respect to x, y, ….
Minimize[{f,cons},{x,y,…}] minimizes f symbolically subject to the constraints cons.
Minimize[…,x∈rdom] constrains x to be in the region or domain rdom.
Minimize[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
MinimumTimeIncrement
MinimumTimeIncrement[tseries] gives the minimum time increment in the time series tseries.
MinIntervalSize
MinIntervalSize is an option for IntervalSlider that specifies the minimum size of the interval during interactive editing.
MinkowskiQuestionMark
MinkowskiQuestionMark[x] gives Minkowski's question mark function ?(x).
MinLimit
MinLimit[f,x->x*] gives the min limit x->x*f(x).
MinLimit[f,{x1->x1*,…,xn->xn*}] gives the nested min limit +x1->x1*⋯ +xn->xn*f(x1,…,xn).
MinLimit[f,{x1,…,xn}->{x1*,…,xn*}] gives the multivariate min limit +{x1,…,xn}->{x1*,…,xn*}f(x1,…,xn).
MinMax
MinMax[list] gives the list {Min[list],Max[list]}.
MinMax[list,δ] gives {Min[list]-δ, Max[list]+δ}.
MinMax[list,Scaled[s]] gives {Min[list]-δ, Max[list]+δ} where δ=s×(Max[list]-Min[list]).
MinMax[list,{δmin,δmax}] gives {Min[list]-δmin,Max[list]+δmax}.
MinorPlanetData
MinorPlanetData[entity,property] gives the value of the specified property for the minor planet entity.
MinorPlanetData[{entity1,entity2,…},property] gives a list of property values for the specified minor planet entities.
MinorPlanetData[entity,property,annotation] gives the specified annotation associated with the given property.
Minors
Minors[m] gives the minors of a matrix m.
Minors[m,k] gives the kth minors.
Minors[m,k,f] applies the function f rather than Det to each of the submatrices picked out.
MinPointSeparation
MinPointSeparation is an option for GeoGraphValuePlot that determines when to merge nearby vertices into a single vertex.
MinRecursion
MinRecursion is an option for NIntegrate and other numerical functions that use a recursive algorithm. With MinRecursion -> n, a minimum depth of recursion of n is used before tests for convergence begin.
MinStableDistribution
MinStableDistribution[μ,σ,ξ] represents a generalized minimum extreme value distribution with location parameter μ, scale parameter σ, and shape parameter ξ.
Minus
-x is the arithmetic negation of x.
MinusPlus
MinusPlus[x] displays as ∓x.
MinusPlus[x,y,…] displays as x∓y∓….
MinValue
MinValue[f,x] gives the minimum value of f with respect to x.
MinValue[f,{x,y,…}] gives the exact minimum value of f with respect to x, y, ….
MinValue[{f,cons},{x,y,…}] gives the minimum value of f subject to the constraints cons.
MinValue[…,x∈rdom] constrains x to be in the region or domain rdom.
MinValue[…,…,dom] constrains variables to the domain dom, typically Reals or Integers.
Missing
Missing[] represents data that is missing.
Missing["reason"] specifies a reason for the data's being missing.
Missing["reason",expr] associates the expression expr with the missing data.
MissingBehavior
MissingBehavior is an option to Query and related functions that specifies how expressions with head Missing should be interpreted in the context of other functions.
MissingDataMethod
MissingDataMethod is an option to TemporalData and other functions that controls how to process missing data.
MissingDataRules
MissingDataRules is an option for SemanticImport and related functions that specifies what should be considered "missing" and what to replace it with.
MissingQ
MissingQ[expr] gives True if expr has head Missing.
MissingString
MissingString is an option for TextString and related functions that indicates how an expression with head Missing should be converted to a string.
MissingStyle
MissingStyle is an option for GeoRegionValuePlot that specifies how locations with missing data should be displayed.
MissingValuePattern
MissingValuePattern is an option for SynthesizeMissingValues and ToTabular to specify which data elements are considered missing.
MissingValueSynthesis
MissingValueSynthesis is an option for functions such as Classify that specifies how missing values should be replaced.
MittagLefflerE
MittagLefflerE[α,z] gives the Mittag–Leffler function Eα(z).
MittagLefflerE[α,β,z] gives the generalized Mittag–Leffler function Eα,β(z).
MixedFractionParts
MixedFractionParts[expr] gives the list {IntegerPart[expr],FractionalPart[expr]}.
MixedGraphQ
MixedGraphQ[g] yields True if the graph g is a mixed graph and False otherwise.
MixedMagnitude
MixedMagnitude[{val1,val2,…,valn}] represents a mixed-magnitude expression consisting of values val1 through valn.
MixedRadix
MixedRadix[{b1,…,bn}] represents the list of bases of a numerical system in which different digits have different bases.
MixedRadixQuantity
MixedRadixQuantity[{value1,…,valuen},{unit1,…,unitn}] yields a single Quantity expression representing the addition of compatible units with magnitude values.
MixedUnit
MixedUnit[{unit1,unit2,…,unitn}] represents a mixed-unit expression consisting of units unit1 through unitn.
MixtureDistribution
MixtureDistribution[{w1,…,wn},{dist1,…,distn}] represents a mixture distribution whose CDF is given as a sum of the CDFs of the component distributions disti, each with weight wi.
Mod
Mod[m,n] gives the remainder on division of m by n.
Mod[m,n,d] uses an offset d.
Modal
Modal is an option to functions such as CreateDialog that specifies whether the dialog that is created should be modal to the Wolfram System front end.
Mode
Mode is an option to Eliminate and related functions that specifies in what sense the equations are to be solved. The possible settings for Mode are Generic, Modular, and Rational.
Modular
Modular is a setting for the option Mode in Solve and related functions, which specifies that equations need be satisfied only modulo an integer.
ModularInverse
ModularInverse[k,n] gives the modular inverse of k modulo n.
ModularLambda
ModularLambda[τ] gives the modular lambda elliptic function λ(τ).
Module
Module[{x,y,…},expr] specifies that occurrences of the symbols x, y, … in expr should be treated as local.
Module[{x=x0,…},expr] defines initial values for x, ….
Modulus
Modulus->n is an option that can be given in certain algebraic functions to specify that integers should be treated modulo n.
MoebiusMu
MoebiusMu[n] gives the Möbius function μ(n).
MoleculeDraw
MoleculeDraw[] displays a window with interactive tools for drawing a Molecule, and returns the result.
MoleculeDraw[mol] displays a window that initially contains the Molecule mol.
MoleculeMatchQ
MoleculeMatchQ[mol,patt] returns True if the Molecule matches the given pattern.
MoleculeMatchQ[patt] represents an operator form of MoleculeMatchQ that can be applied to a molecule.
MoleculeProperty
MoleculeProperty[pname] represents a property identified by pname for use in MoleculeValue.
MoleculeProperty[{pname,item}] represents a property that applies to item within a molecule.
MoleculeQ
MoleculeQ[mol] returns True if mol is a valid Molecule expression, and False otherwise.
MoleculeSubstructureCount
MoleculeSubstructureCount[mol,patt] gives a count of the number of times patt appears as a substructure in mol.
MoleculeSubstructureCount[patt] represents an operator form of MoleculeSubstructureCount that can be applied to a molecule.
Moment
Moment[data,r] gives the order r moment μ r of data.
Moment[data,{r1,…,rm}] gives the order {r1,…,rm} multivariate moment μ r1, …, rm of data.
Moment[dist,…] gives the moment of the distribution dist.
Moment[r] represents the order r formal moment.
MomentConvert
MomentConvert[mexpr,form] converts the moment expression mexpr to the specified form.
MomentEvaluate
MomentEvaluate[mexpr,dist] evaluates formal moments in the moment expression mexpr on the distribution dist.
MomentEvaluate[mexpr,list] evaluates formal moments and formal sample moments in mexpr on the data list.
MomentEvaluate[mexpr,dist,list] evaluates formal moments on the distribution dist and formal sample moments on the data list.
MomentGeneratingFunction
MomentGeneratingFunction[dist,t] gives the moment-generating function for the distribution dist as a function of the variable t.
MomentGeneratingFunction[dist,{t1,t2,…}] gives the moment-generating function for the multivariate distribution dist as a function of the variables t1, t2, … .
MomentOfInertia
MomentOfInertia[reg,pt,v] computes the moment of inertia for the region reg rotating around an axis through the point pt in direction v.
MomentOfInertia[reg] computes the moment of inertia matrix for the region reg relative to the center of mass.
MomentOfInertia[reg,pt] computes the moment of inertia matrix relative to the point pt.
Monday
Monday is a day of the week.
MonomialList
MonomialList[poly] gives the list of all monomials in the polynomial poly.
MonomialList[poly,{x1,x2,…}] gives the list of monomials with respect to the variables xi in poly.
MonomialList[poly,{x1,x2,…},order] puts the monomials in the specified order.
MonsterGroupM
MonsterGroupM[] represents the sporadic simple monster group M.
MoonPhase
MoonPhase[] gives moon phase fraction of illumination for the current date.
MoonPhase[datespec] gives moon phase fraction of illumination for the specified date.
MoonPhase[property] gives the property of the moon phase for the current date.
MoonPhase[datespec,property] gives the property of the moon phase for the specified date.
MoonPosition
MoonPosition[] gives the position of the Moon for the current date and location.
MoonPosition[datespec] gives the position of the Moon for the specified date.
MoonPosition[locationspec] gives the position of the Moon for the specified location.
MoonPosition[locationspec,datespec] gives the position of the Moon for the specified date and location.
MoonPosition[{{location1,date1},{location2,date2},…}] gives the positions of the Moon for all specified locations on the specified dates.
MoonPosition[locationspec,datespec,func] uses func to determine what to return for extended locations.
MorletWavelet
MorletWavelet[] represents a Morlet wavelet.
MorphologicalBinarize
MorphologicalBinarize[image,{t1,t2}] creates a binary image from image by replacing all values above the upper threshold t2 with 1, also including pixels with intensities above the lower threshold t1 that are connected to the foreground.
MorphologicalBinarize[image,t] uses t as the upper threshold, automatically choosing a suitable value for the lower threshold.
MorphologicalBinarize[image] chooses the lower and the upper threshold automatically.
MorphologicalBranchPoints
MorphologicalBranchPoints[image] gives a version of a binary image image in which white pixels represent the morphological branch points.
MorphologicalComponents
MorphologicalComponents[image] gives an array in which each pixel of image is replaced by an integer index representing the connected foreground image component in which the pixel lies.
MorphologicalComponents[image,t] treats values above t as foreground.
MorphologicalComponents[video,…] computes connected components in frames of video.
MorphologicalEulerNumber
MorphologicalEulerNumber[image] computes the morphological Euler number of regions in a binary image.
MorphologicalEulerNumber[image,t] treats values above t as foreground.
MorphologicalGraph
MorphologicalGraph[image] gives a graph object that represents the connectivity of the morphological branch points and endpoints of the objects in image after applying morphological thinning.
MorphologicalPerimeter
MorphologicalPerimeter[image] picks out the morphological perimeter of regions of foreground in image.
MorphologicalPerimeter[image,t] treats values above t as foreground.
MorphologicalTransform
MorphologicalTransform[image,f] applies the function f to the 3×3 neighborhood of each pixel in a binary image image.
MorphologicalTransform[image,rule] applies a morphological transformation specified by a rule number rule.
MorphologicalTransform[image,"name"] uses a named transformation "name".
MorphologicalTransform[image,transformation,n] applies n iterations of transformation on image.
MortalityData
MortalityData[spec] gives the values of all properties for the specified demographic.
MortalityData[spec,property] gives the value of the specified property for the specified demographic.
Most
Most[expr] gives expr with the last element removed.
MountainData
MountainData[entity,property] gives the value of the specified property for the mountain entity.
MountainData[{entity1,entity2,…},property] gives a list of property values for the specified mountain entities.
MountainData[entity,property,annotation] gives the specified annotation associated with the given property.
MovieData
MovieData[entity,property] gives the value of the specified property for the movie entity.
MovieData[{entity1,entity2,…},property] gives a list of property values for the specified movie entities.
MovieData[entity,property,annotation] gives the specified annotation associated with the given property.
MovingAverage
MovingAverage[list,r] gives the moving average of list, computed by averaging runs of r elements.
MovingAverage[list,{w1,w2,…,wr}] gives the moving average of list, computed with weights wi.
MovingMap
MovingMap[f,data,w] applies f to size w windows in the specified data.
MovingMap[f,data,wspec] uses windows specified by wspec.
MovingMap[f,data,wspec,padding] pads data using padding.
MovingMedian
MovingMedian[list,r] gives the moving median of list, computed using spans of r elements.
MoyalDistribution
MoyalDistribution[μ,σ] represents a Moyal distribution with location parameter μ and scale parameter σ.
MoyalDistribution[] represents a Moyal distribution with location parameter 0 and scale parameter 1.
MultiaxisArrangement
MultiaxisArrangement is an option to plotting functions that specifies how multiple axes are arranged.
Multicolumn
Multicolumn[list,cols] is an object that formats with the elements of list arranged in a grid with the indicated number of columns.
Multicolumn[list,{rows,Automatic}] formats as a grid with the indicated number of rows.
Multicolumn[list,{rows,cols}] formats as a grid with the indicated number of rows and columns.
Multicolumn[list] formats with the elements of list in a roughly square arrangement.
MultiedgeStyle
MultiedgeStyle is an option for GraphPlot and related functions that specifies how to draw multiple edges.
MultigraphQ
MultigraphQ[g] yields True if the graph g is a multigraph and False otherwise.
MultilaunchWarning
MultilaunchWarning is a global option that specifies whether a warning is given when you try to modify user preferences while running two copies of the Wolfram System simultaneously.
Multinomial
Multinomial[n1,n2,…] gives the multinomial coefficient (n1+n2+…)!/(n1! n2! …).
MultinomialDistribution
MultinomialDistribution[n,{p1,p2,…,pm}] represents a multinomial distribution with n trials and probabilities pi.
MultinormalDistribution
MultinormalDistribution[Σ] represents a multivariate normal distribution with zero mean and covariance matrix Σ.
MultinormalDistribution[μ,Σ] represents a multivariate normal (Gaussian) distribution with mean vector μ and covariance matrix Σ.
Multiplicity
Multiplicity is an option to Roots. Multiplicity -> n specifies that the multiplicity of each of the roots is n in the final result.
MultiplySides
MultiplySides[rel,x] multiplies each side of the equation or inequality rel by x.
MultiplySides[rel1,rel2] multiplies the corresponding sides of two equations or inequalities.
Multiselection
Multiselection is an option to ListPicker that specifies whether multiple values may be selected.
MultivariateHypergeometricDistribution
MultivariateHypergeometricDistribution[n,{m1,m2,…,mk}] represents a multivariate hypergeometric distribution with n draws without replacement from a collection containing mi objects of type i.
MultivariatePoissonDistribution
MultivariatePoissonDistribution[μ0,{μ1,μ2,…}] represents a multivariate Poisson distribution with mean vector {μ0+μ1,μ0+μ2,…}.
MultivariateTDistribution
MultivariateTDistribution[Σ,ν] represents the multivariate Student t distribution with scale matrix Σ and degrees of freedom parameter ν.
MultivariateTDistribution[μ,Σ,ν] represents the multivariate Student t distribution with location μ, scale matrix Σ, and ν degrees of freedom.
N
N[expr] gives the numerical value of expr.
N[expr,n] attempts to give a result with n‐digit precision.
NakagamiDistribution
NakagamiDistribution[μ,ω] represents a Nakagami distribution with shape parameter μ and spread parameter ω.
NameQ
NameQ["string"] yields True if there are any symbols whose names match the string pattern given, and yields False otherwise.
Names
Names["string"] gives a list of the names of symbols that match the string.
Names[patt] gives a list of names matching the arbitrary string pattern patt.
Names[{patt1,patt2,…}] gives a list of names matching any of the patti.
Nand
Nand[e1,e2,…] is the logical NAND function. It evaluates its arguments in order, giving True immediately if any of them are False, and False if they are all True.
NArgMax
NArgMax[f,x] gives a position xmax at which f is numerically globally maximized.
NArgMax[f,{x,y,…}] gives a position {xmax,ymax,…} at which f is numerically globally maximized.
NArgMax[{f,cons},{x,y,…}] gives a position at which f is numerically globally maximized subject to the constraints cons.
NArgMax[…,x∈reg] constrains x to be in the region reg.
NArgMin
NArgMin[f,x] gives a position xmin at which f is numerically globally minimized.
NArgMin[f,{x,y,…}] gives a position {xmin,ymin,…} at which f is numerically globally minimized.
NArgMin[{f,cons},{x,y,…}] gives a position at which f is numerically globally minimized subject to the constraints cons.
NArgMin[…,x∈reg] constrains x to be in the region reg.
NBernoulliB
NBernoulliB[n] gives the numerical value of the nth Bernoulli number.
NBernoulliB[n, d] gives the result to d-digit precision.
NBodySimulation
NBodySimulation[law,{state1,…,staten},t] generates a simulation of the motion of a system of n bodies with initial states statei, governed by the specified potential or force law, over a length of time t.
NBodySimulation[law,<|body1->state1,…,bodyn->staten|>,t] generates a simulation of the motion of a system of n bodies with names bodyi.
NBodySimulationData
NBodySimulationData[�] represents the result of an n-body simulation.
NCache
NCache[x,xn] represents a numeric cache object for a quantity with exact value x and approximate numerical value xn.
NDEigensystem
NDEigensystem[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues and eigenfunctions for the linear differential operator ℒ over the region Ω.
NDEigensystem[{ℒ1[u[x,y,…],v[x,y,…],…],ℒ2[u[x,y,…],v[x,y,…],…],…},{u,v,…},{x,y,…}∈Ω,n] gives eigenvalues and eigenfunctions for the coupled differential operators {op1,op2,…} over the region Ω.
NDEigensystem[eqns,{u,…},t,{x,y,…}∈Ω,n] gives the eigenvalues and eigenfunctions in the spatial variables {x,y,…} for solutions u,… of the coupled time-dependent differential equations eqns.
NDEigenvalues
NDEigenvalues[ℒ[u[x,y,…]],u,{x,y,…}∈Ω,n] gives the n smallest magnitude eigenvalues for the linear differential operator ℒ over the region Ω.
NDEigenvalues[{ℒ1[u[x,y,…],v[x,y,…],…],ℒ2[u[x,y,…],v[x,y,…],…],…},{u,v,…},{x,y,…}∈Ω,n] gives eigenvalues for the coupled differential operators {op1,op2,…} over the region Ω.
NDEigenvalues[eqns,{u,…},t,{x,y,…}∈Ω,n] gives the eigenvalues in the spatial variables {x,y,…} for solutions u,… of the coupled time-dependent differential equations eqns.
NDSolve
NDSolve[eqns,u,{x,xmin,xmax}] finds a numerical solution to the ordinary differential equations eqns for the function u with the independent variable x in the range xmin to xmax.
NDSolve[eqns,u,{x,xmin,xmax},{y,ymin,ymax}] solves the partial differential equations eqns over a rectangular region.
NDSolve[eqns,u,{x,y}∈Ω] solves the partial differential equations eqns over the region Ω.
NDSolve[eqns,u,{t,tmin,tmax},{x,y}∈Ω] solves the time-dependent partial differential equations eqns over the region Ω.
NDSolve[eqns,{u1,u2,…},…] solves for the functions ui.
NDSolveValue
NDSolveValue[eqns,expr,{x,xmin,xmax}] gives the value of expr with functions determined by a numerical solution to the ordinary differential equations eqns with the independent variable x in the range xmin to xmax.
NDSolveValue[eqns,expr,{x,xmin,xmax},{y,ymin,ymax}] solves the partial differential equations eqns over a rectangular region.
NDSolveValue[eqns,expr,{x,y}∈Ω] solves the partial differential equations eqns over the region Ω.
NDSolveValue[eqns,u,{t,tmin,tmax},{x,y}∈Ω] solves the time-dependent partial differential equations eqns over the region Ω.
Nearest
Nearest[{elem1,elem2,…},x] gives the list of elemi to which x is nearest.
Nearest[{elem1->v1,elem2->v2,…},x] gives the vi corresponding to the elemi to which x is nearest.
Nearest[{elem1,elem2,…}->{v1,v2,…},x] gives the same result.
Nearest[{elem1,elem2,…}->prop,x] gives the property prop for the elemi to which x is nearest.
Nearest[data,{x1,x2,…}] effectively gives {Nearest[data,x1],Nearest[data,x2],…}.
Nearest[data,x,n] gives the n nearest elemi to x.
Nearest[data,x,{n,r}] gives the n or fewer nearest elemi to x that are within radius r of x.
Nearest[data] generates a NearestFunction[…] that can be applied repeatedly to different x.
NearestFunction
NearestFunction[data] represents a function whose values give the elements closest to an element that is supplied.
NearestNeighborG
NearestNeighborG[pdata,r] estimates the nearest neighbor function G(r) at radius r in the point data pdata.
NearestNeighborG[pproc,r] computes G(r) for the point process pproc.
NearestNeighborG[bdata,r] computes G(r) for binned data bdata.
NearestNeighborG[pspec] generates the function G that can be applied repeatedly to different radii r.
NearestNeighborGraph
NearestNeighborGraph[{elem1,elem2,…}] gives a graph with vertices elem1,elem2,… and edges connecting each elemi to its nearest neighbors.
NearestNeighborGraph[{elem1,elem2,…},k] gives a graph connecting each elemi to its k nearest neighbors.
NearestNeighborGraph[{elem1,elem2,…},{k,r}] gives a graph connecting each elemi to at most k nearest vertices within radius r of elemi.
NearestNeighborGraph[{elem1,elem2,…},{All,r}] gives a graph connecting each elemi to all vertices within radius r of elemi.
NearestTo
NearestTo[x] is an operator form that yields Nearest[elems,x] when applied to a list elems.
NearestTo[x,n] is an operator form that yields Nearest[elems,x,n] when applied to a list elems.
NearestTo[x,{n,r}] is an operator form that yields Nearest[elems,x,{n,r}] when applied to a list elems.
NebulaData
NebulaData[entity,property] gives the value of the specified property for the nebula entity.
NebulaData[{entity1,entity2,…},property] gives a list of property values for the specified nebula entities.
NebulaData[entity,property,annotation] gives the specified annotation associated with the given property.
NeedlemanWunschSimilarity
NeedlemanWunschSimilarity[u,v] gives a number representing the Needleman–Wunsch similarity between strings or vectors u and v.
NeedlemanWunschSimilarity[u,v] gives a number representing the Needleman–Wunsch similarity between strings, vectors or biomolecular sequences u and v.
Needs
Needs["context`"] loads an appropriate file if the specified context is not already in $Packages.
Needs["context`"->"alias`"] loads the given context and establishes alias as a context alias for that context.
Needs["context`","file"] loads file if the specified context is not already in $Packages.
Negative
Negative[x] gives True if x is a negative number.
NegativeBinomialDistribution
NegativeBinomialDistribution[n,p] represents a negative binomial distribution with parameters n and p.
NegativeDefiniteMatrixQ
NegativeDefiniteMatrixQ[m] gives True if m is explicitly negative definite, and False otherwise.
NegativeIntegers
NegativeIntegers represents the domain of strictly negative integers, as in x∈NegativeIntegers.
NegativelyOrientedPoints
NegativelyOrientedPoints[{p1,p2,p3,…,pn}] tests whether the sequence of points p1,p2,p3,…,pn is negatively oriented.
NegativeMultinomialDistribution
NegativeMultinomialDistribution[n,p] represents a negative multinomial distribution with parameter n and failure probability vector p.
NegativeRationals
NegativeRationals represents the domain of strictly negative rational numbers, as in x∈NegativeRationals.
NegativeReals
NegativeReals represents the domain of strictly negative real numbers.
NegativeSemidefiniteMatrixQ
NegativeSemidefiniteMatrixQ[m] gives True if m is explicitly negative semidefinite, and False otherwise.
NeighborhoodData
NeighborhoodData[entity,property] gives the value of the specified property for the neighborhood entity.
NeighborhoodData[{entity1,entity2,…},property] gives a list of property values for the specified neighborhood entities.
NeighborhoodData[entity,property,annotation] gives the specified annotation associated with the given property.
NeighborhoodGraph
NeighborhoodGraph[g,v] gives the graph neighborhood of a vertex v in the graph g.
NeighborhoodGraph[g,{a1,a2,…}] gives the graph neighborhood of the ai that can be vertices, edges, or subgraphs of g.
NeighborhoodGraph[g,patt] gives the graph neighborhood of the vertices and edges that match the pattern patt.
NeighborhoodGraph[g,…,d] gives the neighborhood up to distance d.
NeighborhoodGraph[{v->w,…},…] uses rules v->w to specify the graph g.
Nest
Nest[f,expr,n] gives an expression with f applied n times to expr.
Nest[f,n] represents an operator form of Nest that can be applied to expressions.
NestedGreaterGreater
NestedGreaterGreater[x,y,…] displays as x⪢y⪢….
NestedLessLess
NestedLessLess[x,y,…] displays as x⪡y⪡….
NestGraph
NestGraph[f,expr,n] gives the graph obtained by starting with expr and applying f successively n times.
NestGraph[f,{expr1,expr2,…},n] gives the graph obtained by applying f to expr1, expr2, ….
NestGraph[f,graph,n] gives the graph obtained by applying f to the vertices of graph and extending the graph.
NestList
NestList[f,expr,n] gives a list of the results of applying f to expr 0 through n times.
NestList[f,n] represents an operator form of NestList that can be applied to expressions.
NestTree
NestTree[f,tree] adds children to each leaf of tree, with f[expr] giving the list of data for the new children of a leaf with data expr.
NestTree[f,tree,n] successively applies f to the data of each leaf up to level n, adding at most n levels to each leaf.
NestTree[f,tree,n,h] additionally applies h to the data of the new subtrees.
NestTree[f,expr,…] constructs a tree by nesting f on the tree leaf with data expr.
NestWhile
NestWhile[f,expr,test] starts with expr, then repeatedly applies f until applying test to the result no longer yields True.
NestWhile[f,expr,test,m] supplies the most recent m results as arguments for test at each step.
NestWhile[f,expr,test,All] supplies all results so far as arguments for test at each step.
NestWhile[f,expr,test,m,max] applies f at most max times.
NestWhile[f,expr,test,m,max,n] applies f an extra n times.
NestWhile[f,expr,test,m,max,-n] returns the result found when f had been applied n fewer times.
NestWhileList
NestWhileList[f,expr,test] generates a list of the results of applying f repeatedly, starting with expr, and continuing until applying test to the result no longer yields True.
NestWhileList[f,expr,test,m] supplies the most recent m results as arguments for test at each step.
NestWhileList[f,expr,test,All] supplies all results so far as arguments for test at each step.
NestWhileList[f,expr,test,m,max] applies f at most max times.
NetAppend
NetAppend[net,layer] appends a layer or a net onto a NetChain, a layer or a NetGraph with one output port.
NetAppend[net,"name"->layer] appends a layer with a given name.
NetAppend[net,{layer1,layer2,…}] appends several layers or nets.
NetArray
NetArray[] represents an array in a net.
NetArray["name"] uses "name" as an identifier to share the array in more than one layer.
NetArray[prop->value] specifies the property prop for the array.
NetArray[<|"Name"->name,"Array"->array,…|>] specifies several properties for the array.
NetArrayLayer
NetArrayLayer[] represents a layer that has no input and produces as output a constant array.
NetArrayLayer[opts] includes options for the initial value of the array or output size.
NetBidirectionalOperator
NetBidirectionalOperator[net] represents a net that applies net to a sequence and to its reverse, concatenating both results into one output sequence.
NetBidirectionalOperator[{fnet,bnet}] uses fnet on the normal input and bnet on the reversed input.
NetBidirectionalOperator[nets,agg] aggregates the two output sequences using the specified aggregation function.
NetChain
NetChain[{layer1,layer2,…}] specifies a neural net in which the output of layeri is connected to the input of layeri+1.
NetChain[<|name1->layer1,name2->layer2,…|>] specifies a net consisting of a chain of explicitly named layers.
NetDecoder
NetDecoder["name"] represents a decoder that takes a net representation and decodes it into an expression of a given form.
NetDecoder[{"name",…}] represents a decoder with additional parameters specified.
NetDelete
NetDelete[net,n] deletes the nth layer from a NetChain or NetGraph.
NetDelete[net,"name"] deletes a named layer.
NetDelete[net,{spec1,spec2,…}] deletes several layers simultaneously.
NetDelete[graph,NetPort["name"]] deletes an output or state-input port from a NetGraph.
NetDelete[graph,{NetPort[name1],NetPort[name2],…}] deletes several output or state-input ports simultaneously.
NetDrop
NetDrop[chain,n] removes the first n layers from a NetChain.
NetDrop[chain,-n] removes the last n layers from a NetChain.
NetDrop[chain,{start,end}] drops the layers between start and end in a NetChain.
NetEncoder
NetEncoder["name"] represents an encoder that takes a given form of input and encodes it as an array for use in a net.
NetEncoder[{"name",…}] represents an encoder with additional parameters specified.
NetEvaluationMode
NetEvaluationMode is an option that can be given when applying neural net functions to input data, specifying whether the net should use training-specific behavior.
NetExtract
NetExtract[layer,"param"] extracts the value of a parameter for the specified net layer.
NetExtract[net,lspec] extracts the layer identified by lspec from within the NetGraph or NetChain object net.
NetExtract[net,{lspec,"param"}] extracts the value of the parameter param from the layer identified by lspec in net.
NetExtract[net,NetArray[spec]] extracts the value of a shared array within a network or layer.
NetExtract[coder,"param"] extracts the value of a parameter for the specified NetEncoder or NetDecoder.
NetExtract[…,{spec1,spec2,…}] extracts a set of elements, where each speci is a list.
NetFlatten
NetFlatten[net] collapses nested NetChain and NetGraph objects within net.
NetFlatten[net,n] collapses up to nesting level n.
NetFoldOperator
NetFoldOperator[net] represents a net in which net is folded over a sequence of inputs, maintaining a recurrent state.
NetFoldOperator[net,{outi->in1,…}] represents a net in which net is folded over its inputs, maintaining a recurrent state by feeding the outi of each step back to the ini of the next step.
NetFoldOperator[net,feedback,{const1,const2,…}] treats the inputs consti to net as being constant instead of mapped over.
NetFoldOperator[net,feedback,constants,{out1,…}] returns the sequence of values for the specific outputs outi.
NetGANOperator
NetGANOperator[{generator,discriminator}] represents a network to perform generative adversarial network (GAN) training with a generative net generator and a classification net discriminator.
NetGANOperator[{generator,discriminator},loss] specifies the loss type to be used.
NetGraph
NetGraph[{layer1,layer2,…},{m1->n1,m2->n2,…}] specifies a neural net defined by a graph in which the output of layer mi is given as input to layer ni.
NetGraph[<|name1->layer1,name2->layer2,…|>,{namem1->namen1,…}] specifies a net with explicitly named layers.
NetGraph[layer] converts a layer or a NetChain into an equivalent minimal NetGraph.
NetInformation
NetInformation[net] gives a report about the neural network net.
NetInformation[net,"prop"] gives the value of property property "prop" of net.
NetInformation[{net1,net2,…},"prop"] gives a list containing the result for each neti.
NetInitialize
NetInitialize[net] gives a net in which all uninitialized learnable parameters in net have been given initial values.
NetInitialize[net,All] gives a net in which all learnable parameters have been given initial values.
NetInsert
NetInsert[chain,layer,i] inserts a layer into a NetChain before the layer at position i.
NetInsert[chain,"name"->layer,"pos"] inserts a named layer into a NetChain before the layer at the given position.
NetInsertSharedArrays
NetInsertSharedArrays[net] converts all ordinary arrays in net into NetSharedArray objects.
NetInsertSharedArrays[net,"prefix"] uses a prefix for the names of all newly shared arrays.
NetJoin
NetJoin[net1,net2,…] connects a series of NetChain or NetGraph objects to form a single NetChain or NetGraph.
NetMapOperator
NetMapOperator[net] represents a net in which net is mapped over a sequence of inputs to give a sequence of outputs.
NetMapThreadOperator
NetMapThreadOperator[mapnet] represents a net in which mapnet is mapped over one or more inputs to give one or more outputs.
NetMapThreadOperator[mapnet,n] represents a net in which mapnet is mapped over its inputs at depth n.
NetMapThreadOperator[mapnet,<|input1->n1,input2->n2,…|>] represents a net in which mapnet is mapped over the input named inputi at depth ni, and all other inputs are replicated.
NetMeasurements
NetMeasurements[net,data,measurement] computes the requested measurement for the net evaluated on data.
NetMeasurements[net,data,{mspec1,mspec2,…}] computes a list of measurements for the net evaluated on data.
NetModel
NetModel["name"] obtains a neural net model with the specified name from the Neural Net Repository.
NetModel[{"name",param1->setting1,…}] obtains a specified model from a parameterized family of models.
NetModel[model,"prop"] gives property prop of the model.
NetModel[] gives a dataset of available pre-trained neural net models.
NetNestOperator
NetNestOperator[net,n] represents a net in which net is applied n times to the input.
NetPairEmbeddingOperator
NetPairEmbeddingOperator[net] represents a net that takes a pair of arrays, embeds them into a vector space using net, and outputs the distance under the embedding.
NetPairEmbeddingOperator[net,opts] includes options for distance function to use and other parameters.
NetPort
NetPort["port"] represents the specified input or output port for a complete net.
NetPort[{n,"port"}] represents the specified port for layer number n in a NetGraph or similar construct.
NetPort[{"name","port"}] represents the specified port for the layer with the specified name.
NetPort[spec,port] is treated as equivalent to NetPort[{spec,port}].
NetPort[{spec1,spec2,…,"port"}] permits access to the port of nested layers in a NetGraph or a NetChain.
NetPort[All,"States"] represents the set of all states in a net associated with recurrent layers such as LongShortTermMemoryLayer.
NetPortGradient
NetPortGradient["port"] represents the gradient of the output of a net with respect to the value of the specified input port.
NetPortGradient["param"] represents the gradient of the output with respect to a learned parameter named param.
NetPortGradient[{layer1,layer2,…,"param"}] represents the gradient with respect to a parameter at a specific position in a net.
NetPortGradient[All] represents the gradients with respect to all inputs and parameters.
NetPrepend
NetPrepend[net,layer] prepends a layer or a net onto a NetChain, a layer or a NetGraph with one input port.
NetPrepend[net,"name"->layer] appends a layer with a given name.
NetPrepend[net,{layer1,layer2,…}] prepends several layers or nets.
NetRename
NetRename[net,"old"->"new"] gives a net in which the name old for a layer is replaced with new.
NetRename[net,NetPort["old"]->NetPort["new"]] gives a net in which the name old for an input or output port is replaced with new.
NetRename[net,{rule1,rule2,…}] performs all renamings specified by the rulei.
NetRename[net,f] uses a function f to map existing layer names to new names.
NetRename[net,rules,levelspec] renames layers and ports nested at level levelspec.
NetReplace
NetReplace[net,patt->layer] gives a net in which all layers matching patt are replaced with layer.
NetReplace[net,{rule1,rule2,…}] performs all replacements specified by the rulei.
NetReplacePart
NetReplacePart[layer,"array"->value] replaces an array within a layer, returning a new layer.
NetReplacePart[net,"port"->type] returns a new layer or network in which an input or output port has the specified type.
NetReplacePart[net,"input"->encoder] attaches a NetEncoder[…] to a specified input port.
NetReplacePart[net,"output"->decoder] attaches a NetDecoder[…] to a specified output port.
NetReplacePart[net,lspec->layer] returns a new NetChain or NetGraph in which the layer identified by lspec has been replaced.
NetReplacePart[net,NetArray[name]->value] sets a shared array within a network or layer to a specified value.
NetReplacePart[coder,"param"->value] returns a new NetEncoder[…] or NetDecoder[…] in which a parameter has been replaced.
NetReplacePart[net,{lspec,pspec}->value] makes a replacement of a part pspec of a layer or coder lspec within a NetGraph or NetChain.
NetReplacePart[…,{spec1->val1,spec2->val2,…}] makes multiple simultaneous replacements.
NetSharedArray
NetSharedArray["name"] represents an array in a net that is shared by more than one layer.
NetStateObject
NetStateObject[net] creates an object derived from net that represents a neural net with additional stored state information that is updated when the net is applied to data.
NetStateObject[net,seed] creates an object in which additional stored state information is initialized using seed.
NetTake
NetTake[net,end] takes only those layers up to end in a NetChain or NetGraph.
NetTake[net,{start,end}] takes only those layers between start and end in a NetChain or NetGraph.
NetTrain
NetTrain[net,{input1->output1,input2->output2,…}] trains the specified neural net by giving the inputi as input and minimizing the discrepancy between the outputi and the actual output of the net, using an automatically chosen loss function.
NetTrain[net,<|port1->{data11,data12,…},port2->{…},…|>] trains the specified net by supplying training data at the specified ports.
NetTrain[net,"dataset"] trains on a named dataset from the Wolfram Data Repository.
NetTrain[net,f] calls the function f during training to produce batches of training data.
NetTrain[net,data,"prop"] gives data associated with a specific property prop of the training session.
NetTrain[net,data,All] gives a NetTrainResultsObject[…] that summarizes information about the training session.
NetTrainResultsObject
NetTrainResultsObject[…] represents an object generated by NetTrain that contains the trained net and other information about the training process.
NetUnfold
NetUnfold[fnet] produces the elementary net of the folded net fnet, exposing the recurrent states.
NetworkPacketCapture
NetworkPacketCapture[] creates a temporary interactive interface for capturing information on network packets transmitted or received through all network interfaces on your computer.
NetworkPacketCapture[service] captures only packets associated with the specified network service.
NetworkPacketCapture[port] captures only packets associated with the specified port.
NetworkPacketCapture[spec] captures only packets matching the specification spec.
NetworkPacketRecording
NetworkPacketRecording[t] records information on network packets transmitted or received through all network interfaces on your computer for t seconds.
NetworkPacketRecording[t,service] records only packets associated with the specified network service.
NetworkPacketRecording[t,port] records only packets associated with the specified port.
NetworkPacketRecording[t,{port1,port2,…}] records only packets associated with any of the ports porti.
NetworkPacketRecording[t,spec] records only packets matching the specification spec.
NetworkPacketTrace
NetworkPacketTrace[expr] evaluates expr and returns information on network packets transmitted or received through all network interfaces on your computer during the time of the evaluation, together with the result of the evaluation.
NetworkPacketTrace[expr,service] records only packets associated with the specified network service.
NetworkPacketTrace[expr,port] records only packets associated with the specified port.
NetworkPacketTrace[expr,{port1,port2,…}] records only packets associated with any of the ports porti.
NetworkPacketTrace[expr,spec] records only packets matching the specification spec.
NeumannValue
NeumannValue[val,pred] represents a Neumann boundary value val, specified on the part of the boundary of the region given to NDSolve and related functions where pred is True.
NevilleThetaC
NevilleThetaC[z,m] gives the Neville theta function ϑc (zm).
NevilleThetaD
NevilleThetaD[z,m] gives the Neville theta function ϑd (zm).
NevilleThetaN
NevilleThetaN[z,m] gives the Neville theta function ϑn (zm).
NevilleThetaS
NevilleThetaS[z,m] gives the Neville theta function ϑs (zm).
NExpectation
NExpectation[expr,xdist] gives the numerical expectation of expr under the assumption that x follows the probability distribution dist.
NExpectation[expr,{x1,x2,…}dist] gives the numerical expectation of expr under the assumption that {x1,x2,…} follows the multivariate distribution dist.
NExpectation[expr,{x1dist1,x2dist2,…}] gives the numerical expectation of expr under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, ….
NExpectation[exprpred,…] gives the numerical conditional expectation of expr given pred.
NextDate
NextDate[gran] gives the next occurring date of the specified granularity type gran.
NextDate[daytype] gives the next day corresponding to the specified daytype.
NextDate[date,gran] gives the next date of the given granularity relative to the specified date.
NextPrime
NextPrime[x] gives the smallest prime above x.
NextPrime[x,k] gives the kth-next prime above x.
NextScheduledTaskTime
NextScheduledTaskTime[obj] gives the next execution time of the scheduled task represented by obj.
NHoldAll
NHoldAll is an attribute which specifies that none of the arguments to a function should be affected by N.
NHoldFirst
NHoldFirst is an attribute which specifies that the first argument to a function should not be affected by N.
NHoldRest
NHoldRest is an attribute which specifies that all but the first argument to a function should not be affected by N.
NicholsGridLines
NicholsGridLines is an option to NicholsPlot that specifies contours of constant magnitude and constant phase of the closed-loop system.
NicholsPlot
NicholsPlot[lsys] generates a Nichols plot of the transfer function for the system lsys.
NicholsPlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.
NicholsPlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.
NightHemisphere
NightHemisphere[] is a two-dimensional GeoGraphics primitive that represents the half of the Earth currently in darkness.
NightHemisphere[datespec] represents the night half of the Earth for the specified date.
NIntegrate
NIntegrate[f,{x,xmin,xmax}] gives a numerical approximation to the integral ∫xminxmax f dx.
NIntegrate[f,{x,xmin,xmax},{y,ymin,ymax},…] gives a numerical approximation to the multiple integral ∫xminxmaxdx∫yminymaxdy … f.
NIntegrate[f,{x,y,…}∈reg] integrates over the geometric region reg.
NMaximize
NMaximize[f,x] searches for a global maximum in f numerically with respect to x.
NMaximize[f,{x,y,…}] searches for a global maximum in f numerically with respect to x, y, ….
NMaximize[{f,cons},{x,y,…}] searches for a global maximum in f numerically subject to the constraints cons.
NMaximize[…,x∈rdom] constrains x to be in the region or domain rdom.
NMaxValue
NMaxValue[f,x] gives the global maximum value of f with respect to x.
NMaxValue[f,{x,y,…}] gives the global maximum value of f with respect to x, y, ….
NMaxValue[{f,cons},{x,y,…}] gives the global maximum value of f subject to the constraints cons.
NMaxValue[…,x∈reg] constrains x to be in the region reg.
NMinimize
NMinimize[f,x] searches for a global minimum in f numerically with respect to x.
NMinimize[f,{x,y,…}] searches for a global minimum in f numerically with respect to x, y, ….
NMinimize[{f,cons},{x,y,…}] searches for a global minimum in f numerically subject to the constraints cons.
NMinimize[…,x∈rdom] constrains x to be in the region or domain rdom.
NMinValue
NMinValue[f,x] gives the global minimum value of f with respect to x.
NMinValue[f,{x,y,…}] gives the global minimum value of f with respect to x, y, ….
NMinValue[{f,cons},{x,y,…}] gives the global minimum value of f subject to the constraints cons.
NMinValue[…,x∈reg] constrains x to be in the region reg.
NominalVariables
NominalVariables is an option for statistical functions such as LinearModelFit that specifies which variables should be treated as having discrete values specified by names.
NoncentralBetaDistribution
NoncentralBetaDistribution[α,β,δ] represents a noncentral beta distribution with shape parameters α, β and noncentrality parameter δ.
NoncentralChiSquareDistribution
NoncentralChiSquareDistribution[ν,λ] represents a noncentral χ2 distribution with ν degrees of freedom and noncentrality parameter λ.
NoncentralFRatioDistribution
NoncentralFRatioDistribution[n,m,λ] represents a noncentral F-ratio distribution with n numerator degrees of freedom, m denominator degrees of freedom, and numerator noncentrality parameter λ.
NoncentralFRatioDistribution[n,m,λ, η] represents a doubly noncentral F-ratio distribution with numerator noncentrality parameter λ and denominator noncentrality parameter η.
NoncentralStudentTDistribution
NoncentralStudentTDistribution[ν,δ] represents a noncentral Student t distribution with ν degrees of freedom and noncentrality parameter δ.
NonCommutativeMultiply
a**b**c is a general associative, but non‐commutative, form of multiplication.
NonConstants
NonConstants is an option for D which gives a list of objects to be taken to depend implicitly on the differentiation variables.
NondimensionalizationTransform
NondimensionalizationTransform[eq,ovars,fvars] nondimensionalizes eq, replacing original variables ovars with the variables fvars.
NondimensionalizationTransform[eq,ovars,fvars,prop] returns a property associated with the nondimensionalization of eq.
None
None is a setting used for certain options.
NoneTrue
NoneTrue[{e1,e2,…},test] yields True if test[ei] is False for all of the ei.
NoneTrue[expr,test,level] tests parts of expr at level level.
NoneTrue[test] represents an operator form of NoneTrue that can be applied to an expression.
NonlinearModelFit
NonlinearModelFit[{{x1,y1},{x2,y2},…},form,{β1,…},x] constructs a nonlinear model with formula form that fits the yi for each xi using the free parameters βi.
NonlinearModelFit[data,form,params,{x1,…}] constructs a nonlinear model where form depends on the variables xk.
NonlinearModelFit[data,{form,cons},params,{x1,…}] constructs a nonlinear model subject to the parameter constraints cons.
NonlinearStateSpaceModel
NonlinearStateSpaceModel[{f,g},x,u] represents the model x'(t)f(x(t),u(t)), y(t)g(x(t),u(t)).
NonlinearStateSpaceModel[sys] gives a state-space representation corresponding to the systems model sys.
NonlinearStateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},t] gives the state-space model of the differential equations eqns with dependent variables xi, input variables ui, operating values xi0 and ui0, outputs gi, and independent variable t.
NonlocalMeansFilter
NonlocalMeansFilter[image,r] applies a nonlocal means filter to image by comparing a range r neighborhood to its nearby neighborhoods.
NonlocalMeansFilter[image,r,ns] assumes an additive noise power value ns for comparing neighborhoods.
NonlocalMeansFilter[image,r,ns,w] compares neighborhoods in a range w window.
NonNegative
NonNegative[x] gives True if x is a non‐negative number.
NonNegativeIntegers
NonNegativeIntegers represents the domain of non-negative integers, as in x∈NonNegativeIntegers.
NonNegativeRationals
NonNegativeRationals represents the domain of non-negative rational numbers, as in x∈NonNegativeRationals.
NonNegativeReals
NonNegativeReals represents the domain of non-negative real numbers.
NonPositive
NonPositive[x] gives True if x is a non‐positive number.
NonPositiveIntegers
NonPositiveIntegers represents the domain of non-positive integers, as in x∈NonPositiveIntegers.
NonPositiveRationals
NonPositiveRationals represents the domain of non-positive rational numbers, as in x∈NonPositiveRationals.
NonPositiveReals
NonPositiveReals represents the domain of non-positive real numbers.
Nor
Nor[e1,e2,…] is the logical NOR function. It evaluates its arguments in order, giving False immediately if any of them are True, and True if they are all False.
NorlundB
NorlundB[n,a] gives Nørlund polynomials Bn(a) of degree n in a.
NorlundB[n,a,x] gives generalized Bernoulli polynomials Bn(a)(x).
Norm
Norm[expr] gives the norm of a number, vector, or matrix.
Norm[expr,p] gives the p‐norm.
Normal
Normal[expr] converts expr to a normal expression from a variety of special forms.
Normal[expr,h] converts objects with head h in expr to normal expressions.
Normal[expr,{h1,h2,…}] converts objects with head hi to normal expressions.
NormalDistribution
NormalDistribution[μ,σ] represents a normal (Gaussian) distribution with mean μ and standard deviation σ.
NormalDistribution[] represents a normal distribution with zero mean and unit standard deviation.
NormalizationLayer
NormalizationLayer[] represents a trainable net layer that normalizes its input data across the second and subsequent dimensions and applies an independent scaling and bias to each component of the first dimension.
NormalizationLayer[aggregationlevels] normalizes data across the specified aggregation levels and applies a learned scaling and bias on the remaining levels.
NormalizationLayer[aggregationlevels,scalinglevels] applies a learned scaling and bias at the specified scaling levels.
Normalize
Normalize[v] gives the normalized form of a vector v.
Normalize[z] gives the normalized form of a complex number z.
Normalize[expr,f] normalizes with respect to the norm function f.
Normalized
Normalized is an option that determines whether to test if matrix columns or rows are normalized.
NormalizedSquaredEuclideanDistance
NormalizedSquaredEuclideanDistance[u,v] gives the normalized squared Euclidean distance between vectors u and v.
NormalMatrixQ
NormalMatrixQ[m] gives True if m is an explicitly normal matrix, and False otherwise.
NormalsFunction
NormalsFunction is an option for Plot3D and related functions that specifies a function to apply to determine the effective surface normals at every point.
NormFunction
NormFunction is an option for functions such as FindFit and NDSolve which gives a function to be minimized in generating results.
Not
!expr is the logical NOT function. It gives False if expr is True, and True if it is False.
NotCongruent
NotCongruent[x,y,…] displays as x≢y≢….
NotCupCap
NotCupCap[x,y,…] displays as x≭y≭….
NotDoubleVerticalBar
NotDoubleVerticalBar[x,y,…] displays as x∦y∦….
NotElement
NotElement[x,dom] or x∉dom asserts that x is not an element of the domain dom.
NotElement[x1|…|xn,dom] asserts that none of the xi are elements of dom.
NotElement[patt,dom] asserts that any expression matching the pattern patt is not an element of the domain dom.
NotEqualTilde
NotEqualTilde[x,y,…] displays as xy….
NotExists
NotExists[x,y] displays as ∄xy.
NotGreater
NotGreater[x,y,…] displays as x≯y≯….
NotGreaterEqual
NotGreaterEqual[x,y,…] displays as x≱y≱….
NotGreaterFullEqual
NotGreaterFullEqual[x,y,…] displays as x≩y≩….
NotGreaterGreater
NotGreaterGreater[x,y,…] displays as xy….
NotGreaterLess
NotGreaterLess[x,y,…] displays as x≹y≹….
NotGreaterSlantEqual
NotGreaterSlantEqual[x,y,…] displays as xy….
NotGreaterTilde
NotGreaterTilde[x,y,…] displays as x≵y≵….
Nothing
Nothing represents an element of a list that will automatically be removed.
Nothing[…] gives Nothing.
NotHumpDownHump
NotHumpDownHump[x,y,…] displays as xy….
NotHumpEqual
NotHumpEqual[x,y,…] displays as xy….
NotificationFunction
NotificationFunction is an option that specifies how notifications should be sent from background tasks.
NotLeftTriangle
NotLeftTriangle[x,y,…] displays as x⋪y⋪….
NotLeftTriangleBar
NotLeftTriangleBar[x,y,…] displays as xy….
NotLeftTriangleEqual
NotLeftTriangleEqual[x,y,…] displays as x⋬y⋬….
NotLess
NotLess[x,y,…] displays as x≮y≮….
NotLessEqual
NotLessEqual[x,y,…] displays as x≰y≰….
NotLessFullEqual
NotLessFullEqual[x,y,…] displays as x≨y≨….
NotLessGreater
NotLessGreater[x,y,…] displays as x≸y≸….
NotLessLess
NotLessLess[x,y,…] displays as xy….
NotLessSlantEqual
NotLessSlantEqual[x,y,…] displays as xy….
NotLessTilde
NotLessTilde[x,y,…] displays as x≴y≴….
NotNestedGreaterGreater
NotNestedGreaterGreater[x,y,…] displays as xy….
NotNestedLessLess
NotNestedLessLess[x,y,…] displays as xy….
NotPrecedes
NotPrecedes[x,y,…] displays as x⊀y⊀….
NotPrecedesEqual
NotPrecedesEqual[x,y,…] displays as xy….
NotPrecedesSlantEqual
NotPrecedesSlantEqual[x,y,…] displays as x⋠y⋠….
NotPrecedesTilde
NotPrecedesTilde[x,y,…] displays as x⋨y⋨….
NotReverseElement
NotReverseElement[x,y,…] displays as x∌y∌….
NotRightTriangle
NotRightTriangle[x,y,…] displays as x⋫y⋫….
NotRightTriangleBar
NotRightTriangleBar[x,y,…] displays as xy….
NotRightTriangleEqual
NotRightTriangleEqual[x,y,…] displays as x⋭y⋭….
NotSquareSubset
NotSquareSubset[x,y,…] displays as xy….
NotSquareSubsetEqual
NotSquareSubsetEqual[x,y,…] displays as x⋢y⋢….
NotSquareSuperset
NotSquareSuperset[x,y,…] displays as xy….
NotSquareSupersetEqual
NotSquareSupersetEqual[x,y,…] displays as x⋣y⋣….
NotSubset
NotSubset[x,y,…] displays as x⊄y⊄….
NotSubsetEqual
NotSubsetEqual[x,y,…] displays as x⊈y⊈….
NotSucceeds
NotSucceeds[x,y,…] displays as x⊁y⊁….
NotSucceedsEqual
NotSucceedsEqual[x,y,…] displays as xy….
NotSucceedsSlantEqual
NotSucceedsSlantEqual[x,y,…] displays as x⋡y⋡….
NotSucceedsTilde
NotSucceedsTilde[x,y,…] displays as x⋩y⋩….
NotSuperset
NotSuperset[x,y,…] displays as x⊅y⊅….
NotSupersetEqual
NotSupersetEqual[x,y,…] displays as x⊉y⊉….
NotTilde
NotTilde[x,y,…] displays as x≁y≁….
NotTildeEqual
NotTildeEqual[x,y,…] displays as x≄y≄….
NotTildeFullEqual
NotTildeFullEqual[x,y,…] displays as x≇y≇….
NotTildeTilde
NotTildeTilde[x,y,…] displays as x≉y≉….
NotVerticalBar
NotVerticalBar[x,y,…] displays as xy….
Now
Now gives a DateObject representing the current moment in time.
NoWhitespace
NoWhitespace represents the absence of whitespace between elements in a grammar rules pattern.
NProbability
NProbability[pred,xdist] gives the numerical probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution dist.
NProbability[pred,{x1,x2,…}dist] gives the numerical probability that an event satisfies pred under the assumption that {x1,x2,…} follows the multivariate distribution dist.
NProbability[pred,{x1dist1,x2dist2,…}] gives the numerical probability that an event satisfies pred under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, ….
NProbability[pred1pred2,…] gives the numerical conditional probability of pred1 given pred2.
NProduct
NProduct[f,{i,imin,imax}] gives a numerical approximation to the product ∏+i=imin%imaxf.
NProduct[f,{i,imin,imax,di}] uses a step di in the product.
NProductFactors
NProductFactors is an option for NProduct. NProductFactors -> n explicitly includes n factors in the product before extrapolation.
NRoots
NRoots[lhs==rhs,var] yields a disjunction of equations which represent numerical approximations to the roots of a polynomial equation.
NSolve
NSolve[expr,vars] attempts to find numerical approximations to the solutions of the system expr of equations or inequalities for the variables vars.
NSolve[expr,vars,Reals] finds solutions over the domain of real numbers.
NSolveValues
NSolveValues[expr,vars] attempts to find numerical approximations to the values of vars determined by the solutions of the system expr.
NSolveValues[expr,vars,Reals] finds solutions over the domain of real numbers.
NSum
NSum[f,{i,imin,imax}] gives a numerical approximation to the sum ∑+i=imin%imaxf.
NSum[f,{i,imin,imax,di}] uses a step di in the sum.
NSumTerms
NSumTerms is an option for NSum. NSumTerms -> n explicitly includes n terms in the sum before extrapolation.
NuclearExplosionData
NuclearExplosionData[entity,property] gives the value of the specified property for the nuclear explosion entity.
NuclearExplosionData[{entity1,entity2,…},property] gives a list of property values for the specified nuclear explosion entities.
NuclearExplosionData[entity,property,annotation] gives the specified annotation associated with the given property.
NuclearReactorData
NuclearReactorData[entity,property] gives the value of the specified property for the nuclear reactor entity.
NuclearReactorData[{entity1,entity2,…},property] gives a list of property values for the specified nuclear reactor entities.
NuclearReactorData[entity,property,annotation] gives the specified annotation associated with the given property.
Null
Null is a symbol used to indicate the absence of an expression or a result. When it appears as a complete output expression, no output is printed.
NullRecords
NullRecords is an option for Read and related functions which specifies whether null records should be taken to exist between repeated record separators.
NullSpace
NullSpace[m] gives a list of vectors that forms a basis for the null space of the matrix m.
NullWords
NullWords is an option for Read and related functions which specifies whether null words should be taken to exist between repeated word separators.
Number
Number represents an exact integer or an approximate real number in Read.
NumberCompose
NumberCompose[{c1,…,cn},{u1,…,un}] returns the quantity c1 u1+…+cn un.
NumberDecompose
NumberDecompose[x,{u1,…,un}] returns a list of coefficients {c1,…,cn} of a decomposition of the number x in the basis {u1,…,un}.
NumberDigit
NumberDigit[x,n] returns the digit corresponding to 10n in the real-valued number x.
NumberDigit[x,n,b] returns the digit corresponding to bn.
NumberExpand
NumberExpand[x] gives a list of the decimal digits of x multiplied by their corresponding powers of 10.
NumberExpand[x,b] expands x in base b.
NumberExpand[x,b,len] gives a list of length len.
NumberFieldClassNumber
NumberFieldClassNumber[θ] gives the class number for the algebraic number field [θ] generated by θ.
NumberFieldDiscriminant
NumberFieldDiscriminant[a] gives the discriminant of the field [a] generated by the algebraic number a.
NumberFieldFundamentalUnits
NumberFieldFundamentalUnits[a] gives a list of fundamental units for the field [a] generated by the algebraic number a.
NumberFieldIntegralBasis
NumberFieldIntegralBasis[a] gives an integral basis for the field [a] generated by the algebraic number a.
NumberFieldNormRepresentatives
NumberFieldNormRepresentatives[a,m] gives a list of representatives of classes of algebraic integers of norm ±m in the field [a] generated by the algebraic number a.
NumberFieldRegulator
NumberFieldRegulator[a] gives the regulator of the field [a] generated by the algebraic number a.
NumberFieldRootsOfUnity
NumberFieldRootsOfUnity[a] gives the roots of unity for the field [a] generated by the algebraic number a.
NumberFieldSignature
NumberFieldSignature[a] gives the signature of the field [a] generated by the algebraic number a.
NumberForm
NumberForm[expr,n] prints with approximate real numbers in expr given to n‐digit precision.
NumberForm[expr,{n,f}] prints with approximate real numbers having n digits, with f digits to the right of the decimal point.
NumberForm[expr] prints using the default options of NumberForm.
NumberFormat
NumberFormat is an option for NumberForm and related functions that specifies how the mantissa, base, and exponent should be assembled into a final print form.
NumberLinePlot
NumberLinePlot[{v1,v2,…}] plots the values vi on a number line.
NumberLinePlot[pred,x] plots a number line illustrating the region pred.
NumberLinePlot[pred,{x,xmin,xmax}] plots the number to extend over the interval from xmin to xmax.
NumberLinePlot[{spec1,spec2,…},…] plots several number lines.
NumberMarks
NumberMarks is an option for InputForm and related functions that specifies whether ` marks should be included in the printed forms of approximate numbers.
NumberMultiplier
NumberMultiplier is an option for NumberForm and related functions which gives the string to use as a multiplication sign in scientific notation.
NumberPadding
NumberPadding is an option for NumberForm and related functions which gives strings to use as padding on the left‐ and right‐hand sides of numbers.
NumberPoint
NumberPoint is an option for NumberForm and related functions that gives the string to use as a decimal point.
NumberQ
NumberQ[expr] gives True if expr is a number, and False otherwise.
NumberSeparator
NumberSeparator is an option for NumberForm and related functions that gives the string to insert at breaks between digits.
NumberSigns
NumberSigns is an option for NumberForm and related functions which gives strings to use as signs for negative and positive numbers.
NumberString
NumberString represents the characters of a number in StringExpression.
Numerator
Numerator[expr] gives the numerator of expr.
NumeratorDenominator
NumeratorDenominator[expr] gives the list {Numerator[expr],Denominator[expr]} of expr.
NumericalOrder
NumericalOrder[e1,e2] gives 1 if e1<e2, -1 if e1>e2, 0 if e1 and e2 are numerically the same, and orders by type or using canonical order if e1 and e2 are not numerically comparable.
NumericalSort
NumericalSort[list] sorts the elements of list into numerical order.
NumericArray
NumericArray[array,type] creates a numeric array of the specified type.
NumericArray[array,type,method] uses method to convert numbers into type.
NumericArrayQ
NumericArrayQ[expr] gives True if expr is a valid NumericArray object, and False otherwise.
NumericArrayQ[expr, tpatt] requires additionally that NumericArrayType[expr] match the pattern tpatt.
NumericArrayQ[expr,tpatt,dpatt] requires additionally that ArrayDepth[expr] match the pattern dpatt.
NumericArrayType
NumericArrayType[array] gives the underlying type of values used for each element in the NumericArray object.
NumericFunction
NumericFunction is an attribute that can be assigned to a symbol f to indicate that f[arg1,arg2,…] should be considered a numeric quantity whenever all the argi are numeric quantities.
NumericQ
NumericQ[expr] gives True if expr is a numeric quantity, and False otherwise.
NuttallWindow
NuttallWindow[x] represents a Nuttall window function of x.
NValues
NValues[f] gives a list of transformation rules corresponding to all numerical values (values for N[f[x,…],…], etc.) defined for the symbol f.
NyquistGridLines
NyquistGridLines is an option to NyquistPlot that specifies contours of constant magnitude and phase of a closed-loop system.
NyquistPlot
NyquistPlot[lsys] generates a Nyquist plot of the transfer function for the system lsys.
NyquistPlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.
NyquistPlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.
O
O[x]^n represents a term of order xn.
O[x]^n is generated to represent omitted higher‐order terms in power series.
O[x,x0]^n represents a term of order (x-x0)n.
ObjectExistsQ
System`ObjectExistsQ
ObservabilityGramian
ObservabilityGramian[ssm] gives the observability Gramian of the state-space model ssm.
ObservabilityMatrix
ObservabilityMatrix[ssm] gives the observability matrix of the state-space model ssm.
ObservableDecomposition
ObservableDecomposition[sys] yields the observable subsystem of the system sys.
ObservableDecomposition[sys,{z1,…}] specifies the new coordinates zi.
ObservableModelQ
ObservableModelQ[sys] gives True if the system sys is observable, and False otherwise.
ObservableModelQ[{sys,sub}] gives True if the subsystem sub is observable.
OceanData
OceanData[entity,property] gives the value of the specified property for the ocean entity.
OceanData[{entity1,entity2,…},property] gives a list of property values for the specified ocean entities.
OceanData[entity,property,annotation] gives the specified annotation associated with the given property.
Octahedron
Octahedron[] represents a regular octahedron centered at the origin with unit edge length.
Octahedron[l] represents an octahedron with edge length l.
Octahedron[{θ,ϕ},…] represents an octahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
Octahedron[{x,y,z},…] represents an octahedron centered at {x,y,z}.
OddQ
OddQ[expr] gives True if expr is an odd integer, and False otherwise.
Off
Off[symbol::tag] switches off a message, so that it is no longer printed.
Off["name"] switches off a named group of messages.
Off[s] switches off tracing messages associated with the symbol s.
Off[m1,m2,…] switches off several messages or message groups.
Offset
Offset[{dx,dy},position] gives the position of a graphical object obtained by starting at the specified position and then moving by absolute offset {dx,dy}.
On
On[symbol::tag] switches on a message, so that it can be printed.
On["name"] switches on a named group of messages.
On[s] switches on tracing for the symbol s.
On[m1,m2,…] switches on several messages or message groups.
ONanGroupON
ONanGroupON[] represents the sporadic simple O'Nan group O'N.
Once
Once[expr] evaluates expr once in each Wolfram Language session, always returning the result from the first evaluation.
Once[expr,loc] evaluates expr once and caches the result in persistence location loc.
OneIdentity
OneIdentity is an attribute that can be assigned to a symbol f to indicate that f[x], f[f[x]], etc. are all equivalent to x for the purpose of pattern matching.
Opacity
Opacity[a] is a graphics directive that specifies that graphical objects that follow are to be displayed, if possible, with opacity a.
Opacity[a,color] uses the specified color with opacity a.
OpacityFunction
OpacityFunction is an option for graphics functions that specifies a function to apply to determine opacity of elements.
OpacityFunctionScaling
OpacityFunctionScaling is an option to visualization functions such as DensityPlot3D that specifies whether arguments supplied to OpacityFunction should be scaled to lie between 0 and 1.
OpenAppend
OpenAppend["file"] opens a file to append output to it, and returns an OutputStream object.
OpenerView
OpenerView[{expr1,expr2}] represents an object which displays as an opener, together with expr1 if the opener is closed, and both expr1 and expr2 if it is open.
OpenerView[{expr1,expr2},state] specifies the state of the opener, with False being closed, and True being open.
Opening
Opening[image,ker] gives the morphological opening of image with respect to the structuring element ker.
Opening[image,r] gives the opening with respect to a range-r square.
Opening[data,…] applies opening to an array of data.
OpenRead
OpenRead["file"] opens a file to read data from, and returns an InputStream object.
OpenTemporary
OpenTemporary[] opens a temporary file to which output can be written, and returns an OutputStream object.
OpenWrite
OpenWrite["file"] opens a file to write output to it, and returns an OutputStream object.
OpenWrite[] opens a new file in the default area for temporary files on your computer system.
Operate
Operate[p,f[x,y,…]] gives p[f][x,y,…].
Operate[p,expr,n] applies p at level n in the head of expr.
OperatorApplied
OperatorApplied[f,n] represents an operator form of the function f of n arguments so that OperatorApplied[f,n][x1]…[xn] is equivalent to f[x1,…,xn].
OperatorApplied[f] represents an operator form of the function f of two arguments so that OperatorApplied[f][y][x] is equivalent to f[x,y].
OperatorApplied[f,{i1,…,in}] represents an operator form of the function f of n arguments so that OperatorApplied[f,{i1,…,in}][x1]…[xn] is equivalent to f[xi1,…,xin].
OperatorApplied[f,k->{i1,…,in}] represents an operator form that takes k arguments.
OptimumFlowData
OptimumFlowData[…] represents flow data such as generated by FindMaximumFlow, FindMinimumCostFlow, etc.
Optional
patt:def or Optional[patt,def] is a pattern object that represents an expression of the form patt, which, if omitted, should be replaced by the default value def.
OptionalElement
OptionalElement[patt] is a grammar rules pattern object that represents 0 or 1 instances of patt.
OptionalElement[patt,default] uses default if the element is not present.
OptionInspectorSettings
OptionInspectorSettings is a global option that specifies the display of options in the Option Inspector.
OptionQ
OptionQ[e] returns True if e can be considered an option or list of options, and False otherwise.
Options
Options[symbol] or Options["symbol"] gives the list of default options assigned to a symbol.
Options[expr] gives the options explicitly specified in a particular expression such as a graphics object.
Options[stream] gives options associated with a particular stream.
Options[object] gives options associated with an external object such as an NotebookObject or CloudObject.
Options[obj,name] gives the setting for the option name.
Options[obj,{name1,name2,…}] gives a list of the settings for the options namei.
OptionsPattern
OptionsPattern[] is a pattern object that represents a collection of options given as rules, where the values of the options can be accessed using OptionValue.
OptionsPattern[f] takes default option values from Options[f].
OptionsPattern[{opt1->val1,opt2->val2,…}] uses an explicit list of default option values.
OptionValue
OptionValue[name] gives the value of name in options matched by OptionsPattern.
OptionValue[f,name] gives the value of name for options associated with the head f.
OptionValue[f,opts,name] extracts option values from the explicit list of rules opts.
OptionValue[…,{name1,name2,…}] extracts several option values.
Or
e1||e2||… is the logical OR function. It evaluates its arguments in order, giving True immediately if any of them are True, and False if they are all False.
Orange
Orange represents the color orange in graphics or style specifications.
Order
Order[expr1,expr2] gives 1 if expr1 is before expr2 in canonical order, and -1 if expr1 is after expr2 in canonical order. It gives 0 if expr1 is identical to expr2.
OrderDistribution
OrderDistribution[{dist,n},k] represents the kth-order statistics distribution for n observations from the distribution dist.
OrderDistribution[{dist,n},{k1,k2,…}] represents the joint (k1,k2,…)th-order statistics distribution from n observations from the distribution dist.
OrderDistribution[{dist1,…,distn},…] represents the order statistics distribution for independent distributions disti.
OrderDistribution[mdist,…] represents the order statistics distribution for multivariate distribution mdist.
OrderedQ
OrderedQ[h[e1,e2,…]] gives True if the ei are in canonical order, and False otherwise.
OrderedQ[h[e1,e2,…],p] uses the ordering function p to determine whether each pair of elements ei, ei+1 is in order.
Ordering
Ordering[list] gives the positions in list at which each successive element of Sort[list] appears.
Ordering[list,n] gives the positions in list at which the first n elements of Sort[list] appear.
Ordering[list,-n] gives the positions of the last n elements of Sort[list].
Ordering[list,n,p] gives positions in list of elements of Sort[list,p].
OrderingBy
OrderingBy[list,f] gives the positions in list at which each successive element of SortBy[list,f] appears.
OrderingBy[list,f,n] gives the positions in list at which the first n elements of SortBy[list,f] appear.
OrderingBy[list,f,-n] gives the positions of the last n elements of SortBy[list,f].
OrderingBy[list,f,n,p] gives positions in list of elements of SortBy[list,f,p].
OrderingBy[f] represents an operator form of OrderingBy that can be applied to an expression.
OrderingLayer
OrderingLayer[] represents a net layer that effectively applies Ordering to its input.
OrderingLayer[n] gives the first n elements in the ordering of its input.
OrderingLayer[-n] gives the last n elements in the ordering of its input.
Orderless
Orderless is an attribute that can be assigned to a symbol f to indicate that the elements ei in expressions of the form f[e1,e2,…] should automatically be sorted into canonical order. This property is accounted for in pattern matching.
OrderlessPatternSequence
OrderlessPatternSequence[p1,p2,…] is a pattern object that represents a sequence of arguments matching p1,p2,… in any order.
OrnsteinUhlenbeckProcess
OrnsteinUhlenbeckProcess[μ,σ,θ] represents a stationary Ornstein–Uhlenbeck process with long-term mean μ, volatility σ, and mean reversion speed θ.
OrnsteinUhlenbeckProcess[μ,σ,θ,x0] represents an Ornstein–Uhlenbeck process with initial condition x0.
Orthogonalize
Orthogonalize[{v1,v2,…}] gives an orthonormal basis found by orthogonalizing the vectors vi.
Orthogonalize[{e1,e2,…},f] gives an orthonormal basis found by orthogonalizing the elements ei with respect to the inner product function f.
OrthogonalMatrixQ
OrthogonalMatrixQ[m] gives True if m is an explicitly orthogonal matrix, and False otherwise.
Out
%n or Out[n] is a global object that is assigned to be the value produced on the nth output line.
% gives the last result generated.
%% gives the result before last. %%…% (k times) gives the kth previous result.
Outer
Outer[f,list1,list2,…] gives the generalized outer product of the listi, forming all possible combinations of the lowest‐level elements in each of them, and feeding them as arguments to f.
Outer[f,list1,list2,…,n] treats as separate elements only sublists at level n in the listi.
Outer[f,list1,list2,…,n1,n2,…] treats as separate elements only sublists at level ni in the corresponding listi.
OuterPolygon
OuterPolygon[poly] gives the outer polygon of the polygon poly.
OuterPolyhedron
OuterPolyhedron[poly] gives the outer polyhedron of the polyhedron poly.
OutputAutoOverwrite
OutputAutoOverwrite is an option for notebooks that specifies whether the output of a command should replace any existing output from a previous evaluation.
OutputControllabilityMatrix
OutputControllabilityMatrix[ssm] gives the output controllability matrix of the state-space model ssm.
OutputControllableModelQ
OutputControllableModelQ[ssm] gives True if the state-space model ssm is output controllable, and False otherwise.
OutputForm
OutputForm[expr] prints as a two-dimensional representation of expr using only keyboard characters.
OutputNamePacket
OutputNamePacket[string] is a WSTP packet that contains in string the name assigned to the next output.
OutputPorts
OutputPorts is an option to specify the number, names or shapes of output ports for some neural net layers.
OutputResponse
OutputResponse[sys,u[t],{t,tmin,tmax}] gives the numeric output response of systems model sys to the input u[t] for tmin≤t≤tmax.
OutputResponse[sys,{u[0],u[1],…}] gives the output response of the discrete-time system sys to the input sequence u[i].
OutputResponse[sys,u[t],t] gives the symbolic output response of system sys to the input u[t] as a function of time t.
OutputResponse[sys,{u1[t],…,um[t]},…] gives the output response for multiple inputs ui[t].
OutputSizeLimit
OutputSizeLimit is an option for notebooks that specifies the maximum size in bytes of expressions that will automatically be output in their entirety.
OutputStream
OutputStream["name",n] is an object that represents an output stream for functions such as Write.
OverBar
OverBar[expr] displays with a bar over expr.
OverDot
OverDot[expr] displays with a dot over expr.
OverDot[expr,n] prints with n dots.
Overflow
Overflow[] represents a number too large to represent explicitly on your computer system.
OverHat
OverHat[expr] displays with a hat over expr.
Overlaps
Overlaps is an option to string and sequence functions that specifies how to treat overlapping substrings.
Overlay
Overlay[{expr1,expr2,…}] displays as an overlay of all the expri.
Overlay[{expr1,expr2,…},{i,j,…}] displays as an overlay of expri, exprj, ….
Overlay[{expr1,expr2,…},{i,j,…},s] allows selections to be made and controls to be clicked in exprs.
OverlayVideo
OverlayVideo[background,o] gives the result of overlaying o onto a background video or image background.
OverlayVideo[background,{o1,o2,…}] gives the result of overlaying o1, o2, ….
OverlayVideo[background,{interval1->o1,…}] overlays each oi during the time interval intervali.
Overscript
Overscript[x,y] is an object that formats as x&y.
OverTilde
OverTilde[expr] displays with a tilde over expr.
OverVector
OverVector[expr] displays with a right vector over expr.
OverwriteTarget
OverwriteTarget is an option for functions like CopyFile that specifies whether to overwrite if target files already exist.
OwenT
OwenT[x,a] gives Owen's T function T(x,a).
OwnValues
OwnValues[x] gives a list of transformation rules corresponding to all ownvalues defined for the symbol x.
OwnValues["symbol"] gives a list of transformation rules corresponding to all ownvalues defined for the symbol named "symbol" if it exists.
PackingMethod
PackingMethod is an option for GraphPlot and related functions that specifies how disconnected components should be packed together in the layout produced.
PackPaclet
The experimental function PackPaclet is now obsolete and is superseded by CreatePacletArchive.
PacletDataRebuild
PacletDataRebuild[] rescans all the installed paclets to rebuild the internal cache of paclet data.
PacletDirectoryAdd
The experimental function PacletDirectoryAdd is now obsolete and is superseded by PacletDirectoryLoad.
PacletDirectoryLoad
PacletDirectoryLoad[dir] makes paclets in dir visible in the current session.
PacletDirectoryLoad[{dir1,dir2, …}] makes paclets in all the diri visible in the current session.
PacletDirectoryRemove
StringTemplate[The experimental function `1` is now obsolete and is superseded by `2`., PacletDirectoryRemove, PacletDirectoryUnload]
PacletDirectoryUnload
PacletDirectoryUnload[dir] makes paclets in dir no longer visible in the current session.
PacletDirectoryUnload[{dir1,dir2, …}] makes paclets in all the diri no longer visible in the current session.
PacletDisable
PacletDisable[paclet] disables an installed paclet.
PacletEnable
PacletEnable[paclet] enables a previously disabled paclet.
PacletFind
PacletFind["name"] gives a list of installed paclets that match "name".
PacletFind["name"->"version"] gives a list of installed paclets that match "name" and "version".
PacletFind["name",<|prop1->val1,prop2->val2,…|>] gives a list of installed paclets that match "name" and criteria given by the propi->vali.
PacletFindRemote
PacletFindRemote["name"] gives a list of paclets that match "name" available on known paclet sites.
PacletFindRemote["name"->"version"] gives a list of paclets that match "name" and "version" available on known paclet sites.
PacletFindRemote["name",<|prop1->val1,prop2->val2,…|>] gives a list of paclets that match "name" and criteria given by the propi->vali available on known paclet sites.
PacletInformation
The experimental function PacletInformation is now obsolete. Use Information[PacletObject["pacletname"]], or property-extraction syntax like PacletObject["pacletname"]["prop"] or PacletObject["pacletname"][All] instead.
PacletInstall
PacletInstall[paclet] installs or updates paclet.
PacletInstall[task] waits for completion of the task started by a call to PacletInstallSubmit.
PacletInstallSubmit
PacletInstallSubmit[paclet] asynchronously installs or updates paclet.
PacletNewerQ
PacletNewerQ[paclet1,paclet2] returns True if paclet1 has a higher version number than paclet2, and False otherwise.
PacletObject
PacletObject[...] is the representation of a paclet in the Wolfram Language.
PacletObjectQ
PacletObjectQ[expr] returns True or False depending on whether its argument is a PacletObject expression.
PacletSite
PacletSite is an option for PacletInstall and PacletInstallSubmit that specifies the URL of a paclet site on which to look for the paclet.
PacletSiteObject
PacletSiteObject[assoc] represents a site from which paclets can be automatically downloaded.
PacletSiteRegister
PacletSiteRegister[url] registers url as a known paclet site.
PacletSiteRegister[url,name] registers url as a known paclet site with name.
PacletSiteRegister[PacletSiteObject[…]] registers the given PacletSiteObject as a known paclet site.
PacletSites
PacletSites[] gives the list of all paclet sites known to your system.
PacletSiteUnregister
PacletSiteUnregister[url] removes url from the list of registered paclet sites.
PacletSiteUnregister[name] removes the site named name from the list of registered paclet sites.
PacletSiteUnregister[PacletSiteObject[…]] removes the given PacletSiteObject from the list of registered paclet sites.
PacletSiteUpdate
PacletSiteUpdate[site] acquires and caches current information about the available paclets on the given paclet site.
PacletSymbol
PacletSymbol[paclet,"sym"] gives the symbol named "sym" in the primary context of paclet.
PacletSymbol[paclet,"sym",h] wraps the head h around the symbol before returning it.
PacletUninstall
PacletUninstall[paclet] uninstalls a paclet.
PacletUpdate
The experimental function PacletUpdate is now obsolete and is superseded by PacletInstall.
PaddedForm
PaddedForm[expr,n] prints with all numbers in expr padded to leave room for a total of n digits.
PaddedForm[expr,{n,f}] prints with approximate real numbers having exactly f digits to the right of the decimal point.
Padding
Padding is an option to various array and image operations that specifies what padding to use when extending beyond the original data specified.
PaddingLayer
PaddingLayer[{{m1,n1},{m2,n2},…}] represents a net layer that pads an input array with mi elements at the beginning and ni elements at the end at level i of the array.
PaddingSize
PaddingSize is an option in AudioDelay and other functions that specifies the amount of padding.
PadeApproximant
PadeApproximant[expr,{x,x0,{m,n}}] gives the Padé approximant to expr about the point x=x0, with numerator order m and denominator order n.
PadeApproximant[expr,{x,x0,n}] gives the diagonal Padé approximant to expr about the point x=x0 of order n.
PadLeft
PadLeft[list,n] makes a list of length n by padding list with zeros on the left.
PadLeft[list,n,x] pads by repeating the element x.
PadLeft[list,n,{x1,x2,…}] pads by cyclically repeating the elements xi.
PadLeft[list,n,padding,m] leaves a margin of m elements of padding on the right.
PadLeft[list,{n1,n2,…}] makes a nested list with length ni at level i.
PadLeft[list] pads a ragged array list with zeros to make it full.
PadRight
PadRight[list,n] makes a list of length n by padding list with zeros on the right.
PadRight[list,n,x] pads by repeating the element x.
PadRight[list,n,{x1,x2,…}] pads by cyclically repeating the elements xi.
PadRight[list,n,padding,m] leaves a margin of m elements of padding on the left.
PadRight[list,{n1,n2,…}] makes a nested list with length ni at level i.
PadRight[list] pads a ragged array list with zeros to make it full.
PageBreakAbove
PageBreakAbove is an option for Cell which specifies whether a page break should be made immediately above the cell if the notebook that contains the cell is printed.
PageBreakBelow
PageBreakBelow is an option for Cell which specifies whether a page break should be made immediately below the cell if the notebook that contains the cell is printed.
PageBreakWithin
PageBreakWithin is an option for Cell which specifies whether a page break should be allowed within the cell if the notebook that contains the cell is printed.
PageFooterLines
PageFooterLines is an option for notebooks that specifies whether a horizontal line is inserted at the bottom of each page when the notebook is printed.
PageFooters
PageFooters is an option for notebooks that specifies what should be inserted as the footer of each page of a notebook when it is printed.
PageHeaderLines
PageHeaderLines is an option for notebooks that specifies whether a horizontal line is inserted at the top of each page when the notebook is printed.
PageHeaders
PageHeaders is an option for notebooks that specifies what should be inserted as the header of each page of a notebook when it is printed.
PageRankCentrality
PageRankCentrality[g,α] gives a list of page-rank centralities for the vertices in the graph g and weight α.
PageRankCentrality[g,α,β] gives a list of page-rank centralities, using weight α and initial centralities β.
PageRankCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
PageTheme
PageTheme is an option for FormObject, GalleryView, and related functions that specifies an overall theme for a webpage and its elements.
Pagination
Pagination is an option for GalleryView and related functions that specifies how pagination should be done in displayed output.
PairCorrelationG
PairCorrelationG[pdata,r] estimates the pair correlation function g(r) for point data pdata at radius r.
PairCorrelationG[pproc,r] computes g(r) for the point process pproc.
PairCorrelationG[bdata,r] computes g(r) for binned data bdata.
PairCorrelationG[pspec] generates the function g that can be applied repeatedly to different radii r.
PairedBarChart
PairedBarChart[{y1,y2,…},{z1,z2,…}] makes a paired bar chart with bar lengths y1, y2, … and z1, z2, …, respectively.
PairedBarChart[{…,wi[yi,…],…},{…,wj[zj,…],…}] makes a paired bar chart with bar features defined by the symbolic wrappers wk.
PairedBarChart[{data11,…},{data21,…}] makes a paired bar chart from multiple datasets data1i and data2j.
PairedHistogram
PairedHistogram[{x1,x2,…},{y1,y2,…}] plots a paired histogram of the values xi and yi.
PairedHistogram[{x1,x2,…},{y1,y2,…}, bspec] plots a paired histogram with bin width specification bspec.
PairedHistogram[{x1,x2,…},{y1,y2,…},bspec,hspec] plots a paired histogram with bin heights computed according to the specification hspec.
PairedHistogram[{data11,…},{data21,…},…] plots paired histograms for multiple datasets data1i and data2j.
PairedSmoothHistogram
PairedSmoothHistogram[{x1,x2,…},{y1,y2,…}] plots a paired smooth histogram of the values xi and yi.
PairedSmoothHistogram[{x1,x2,…},{y1,y2,…},espec] plots a paired smooth histogram with estimator specification espec.
PairedSmoothHistogram[{x1,x2,…},{y1,y2,…},espec,dfun] plots a paired smooth histogram with distribution function dfun.
PairedSmoothHistogram[{data11,…},{data21,…},…] plots paired smooth histograms for multiple datasets data1i and data2j.
PairedTTest
PairedTTest[data] tests whether the mean of data is zero.
PairedTTest[{data1,data2}] tests whether the mean of data1– data2 is zero.
PairedTTest[dspec,μ0] tests a location measure against μ0.
PairedTTest[dspec,μ0,"property"] returns the value of "property".
PairedZTest
PairedZTest[data] tests whether the mean of the data is zero.
PairedZTest[{data1,data2}] tests whether the means of data1 and data2 are equal.
PairedZTest[dspec,σ] tests for zero or equal means assuming a population variance σ.
PairedZTest[dspec,σ,μ0] tests the mean against μ0.
PairedZTest[dspec,σ,μ0,"property"] returns the value of "property".
PalindromeQ
PalindromeQ[list] returns True if the given list is identical to Reverse[list], and False otherwise.
PalindromeQ[n] returns True if the integer n is identical to IntegerReverse[n], and False otherwise.
PalindromeQ[string] returns True if the given string is identical to StringReverse[string], and False otherwise.
Pane
Pane[expr] displays as a pane containing expr.
Pane[expr,w] makes the pane be w printer's points wide, linewrapping the contents if necessary.
Pane[expr,{w,h}] makes the pane be w points wide and h points high, shrinking the contents if necessary.
Panel
Panel[expr] displays as a panel containing expr.
Panel[expr,title] gives the panel the specified title.
Panel[expr,title,pos] places title at a position specified by pos.
Panel[expr,{title1,title2,…},{pos1,…}] places titlei at position posi.
Panel[] displays an empty panel.
Paneled
Paneled is an option for Manipulate and related functions that specifies whether to give the output inside a panel.
ParabolicCylinderD
ParabolicCylinderD[ν,z] gives the parabolic cylinder function Dν(z).
ParallelArray
ParallelArray[f,n] generates in parallel a list of length n, with elements f[i], evaluated.
ParallelArray[f,{n1,n2,…}] generates in parallel an n1n2… array of nested lists, with elements f[i1,i2,…].
ParallelArray[f,{n1,n2,…},{r1,r2,…}] generates in parallel a list using the index origins ri (default 1).
ParallelArray[f,dims,origin,h] uses head h, rather than List, for each level of the array.
ParallelAxisPlot
ParallelAxisPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] generates a parallel axis plot for the points {yi1,…,yin} using equally spaced axes.
ParallelAxisPlot[{data1,data2,…}] plots several sets of points.
ParallelCombine
ParallelCombine[f,h[e1,e2,…],comb] evaluates f[h[e1,e2,…]] in parallel by distributing parts of the computation to all parallel kernels and combining the partial results with comb.
ParallelCombine[f,h[e1,e2, …]] is equivalent to ParallelCombine[f,h[e1,e2,…],h] if h has attribute Flat, and ParallelCombine[f,h[e1,e2,…],Join] otherwise.
ParallelDo
ParallelDo[expr,{imax}] evaluates expr in parallel imax times.
ParallelDo[expr,{i,imax}] evaluates expr in parallel with the variable i successively taking on the values 1 through imax (in steps of 1).
ParallelDo[expr,{i,imin,imax}] starts with i=imin.
ParallelDo[expr,{i,imin,imax,di}] uses steps di.
ParallelDo[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….
ParallelDo[expr,{i,imin,imax},{j,jmin,jmax},…] evaluates expr looping in parallel over different values of j, etc. for each i.
Parallelepiped
Parallelepiped[p,{v1,…,vk}] represents a parallelepiped with origin p and directions vi.
ParallelEvaluate
ParallelEvaluate[expr] evaluates the expression expr on all available parallel kernels and returns the list of results obtained.
ParallelEvaluate[expr,kernel] evaluates expr on the parallel kernel specified.
ParallelEvaluate[expr,{ker1,ker2,…}] evaluates expr on the parallel kernels keri.
ParallelEvaluate[expr,kernels,h] wraps the head h around the results before returning them.
Parallelization
Parallelization is an option for Compile that specifies whether it should create a compiled function that could run in parallel.
Parallelize
Parallelize[expr] evaluates expr using automatic parallelization.
ParallelMap
ParallelMap[f,expr] applies f in parallel to each element on the first level in expr.
ParallelMap[f,expr,levelspec] applies f in parallel to parts of expr specified by levelspec.
ParallelNeeds
ParallelNeeds["context`"] evaluates Needs["context`"] on all available parallel kernels.
Parallelogram
Parallelogram[p,{v1,v2}] represents a parallelogram with origin p and directions v1 and v2.
ParallelSubmit
ParallelSubmit[expr] submits expr for evaluation on the next available parallel kernel and returns an EvaluationObject expression representing the submitted evaluation.
ParallelSubmit[{var1,var2, …},expr] builds a closure for the variables given before submitting expr.
ParallelTable
ParallelTable[expr,{imax}] generates in parallel a list of imax copies of expr.
ParallelTable[expr,{i,imax}] generates in parallel a list of the values of expr when i runs from 1 to imax.
ParallelTable[expr,{i,imin,imax}] starts with i=imin.
ParallelTable[expr,{i,imin,imax,di}] uses steps di.
ParallelTable[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….
ParallelTable[expr,{i,imin,imax},{j,jmin,jmax},…] gives a nested list. The list associated with i is outermost.
ParallelTry
ParallelTry[f,{arg1,arg2,…}] evaluates f[argi] in parallel, returning the first result received.
ParallelTry[f,{arg1,arg2,…},k] returns a list of the first k results.
ParameterEstimator
ParameterEstimator is an option to EstimatedDistribution and FindDistributionParameters that specifies what parameter estimator to use.
ParameterMixtureDistribution
ParameterMixtureDistribution[dist[θ],θwdist] represents a parameter mixture distribution where the parameter θ is distributed according to the weight distribution wdist.
ParameterMixtureDistribution[dist[θ1,θ2,…],{θ1wdist1,θ2wdist2,…}] represents a parameter mixture distribution where the parameter θ1 has weight distribution wdist1, θ2 has weight distribution wdist2, etc.
ParameterVariables
ParameterVariables is an option for GroebnerBasis and PolynomialReduce. These variables will always be last in the ordering. By default, all variables that are not otherwise classified will become parameter variables. By specifying them explicitly one fixes their relative positions in the overall variable ordering.
ParametricConvexOptimization
ParametricConvexOptimization[f,cons,vars,pars] gives a ParametricFunction object that finds values of variables vars that minimize the convex objective function f subject to convex constraints cons with parameters pars.
ParametricConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned by the ParametricFunction object.
ParametricFunction
ParametricFunction[pars,…] represents a function that computes a solution when evaluated with numerical values for the parameters pars.
ParametricNDSolve
ParametricNDSolve[eqns,u,{x,xmin,xmax},pars] finds a numerical solution to the ordinary differential equations eqns for the function u with the independent variable x in the range xmin to xmax with parameters pars.
ParametricNDSolve[eqns,u,{x,xmin,xmax},{y,ymin,ymax},pars] solves the partial differential equations eqns over a rectangular region.
ParametricNDSolve[eqns,u,{x,y}∈Ω,pars] solves the partial differential equations eqns over the region Ω.
ParametricNDSolve[eqns,u,{t,tmin,tmax},{x,y}∈Ω,pars] solves the time-dependent partial differential equations eqns over the region Ω.
ParametricNDSolve[eqns,{u1,u2,…},…] solves for the functions ui.
ParametricNDSolveValue
ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},pars] gives the value of expr with functions determined by a numerical solution to the ordinary differential equations eqns with the independent variable x in the range xmin to xmax with parameters pars.
ParametricNDSolveValue[eqns,expr,{x,xmin,xmax},{y,ymin,ymax},pars] solves the partial differential equations eqns over a rectangular region.
ParametricNDSolveValue[eqns,expr,{x,y}∈Ω,pars] solves the partial differential equations eqns over the region Ω.
ParametricNDSolveValue[eqns,expr,{t,tmin,tmax},{x,y}∈Ω,pars] solves the time-dependent partial differential equations eqns over the region Ω.
ParametricPlot
ParametricPlot[{fx,fy},{u,umin,umax}] generates a parametric plot of a curve with x and y coordinates fx and fy as a function of u.
ParametricPlot[{{fx,fy},{gx,gy},…},{u,umin,umax}] plots several parametric curves.
ParametricPlot[{fx,fy},{u,umin,umax},{v,vmin,vmax}] plots a parametric region.
ParametricPlot[{{fx,fy},{gx,gy},…},{u,umin,umax},{v,vmin,vmax}] plots several parametric regions.
ParametricPlot[{…,w[{fx,fy}],…},…] plots the curve {fx,fy} with features defined by the symbolic wrapper w.
ParametricPlot[…,{u,v}∈reg] takes parameters {u,v} to be in the geometric region reg.
ParametricPlot3D
ParametricPlot3D[{fx,fy,fz},{u,umin,umax}] produces a three-dimensional space curve parametrized by a variable u which runs from umin to umax.
ParametricPlot3D[{fx,fy,fz},{u,umin,umax},{v,vmin,vmax}] produces a three-dimensional surface parametrized by u and v.
ParametricPlot3D[{{fx,fy,fz},{gx,gy,gz},…},…] plots several objects together.
ParametricPlot3D[…,{u,v}∈reg] takes parameters {u,v} to be in the geometric region reg.
ParametricRampLayer
ParametricRampLayer[] represents a net layer that computes a leaky ReLU activation with a slope that can be learned.
ParametricRampLayer[levels] specifies the levels on which each dimension has a specific slope.
ParametricRegion
ParametricRegion[{f1,…,fn},{u1,…,um}] represents a region in n given by the points {f1,…,fn} for parameters ui∈.
ParametricRegion[{f1,…,fn},{{u1,a1,b1},…}] constrains parameters to an interval a1≤u1≤b1 etc.
ParametricRegion[{{f1,…,fn},cond},…] constrains parameters to satisfy the condition cond.
ParentCell
ParentCell[obj] returns the CellObject that contains obj.
ParentDirectory
ParentDirectory[] gives the parent of the current working directory.
ParentDirectory["dir"] gives the parent of the directory dir.
ParentDirectory["dir",n] gives the directory n levels up from dir.
Parenthesize
Parenthesize[ expr, fmt, prec, group] or Parenthesize[ expr, fmt, {prec, group}] will represent expr in format fmt and parenthesize it if necessary when it is an operand to an operator of the given precedence and grouping.
Parenthesize[expr,fmt,head] infers prec and group from the operator, if any, used by the symbol head in fmt.
Parenthesize[expr,fmt,prec,group,side] or Parenthesize[expr,fmt,head,side] assume expr appears on the specified side of the operator.
ParetoDistribution
ParetoDistribution[k,α] represents a Pareto distribution with minimum value parameter k and shape parameter α.
ParetoDistribution[k,α,μ] represents a Pareto type II distribution with location parameter μ.
ParetoDistribution[k,α,γ,μ] represents a Pareto type IV distribution with shape parameter γ.
ParetoPickandsDistribution
ParetoPickandsDistribution[μ,σ,ξ] gives a Pareto–Pickands distribution with location parameter μ, scale parameter σ and shape parameter ξ.
ParetoPickandsDistribution[ξ] gives the standard Pareto–Pickands distribution with zero location and unit scale parameters.
ParkData
ParkData[entity,property] gives the value of the specified property for the park entity.
ParkData[{entity1,entity2,…},property] gives a list of property values for the specified park entities.
ParkData[entity,property,annotation] gives the specified annotation associated with the given property.
Part
expr[[i]] or Part[expr,i] gives the ith part of expr.
expr[[-i]] counts from the end.
expr[[i,j,…]] or Part[expr,i,j,…] is equivalent to expr[[i]][[j]]….
expr[[{i1,i2,…}]] gives a list of the parts i1, i2, … of expr.
expr[[m;;n]] gives parts m through n.
expr[[m;;n;;s]] gives parts m through n in steps of s.
expr[["key"]] gives the value associated with the key "key" in an association expr.
expr[[Key[k]]] gives the value associated with an arbitrary key k in the association expr.
PartBehavior
PartBehavior is an option to Query and related functions that specifies how nonexistent parts should be resolved.
PartialCorrelationFunction
PartialCorrelationFunction[data,hspec] estimates the partial correlation function at lags hspec from data.
PartialCorrelationFunction[tproc,hspec] represents the partial correlation function at lags hspec for the time series process tproc.
ParticleAcceleratorData
ParticleAcceleratorData[entity,property] gives the value of the specified property for the particle accelerator entity.
ParticleAcceleratorData[{entity1,entity2,…},property] gives a list of property values for the specified particle accelerator entities.
ParticleAcceleratorData[entity,property,annotation] gives the specified annotation associated with the given property.
ParticleData
ParticleData[name,"property"] gives the specified property for a subatomic particle or family of particles with the specified name.
ParticleData[{name,q},"property"] gives the specified property for a version of the particle with charge q.
Partition
Partition[list,n] partitions list into nonoverlapping sublists of length n.
Partition[list,n,d] generates sublists with offset d.
Partition[list,{n1,n2,…}] partitions a nested list into blocks of size n1×n2×….
Partition[list,{n1,n2,…},{d1,d2,…}] uses offset di at level i in list.
Partition[list,n,d,{kL,kR}] specifies that the first element of list should appear at position kL in the first sublist, and the last element of list should appear at or after position kR in the last sublist. If additional elements are needed, Partition fills them in by treating list as cyclic.
Partition[list,n,d,{kL,kR},x] pads if necessary by repeating the element x.
Partition[list,n,d,{kL,kR},{x1,x2,…}] pads if necessary by cyclically repeating the elements xi.
Partition[list,n,d,{kL,kR},{}] uses no padding, and so can yield sublists of different lengths.
Partition[list,nlist,dlist,{klistL,klistR},padlist] specifies alignments and padding in a nested list.
PartitionGranularity
PartitionGranularity is an option for audio analysis functions that specifies the partitioning of the audio.
PartitionsP
PartitionsP[n] gives the number p(n) of unrestricted partitions of the integer n.
PartitionsQ
PartitionsQ[n] gives the number q(n) of partitions of the integer n into distinct parts.
PartLayer
PartLayer[i] represents a net layer that gives the ith part of the input.
PartLayer[i;;j] gives parts i through j.
PartLayer[i;;j;;k] gives parts i through j in steps of k.
PartLayer[{spec1,spec2,…}] takes part speci at level i in the input.
PartOfSpeech
PartOfSpeech["word"] returns the possible parts of speech for the specified word.
ParzenWindow
ParzenWindow[x] represents a Parzen window function of x.
PascalDistribution
PascalDistribution[n,p] represents a Pascal distribution with parameters n and p.
EventHandler
EventHandler[expr,{event1:>action1,event2:>action2,…}] displays as expr, evaluating actioni whenever "eventi" occurs in connection with expr.
PassEventsDown
PassEventsDown is an option to EventHandler which specifies whether events handled by a particular event handler should be passed down to event handlers nested inside.
PassEventsUp
PassEventsUp is an option to EventHandler that specifies whether events handled by a particular event handler should be passed up to event handlers in outer expressions.
Paste
Paste[expr] pastes expr at the current insertion point in the input notebook.
Paste[notebook,expr] pastes expr to the specified notebook.
Paste[] pastes the contents of the system clipboard in the input notebook.
Paste[notebook,Automatic] pastes the contents of the system clipboard to notebook.
Path
Path is an option for Get and related functions which gives a list of directories to search in attempting to find an external file.
PathGraph
PathGraph[{v1,v2,…}] yields a path with vertices vi and edges between vi and vi+ 1 .
PathGraph[{e1,e2,…}] yields a path with edges ej.
PathGraph[{v1,v2,…},{e1,e2,…}] yields a path with vertices vi and edges ej.
PathGraph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a path with vertex and edge properties defined by the symbolic wrappers wk.
PathGraph[{vi->vj,…}] uses rules vi->vj to specify a path.
PathGraphQ
PathGraphQ[g] yields True if the graph g is a path and False otherwise.
Pattern
sym:obj or Pattern[sym,obj] represents the pattern object obj, assigned the name sym.
PatternFilling
PatternFilling[obj] is a two-dimensional graphics directive specifying that obj should be used to fill faces of polygons and other filled graphics objects.
PatternFilling["name"] uses the specified pattern "name".
PatternFilling[obj,size] specifies the size of the object obj.
PatternFilling[obj,size,{dx,dy}] moves the object obj by the offset {dx,dy}.
PatternSequence
PatternSequence[p1,p2,…] is a pattern object that represents a sequence of arguments matching p1, p2, ….
PatternTest
p?test is a pattern object that stands for any expression that matches p, and on which the application of test gives True.
PauliMatrix
PauliMatrix[k] gives the kth Pauli spin matrix σk.
PaulWavelet
PaulWavelet[] represents a Paul wavelet of order 4.
PaulWavelet[n] represents a Paul wavelet of order n.
Pause
Pause[n] pauses for at least n seconds.
PDF
PDF[dist,x] gives the probability density function for the distribution dist evaluated at x.
PDF[dist,{x1,x2,…}] gives the multivariate probability density function for a distribution dist evaluated at {x1,x2,…}.
PDF[dist] gives the PDF as a pure function.
PeakDetect
PeakDetect[list] gives a binary list in which 1s correspond to peak positions in list.
PeakDetect[list,σ] detects peaks that survive Gaussian blurring up to scale σ.
PeakDetect[list,σ,s] detects peaks with minimum sharpness s.
PeakDetect[list,σ,s,t] detects only peaks with values greater than t.
PeakDetect[list,σ,{s,σs},{t,σt}] uses different scales for thresholding sharpness and value.
PeanoCurve
PeanoCurve[n] gives the line segments representing the nth-step Peano curve.
PearsonChiSquareTest
PearsonChiSquareTest[data] tests whether data is normally distributed using the Pearson χ2 test.
PearsonChiSquareTest[data,dist] tests whether data is distributed according to dist using the Pearson χ2 test.
PearsonChiSquareTest[data,dist,"property"] returns the value of "property".
PearsonCorrelationTest
PearsonCorrelationTest[v1,v2] tests whether the vectors v1 and v2 are linearly independent.
PearsonCorrelationTest[…,"property"] returns the value of "property".
PearsonDistribution
PearsonDistribution[a1,a0,b2,b1,b0] represents a distribution of the Pearson family with parameters a1, a0, b2, b1, and b0.
PearsonDistribution[type,a1,a0,b2,b1,b0] represents a Pearson distribution of given type.
PercentForm
PercentForm[expr] prints with numbers in expr given as percentages.
PercentForm[expr,n] prints with approximate real numbers in expr given as percentages to n-digit precision.
PerfectNumber
PerfectNumber[n] gives the nth perfect number.
PerfectNumberQ
PerfectNumberQ[n] returns True if n is a perfect number, and False otherwise.
PerformanceGoal
PerformanceGoal is an option for various algorithmic and presentational functions that specifies what aspect of performance to try to optimize with Automatic settings for options.
Perimeter
Perimeter[reg] gives the perimeter of the two-dimensional region reg.
Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax}] gives the perimeter of the parametrized region whose Cartesian coordinates xi are functions of s and t.
Perimeter[{x1,x2},{s,smin,smax},{t,tmin,tmax},chart] interprets the xi as coordinates in the specified coordinate chart.
PeriodicBoundaryCondition
PeriodicBoundaryCondition[u[x1,…],pred,f] represents a periodic boundary condition =u(xtarget)=u(f(xtarget)) for all xtarget on the boundary of the region given to NDSolve where pred is True.
PeriodicBoundaryCondition[a+b u[x1,…],pred,f] represents a generalized periodic boundary condition a+b u(xtarget)=u(f(xtarget)).
Periodogram
Periodogram[list] plots the squared magnitude of the discrete Fourier transform (power spectrum) of list.
Periodogram[list,n] plots the mean of power spectra of non-overlapping partitions of length n.
Periodogram[list,n,d] uses partitions with offset d.
Periodogram[list,n,d,wfun] applies a smoothing window wfun to each partition.
Periodogram[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
Periodogram[{list1,list2,…},n,d,wfun,m] plots power spectra of several lists.
Periodogram[audio,…] plots the power spectrum of audio.
Periodogram[video,…] plots the power spectrum of the first audio track in video.
Periodogram[{input1,input2,…},…] plots the power spectra of all inputi.
PeriodogramArray
PeriodogramArray[list] returns the squared magnitude of the discrete Fourier transform (power spectrum) of list.
PeriodogramArray[list,n] averages the power spectra of non-overlapping partitions of length n.
PeriodogramArray[list,n,d] uses partitions with offset d.
PeriodogramArray[list,n,d,wfun] applies a smoothing window wfun to each partition.
PeriodogramArray[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
PeriodogramArray[image,…] returns the squared power spectrum of image.
PeriodogramArray[audio,…] returns the squared power spectrum of audio.
PeriodogramArray[video,…] returns the squared power spectrum of the first audio track in video.
Permanent
Permanent[m] gives the permanent of the square matrix m.
PermissionsGroup
PermissionsGroup["name"] represents a permissions group with the specified name, owned by the current user.
PermissionsGroup[user,"name"] represents a permissions group owned by the specified user.
PermissionsGroupMemberQ
PermissionsGroupMemberQ[group,user] returns True if user is a member of the permissions group group, and False otherwise.
PermissionsGroups
PermissionsGroups[] gives a list of permissions groups belonging to the current user.
PermissionsKeys
PermissionsKeys[] gives a list of all valid permissions keys created by the currently authenticated user.
PermutationCycles
PermutationCycles[perm] gives a disjoint cycle representation of permutation perm.
PermutationCyclesQ
PermutationCyclesQ[expr] returns True if expr is a permutation in disjoint cyclic form, and False otherwise.
PermutationGroup
PermutationGroup[{perm1,…,permn}] represents the group generated by multiplication of the permutations perm1,…,permn.
PermutationLength
PermutationLength[perm] returns the number of integers moved by the permutation perm.
PermutationList
PermutationList[perm] returns a permutation list representation of permutation perm.
PermutationList[perm,len] returns a permutation list of length len.
PermutationListQ
PermutationListQ[expr] returns True if expr is a valid permutation list and False otherwise.
PermutationMax
PermutationMax[perm] returns the largest integer moved by the permutation perm.
PermutationMin
PermutationMin[perm] returns the smallest integer moved by the permutation perm.
PermutationOrder
PermutationOrder[perm] gives the order of permutation perm.
PermutationPower
PermutationPower[perm,n] gives the nth permutation power of the permutation perm.
PermutationProduct
PermutationProduct[a,b,c] gives the product of permutations a, b, c.
PermutationReplace
PermutationReplace[expr,perm] replaces each part in expr by its image under the permutation perm.
PermutationReplace[expr,gr] returns the list of images of expr under all elements of the permutation group gr.
Permutations
Permutations[list] generates a list of all possible permutations of the elements in list.
Permutations[list,n] gives all permutations containing at most n elements.
Permutations[list,{n}] gives all permutations containing exactly n elements.
PermutationSupport
PermutationSupport[perm] returns the support of the permutation perm.
Permute
Permute[expr,perm] permutes the positions of the elements of expr according to the permutation perm.
Permute[expr,gr] returns the list of permuted forms of expr under the elements of the permutation group gr.
PeronaMalikFilter
PeronaMalikFilter[image] applies a Perona–Malik diffusion filter to image.
PeronaMalikFilter[image,t] specifies the amount of diffusion time t to be applied.
PeronaMalikFilter[image,t,k] uses a conductance parameter k.
PeronaMalikFilter[image,t,k,σ] applies a Gaussian regularization of width σ to the image gradient in the conductance function.
PerpendicularBisector
PerpendicularBisector[{p1,p2}] gives the perpendicular bisector of the line segment connecting p1 and p2.
PerpendicularBisector[Line[{p1,p2}]] gives the perpendicular bisector of a line segment.
PersistenceLocation
PersistenceLocation["type"] represents a persistence location of the given type.
PersistenceLocation["type",base] includes the base address for a location type that allows multiple locations.
PersistenceTime
PersistenceTime is an option for various functions that specifies when a persistent value should be treated as expired.
PersistentObject
PersistentObject["name",loc] represents a persistent object stored at persistence location loc.
PersistentObjects
PersistentObjects[] gives all persistent objects in all locations in $PersistencePath.
PersistentObjects[patt] gives all persistent objects whose names match the string pattern patt.
PersistentObjects[patt,loc] gives all matching persistent objects in persistence location loc.
PersistentObjects[patt,{loc1,…}] gives all matching persistent objects in all the loci.
PersistentSymbol
PersistentSymbol["name"] represents the persistent symbol associated with the key "name".
PersistentSymbol["name",loc] represents the persistent symbol associated with name stored in persistence location loc.
PersistentSymbol["name",{loc1,…}] represents the persistent symbol associated with name at the first of the locations loci at which it occurs.
PersistentValue
PersistentValue["name"] represents the persistent value associated with the key "name".
PersistentValue["name",loc] represents the persistent value associated with name stored in persistence location loc.
PersistentValue["name",{loc1,…}] represents the persistent value associated with name at the first of the locations loci at which it occurs.
PersonData
PersonData[entity,property] gives the value of the specified property for the person entity.
PersonData[{entity1,entity2,…},property] gives a list of property values for the specified person entities.
PersonData[entity,property,annotation] gives the specified annotation associated with the given property.
PERTDistribution
PERTDistribution[{min,max},c] represents a PERT distribution with range min to max and mode at c.
PERTDistribution[{min,max},c,λ] represents a modified PERT distribution with shape parameter λ.
PetersenGraph
PetersenGraph[n,k] gives the generalized Petersen graph Pn, k.
PhaseMargins
PhaseMargins[lsys] gives the phase margins of the linear time-invariant system lsys.
PhaseRange
PhaseRange is an option to BodePlot and NicholsPlot that specifies the phase range.
Pi
Pi is π, with numerical value ≃3.14159.
Pick
Pick[list,sel] picks out those elements of list for which the corresponding element of sel is True.
Pick[list,sel,patt] picks out those elements of list for which the corresponding element of sel matches patt.
PIDData
PIDData[…] represents PID data generated by PIDTune function.
PIDDerivativeFilter
PIDDerivativeFilter is an option to PIDTune that controls the filtering used for derivative terms.
PIDFeedforward
PIDFeedforward is an option to PIDTune that controls the reference weights used for the feedforward filter.
PIDTune
PIDTune[sys] gives a feedback PID controller for the system sys.
PIDTune[sys,"carch"] gives a controller of architecture "carch" ("P", "PI", "PID", etc).
PIDTune[sys,{"carch","trule"}] gives a controller using the tuning rule "trule".
PIDTune[sys,…,"prop"] returns the value for the property "prop".
Piecewise
Piecewise[{{val1,cond1},{val2,cond2},…}] represents a piecewise function with values vali in the regions defined by the conditions condi.
Piecewise[{{val1,cond1},…},val] uses default value val if none of the condi apply. The default for val is 0.
PiecewiseExpand
PiecewiseExpand[expr] expands nested piecewise functions in expr to give a single piecewise function.
PiecewiseExpand[expr,assum] expands piecewise functions using assumptions.
PiecewiseExpand[expr,assum,dom] does the expansion over the domain dom.
PieChart
PieChart[{y1,y2,…,yn}] makes a pie chart with sector angle proportional to y1, y2, ….
PieChart[{…,wi[yi,…],…,wj[yj,…],…}] makes a pie chart with sector features defined by the symbolic wrappers wk.
PieChart[{data1,data2,…}] makes a pie chart from multiple datasets datai.
PieChart3D
PieChart3D[{y1,y2,…}] makes a 3D pie chart with sector angle proportional to y1, y2, … .
PieChart3D[{…,wi[yi,…],…,wj[yj,…],…}] makes a 3D pie chart with sector features defined by the symbolic wrappers wk.
PieChart3D[{data1,data2,…}] makes a 3D pie chart from multiple datasets datai.
PillaiTrace
PillaiTrace[m1,m2] gives Pillai's trace for the matrices m1 and m2.
PillaiTraceTest
PillaiTraceTest[m1,m2] tests whether the matrices m1 and m2 are independent.
PillaiTraceTest[…,"property"] returns the value of "property".
PingTime
PingTime[host] gives the round-trip ping time for the specified network host.
PingTime[host,n] gives a list of times for n successive pings.
Pink
Pink represents the color pink in graphics or style specifications.
PitchRecognize
PitchRecognize[audio] recognizes the main pitch in audio, returning it as a TimeSeries object.
PitchRecognize[audio,spec] returns the main pitch processed according to the specified spec.
PitchRecognize[video,…] recognizes the main pitch in the first audio track in video.
Pivoting
Pivoting is an option to certain matrix decomposition functions. With Pivoting -> False, no pivoting is done. With Pivoting -> True, column pivoting is carried out and the list of matrices returned is augmented by the appropriate permutation matrix.
PixelValue
PixelValue[image,ppos] gives the pixel value of image at position pos.
PixelValue[image,ppos,"type"] gives the pixel value converted to the specified type.
PixelValuePositions
PixelValuePositions[image,val] returns a list of pixel positions in image that exactly match the value val.
PixelValuePositions[image,val,d] returns all pixel positions that have values within a distance d from val.
Placed
Placed[expr,pos] represents an expression expr placed at relative position pos in a chart or other display.
Placed[{e1,e2,…},pos] places each of the ei at a relative position specified by pos.
Placed[{e1,e2,…},pos,f] applies the function f to each of the ei before displaying it.
Placeholder
Placeholder[name] represents a placeholder labeled with name that indicates a place to type.
Placeholder[] gives the empty placeholder .
PlaceholderLayer
PlaceholderLayer[] represents a net layer whose operation is undefined.
PlaceholderLayer["tag",assoc] indicates a tag and information given by the association assoc.
PlaceholderReplace
PlaceholderReplace is an option to Paste that determines whether to replace a selection placeholder with the selected contents.
Plain
Plain represents a font that is not bold, italic, or underlined.
PlanarAngle
PlanarAngle[p->{q1,q2}] gives the angle between the half‐lines from p through q1 and q2.
PlanarAngle[{q1,p,q2}] gives the angle at p formed by the triangle with vertex points p, q1 and q2.
PlanarAngle[…,"spec"] gives the angle specified by "spec".
PlanarFaceList
PlanarFaceList[g] gives the list of faces of the planar graph g.
PlanarGraph
PlanarGraph[{e1,e2,…}] yields a planar graph with edges ej.
PlanarGraph[{v1,v2,…},{e1,e2,…}] yields a planar graph with vertices vi and edges ej.
PlanarGraph[{…,wi[vi],…},{…,wj[ej],…}] yields a planar graph with vertex and edge properties defined by the symbolic wrappers wk.
PlanarGraph[{vi->vj,…}] uses rules vi->vj to specify a planar graph.
PlanarGraphQ
PlanarGraphQ[g] yields True if g is a planar graph and False otherwise.
PlanckRadiationLaw
PlanckRadiationLaw[temperature,λ] returns the spectral radiance for the specified temperature and wavelength λ.
PlanckRadiationLaw[temperature,f] returns the spectral radiance for the specified temperature and frequency f.
PlanckRadiationLaw[temperature,property] returns the value of the property for the specified temperature.
PlanckRadiationLaw[temperature,{λ1,λ2}] returns the integrated result of the spectral radiance over the wavelength range λ1 to λ2.
PlanckRadiationLaw[temperature,{f1,f2}] returns the integrated result of the spectral radiance over the frequency range f1 to f2.
PlaneCurveData
PlaneCurveData[entity,property] gives the value of the specified property for the plane curve entity.
PlaneCurveData[{entity1,entity2,…},property] gives a list of property values for the specified plane curve entities.
PlaneCurveData[entity,property,annotation] gives the specified annotation associated with the given property.
PlanetaryMoonData
PlanetaryMoonData[entity,property] gives the value of the specified property for the moon entity of a planet or minor planet.
PlanetaryMoonData[{entity1,entity2,…},property] gives a list of property values for the specified moon entities.
PlanetaryMoonData[entity,property,annotation] gives the specified annotation associated with the property.
PlanetData
PlanetData[entity,property] gives the value of the specified property for the planet entity.
PlanetData[{entity1,entity2,…},property] gives a list of property values for the specified planet entities.
PlanetData[entity,property,annotation] gives the specified annotation associated with the property.
PlantData
PlantData[entity,property] gives the value of the specified property for the plant entity.
PlantData[{entity1,entity2,…},property] gives a list of property values for the specified plant entities.
PlantData[entity,property,annotation] gives the specified annotation associated with the property.
Play
Play[f,{t,tmin,tmax}] creates an object that plays as a sound whose amplitude is given by f as a function of time t in seconds between tmin and tmax.
PlayRange
PlayRange is an option for Play and related functions which specifies what range of sound amplitude levels should be included.
Plot
Plot[f,{x,xmin,xmax}] generates a plot of f as a function of x from xmin to xmax.
Plot[{f1,f2,…},{x,xmin,xmax}] plots several functions fi.
Plot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
Plot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
Plot3D
Plot3D[f,{x,xmin,xmax},{y,ymin,ymax}] generates a three-dimensional plot of f as a function of x and y.
Plot3D[{f1,f2,…},{x,xmin,xmax},{y,ymin,ymax}] plots several functions.
Plot3D[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
Plot3D[…,{x,y}∈reg] takes variables {x,y} to be in the geometric region reg.
PlotDivision
PlotDivision is an option for Plot that specifies the maximum amount of subdivision to be used.
PlotJoined
PlotJoined is an option for ListPlot that specifies whether the points plotted should be joined by a line.
PlotLabel
PlotLabel is an option for graphics functions that specifies an overall label for a plot.
PlotLabels
PlotLabels is an option for visualization functions that specifies what labels to use for each data source.
PlotLayout
PlotLayout is an option for plotting functions that specifies the layout of multiple components in a plot.
PlotLegends
PlotLegends is an option for plot functions that specifies what legends to use.
PlotMarkers
PlotMarkers is an option for graphics functions like ListPlot and ListLinePlot that specifies what markers to draw at the points plotted.
PlotPoints
PlotPoints is an option for plotting functions that specifies how many initial sample points to use.
PlotRange
PlotRange is an option for graphics functions that specifies what range of coordinates to include in a plot.
PlotRangeClipping
PlotRangeClipping is an option for graphics functions that specifies whether graphics objects should be clipped at the edge of the region defined by PlotRange, or should be allowed to extend to the actual edge of the image.
PlotRangePadding
PlotRangePadding is an option for graphics functions that specifies how much further axes etc. should extend beyond the range of coordinates specified by PlotRange.
PlotRegion
PlotRegion is an option for graphics functions that specifies what region of the final display area a plot should fill.
PlotStyle
PlotStyle is an option for plotting and related functions that specifies styles in which objects are to be drawn.
PlotTheme
PlotTheme is an option for plotting and related functions that specifies an overall theme for visualization elements and styles.
Pluralize
Pluralize["noun"] gives the plural form of the English word "noun".
Pluralize["noun",n] gives the inflected form of "noun" for n instances.
Pluralize[{"singular","plural"},n] inflects using the specified forms.
Pluralize[spec,list] uses the length of list to determine the inflection to use.
Plus
x+y+z represents a sum of terms.
PlusMinus
PlusMinus[x] displays as ±x.
PlusMinus[x,y,…] displays as x±y±….
Pochhammer
Pochhammer[a,n] gives the Pochhammer symbol (a)n.
PodStates
PodStates is an option for WolframAlpha that determines information about the states of the pods.
PodWidth
PodWidth is an option for WolframAlpha that determines the width parameters of the content returned by the Wolfram|Alpha API.
Point
Point[p] is a graphics and geometry primitive that represents a point at p.
Point[{p1,p2,…}] represents a collection of points.
PointCountDistribution
PointCountDistribution[pproc,reg] represents the distribution of point counts for the point process pproc in the region reg.
PointCountDistribution[pproc,{reg1,…,regn}] represents the joint distribution of point counts in regions regi.
PointDensity
PointDensity[pdata] estimates the point density function μ(x) from point data pdata.
PointDensity[pdata,pmethod] estimates the point density function μ(x) with the partition method pmethod.
PointDensity[bdata,…] estimates the point density function μ(x) from binned data bdata.
PointDensity[pproc,…] computes the density function μ(x) for point process pproc.
PointDensityFunction
PointDensityFunction[…] represents a function whose values give the density at a given location.
PointFigureChart
PointFigureChart[{{date1,p1},{date2,p2},…}] makes a point and figure chart with prices pi at date datei.
PointFigureChart[{"name",daterange}] makes a point and figure chart of closing prices for the financial entity "name" over the date range daterange.
PointFigureChart[{…},s,n] makes a point and figure chart with point and figure height s and n reversals.
PointLegend
PointLegend[{col1,…},{lbl1,…}] generates a legend that associates points of colors coli with labels lbli.
PointLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.
PointLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.
PointLight
PointLight[col,pt] is a three-dimensional graphics directive that specifies the point light of color col at position pt to use in coloring 3D surfaces.
PointLight[col,pt,att] uses the point light with geometric attenuation att.
PointProcessEstimator
PointProcessEstimator[] is an option to EstimatedPointProcess and FindPointProcessParameters that specifies what point process parameter estimator to use.
PointProcessFitTest
PointProcessFitTest[pdata] tests whether the point collection pdata could be modeled by a Poisson point process.
PointProcessFitTest[pdata,pproc] tests whether the point collection could be modeled by the point process pproc.
PointProcessFitTest[pdata,pproc,"property"] returns the value of "property".
PointProcessParameterAssumptions
PointProcessParameterAssumptions[proc] gives a logical expression for assumptions on parameters in the point process proc.
PointProcessParameterQ
PointProcessParameterQ[proc] yields True if proc is a valid random point process, and yields False otherwise.
PointSize
PointSize[d] is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with diameter d. The diameter d is given as a fraction of the total width of the plot.
PointStatisticFunction
PointStatisticFunction[…] represents a function whose values give the statistic of a points collection pdata at a supplied radius.
PointValuePlot
PointValuePlot[{pt1->val1,pt2->val2,…}] plots the points pti styled according to the values vali.
PointValuePlot[pts->vals] uses a collection of points pti from pts with corresponding values vali from val.
PointValuePlot[…,enc] uses the visual encoding enc to represent the values vali in the plot.
PointValuePlot[data,…] plots the locations and values from data.
PoissonConsulDistribution
PoissonConsulDistribution[μ,λ] represents a Poisson–Consul distribution with parameters μ and λ.
PoissonDistribution
PoissonDistribution[μ] represents a Poisson distribution with mean μ.
PoissonPDEComponent
PoissonPDEComponent[vars,pars] yields a Poisson PDE term ∇2{x1,…,xn}u-f with model variables vars and model parameters pars.
PoissonProcess
PoissonProcess[μ] represents a Poisson process with rate μ.
PoissonWindow
PoissonWindow[x] represents a Poisson window function of x.
PoissonWindow[x,α] uses the parameter α.
PolarAxes
PolarAxes is an option for sector charts and polar plots that specifies whether polar axes should be drawn.
PolarAxesOrigin
PolarAxesOrigin is an option for sector charts and polar plots that specifies where polar axes should be drawn.
PolarGridLines
PolarGridLines is an option for sector charts and polar plots that specifies polar grid lines.
PolarPlot
PolarPlot[r,{θ,θmin,θmax}] generates a polar plot of a curve with radius r as a function of angle θ.
PolarPlot[{r1,r2,…},{θ,θmin,θmax}] makes a polar plot of curves with radius functions r1, r2, ….
PolarTicks
PolarTicks is an option for sector charts and polar plots that specifies tick marks for polar axes.
PoleZeroMarkers
PoleZeroMarkers is an option for RootLocusPlot that specifies the markers to be drawn on the complex plane at the open-loop poles, closed-loop poles, and open-loop zeros.
PolyaAeppliDistribution
PolyaAeppliDistribution[θ,p] represents a Pólya–Aeppli distribution with shape parameters θ and p.
PolyGamma
PolyGamma[z] gives the digamma function ψ(z).
PolyGamma[n,z] gives the nth derivative of the digamma function ψ(n)(z).
Polygon
Polygon[{p1,…,pn}] represents a filled polygon with points pi.
Polygon[{p1,…,pn}->{{q1,…,qm},…}] represents a polygon with holes {q1,…,qm},….
Polygon[{poly1,poly2,…}] represents a collection of polygons polyi.
Polygon[{p1,…,pn},data] represents a polygon in which coordinates given as integers i in data are taken to be pi.
PolygonalNumber
PolygonalNumber[n] gives the nth triangular number Tn.
PolygonalNumber[r,n] gives the nth r-gonal number Pn r.
PolygonAngle
PolygonAngle[poly] gives a list of angles at the vertex points of poly.
PolygonAngle[poly,p] gives the angle at the vertex point p of a polygon poly.
PolygonAngle[poly,i] gives the angle at the point pi of poly in canonical form Polygon[{p1,…,pn},data].
PolygonAngle[…,"spec"] gives the angle specified by "spec".
PolygonCoordinates
PolygonCoordinates[poly] gives a list of coordinates in the polygon poly.
PolygonDecomposition
PolygonDecomposition[poly] decomposes the polygon poly into a disjoint union of simpler polygons.
PolygonDecomposition[poly,"type"] decomposes into polygons of the specified "type".
PolygonIntersections
PolygonIntersections is an option for Graphics3D which specifies whether intersecting polygons should be left unchanged.
Polyhedron
Polyhedron[{f1,…,fn}] represents a filled polyhedron inside the closed surfaces with polygon faces fi.
Polyhedron[{f1,…,fn}->{{g1,…,gm},…}] represents a polyhedron with voids {g1,…,gm},….
Polyhedron[{poly1,poly2,…}] represents a collection of polyhedra polyi.
Polyhedron[{p1,…,pn},data] represents a polyhedron in which coordinates given as integers i in data are taken to be pi.
PolyhedronAngle
PolyhedronAngle[poly,p] gives the solid angle at the point p and spanned by edges with common point p.
PolyhedronAngle[poly,e] gives the dihedral angle between the two faces with common edge e.
PolyhedronCoordinates
PolyhedronCoordinates[poly] gives a list of coordinates in the polyhedron poly.
PolyhedronData
PolyhedronData[poly,"property"] gives the value of the specified property for the polyhedron named poly.
PolyhedronData[poly] gives an image of the polyhedron named poly.
PolyhedronData["class"] gives a list of the polyhedra in the specified class.
PolyhedronDecomposition
PolyhedronDecomposition[poly] decomposes the polyhedron poly into a union of simpler polyhedra.
PolyhedronGenus
PolyhedronGenus[poly] gives the genus of the polyhedron poly.
PolyLog
PolyLog[n,z] gives the polylogarithm function Lin(z).
PolyLog[n,p,z] gives the Nielsen generalized polylogarithm function Sn,p(z).
PolynomialExpressionQ
PolynomialExpressionQ[expr,x] gives True if expr is structurally a polynomial expression in x, and False otherwise.
PolynomialExpressionQ[expr,{x,y,…}] gives True if expr is structurally a polynomial expression in x,y,…, and False otherwise.
PolynomialExpressionQ[expr,{x,y,…},test] gives True if expr is structurally a polynomial expression in x,y,… with coefficients satisfying test, and False otherwise.
PolynomialExtendedGCD
PolynomialExtendedGCD[poly1,poly2,x] gives the extended GCD of poly1 and poly2 treated as univariate polynomials in x.
PolynomialExtendedGCD[poly1,poly2,x,Modulus->p] gives the extended GCD over the integers modulo the prime p.
PolynomialGCD
PolynomialGCD[poly1,poly2,…] gives the greatest common divisor of the polynomials polyi.
PolynomialGCD[poly1,poly2,…,Modulus->p] evaluates the GCD modulo the prime p.
PolynomialLCM
PolynomialLCM[poly1,poly2,…] gives the least common multiple of the polynomials polyi.
PolynomialLCM[poly1,poly2,…,Modulus->p] evaluates the LCM modulo the prime p.
PolynomialMod
PolynomialMod[poly,m] gives the polynomial poly reduced modulo m.
PolynomialMod[poly,{m1,m2,…}] reduces modulo all of the mi.
PolynomialQ
PolynomialQ[expr,var] yields True if expr is a polynomial in var, and yields False otherwise.
PolynomialQ[expr,{var1,…}] tests whether expr is a polynomial in the vari.
PolynomialQuotient
PolynomialQuotient[p,q,x] gives the quotient of p and q, treated as polynomials in x, with any remainder dropped.
PolynomialQuotientRemainder
PolynomialQuotientRemainder[p,q,x] gives a list of the quotient and remainder of p and q, treated as polynomials in x.
PolynomialReduce
PolynomialReduce[poly,{poly1,poly2,…},{x1,x2,…}] yields a list representing a reduction of poly in terms of the polyi. The list has the form {{a1,a2,…},b}, where b is minimal and a1 poly1+a2 poly2+…+b is exactly poly.
PolynomialRemainder
PolynomialRemainder[p,q,x] gives the remainder from dividing p by q, treated as polynomials in x.
PoolingLayer
PoolingLayer[sz] represents a pooling net layer using kernels of size sz.
PoolingLayer[{w}] represents a layer performing one-dimensional pooling with kernels of size w.
PoolingLayer[{h,w}] represents a layer performing two-dimensional pooling with kernels of size h×w.
PoolingLayer[{h,w,d}] represents a layer performing three-dimensional pooling with kernels of size h×w×d.
PoolingLayer[kernel,stride] represents a layer that uses stride as the step size between kernel applications.
PoolingLayer[kernel,opts] includes options for other pooling methods, padding and other parameters.
PopupWindow
PopupWindow[expr,contents] displays as expr, but pops up a window containing contents when clicked.
Position
Position[expr,pattern] gives a list of the positions at which objects matching pattern appear in expr.
Position[expr,pattern,levelspec] finds only objects that appear on levels specified by levelspec.
Position[expr,pattern,levelspec,n] gives the positions of the first n objects found.
Position[pattern] represents an operator form of Position that can be applied to an expression.
PositionIndex
PositionIndex[list] gives an association between unique elements in list and the positions at which they occur.
PositionIndex[assoc] gives an association whose keys are the distinct values in assoc, and whose values are lists of the keys with which they are associated.
Positive
Positive[x] gives True if x is a positive number.
PositiveDefiniteMatrixQ
PositiveDefiniteMatrixQ[m] gives True if m is explicitly positive definite, and False otherwise.
PositiveIntegers
PositiveIntegers represents the domain of strictly positive integers, as in x∈PositiveIntegers.
PositivelyOrientedPoints
PositivelyOrientedPoints[{p1,p2,p3,…,pd+1}] tests whether the sequence of points p1,p2,p3,…,pd+1 is positively oriented.
PositiveRationals
PositiveRationals represents the domain of strictly positive rational numbers, as in x∈PositiveRationals.
PositiveReals
PositiveReals represents the domain of strictly positive real numbers.
PositiveSemidefiniteMatrixQ
PositiveSemidefiniteMatrixQ[m] gives True if m is explicitly positive semidefinite, and False otherwise.
PossibleZeroQ
PossibleZeroQ[expr] gives True if basic symbolic and numerical methods suggest that expr has value zero, and gives False otherwise.
Postfix
Postfix[f[expr]] prints with f[expr] given in default postfix form: expr//f.
Postfix[f[expr],h] prints as exprh.
Power
x^y gives x to the power y.
PowerDistribution
PowerDistribution[k,a] represents a power distribution with domain parameter k and shape parameter a.
PowerExpand
PowerExpand[expr] expands all powers of products and powers.
PowerExpand[expr,{x1,x2,…}] expands only with respect to the variables xi.
PowerMod
PowerMod[a,b,m] gives ab mod m.
PowerMod[a,-1,m] finds the modular inverse of a modulo m.
PowerMod[a,1/r,m] finds a modular rth root of a.
PowerModList
PowerModList[a,s/r,m] gives a list of all x modulo m for which xr≡as mod m.
PowerRange
PowerRange[b] generates the list {1,10,100,…,max}, where max is the largest power of 10 that does not exceed b.
PowerRange[a,b] generates the list {a,10a,100a,…,max}, with successive elements increasing by factors of 10.
PowerRange[a,b,r] uses factors of r instead of 10.
PowerSpectralDensity
PowerSpectralDensity[data,ω] estimates the power spectral density for data.
PowerSpectralDensity[data,ω,sspec] estimates the power spectral density for data with smoothing specification sspec.
PowerSpectralDensity[tproc,ω] represents the power spectral density of a time series process tproc.
PowerSymmetricPolynomial
PowerSymmetricPolynomial[r] represents a formal power symmetric polynomial with exponent r.
PowerSymmetricPolynomial[{r1,r2,…}] represents a multivariate formal power symmetric polynomial with exponents r1, r2, ….
PowerSymmetricPolynomial[rspec,data] gives the power symmetric polynomial in data.
Precedence
Precedence[sym] returns the precedence of the output operator associated to the symbol sym.
Precedence[boxes,fmt] returns the precedence of the operator of used in the typeset expression boxes, assuming it was typeset in the format fmt.
PrecedenceForm
PrecedenceForm[expr,prec] prints with expr parenthesized as it would be if it contained an operator with precedence prec.
Precedes
Precedes[x,y,…] displays as x≺y≺….
PrecedesEqual
PrecedesEqual[x,y,…] displays as x⪯y⪯….
PrecedesSlantEqual
PrecedesSlantEqual[x,y,…] displays as x≼y≼….
PrecedesTilde
PrecedesTilde[x,y,…] displays as x≾y≾….
Precision
Precision[x] gives the effective number of digits of precision in the number x.
PrecisionGoal
PrecisionGoal is an option for various numerical operations which specifies how many effective digits of precision should be sought in the final result.
PreDecrement
--x decreases the value of x by 1, returning the new value of x.
Predict
Predict[{in1->out1,in2->out2,…}] generates a PredictorFunction that attempts to predict outi from the example ini.
Predict[data,input] attempts to predict the output associated with input from the training examples given.
Predict[data,input,prop] computes the specified property prop relative to the prediction.
PredictorFunction
PredictorFunction[…] represents a function generated by Predict that predicts numerical values from data.
PredictorInformation
PredictorInformation[predictor] generates a report giving information on the predictor function predictor.
PredictorInformation[predictor,prop] gives information for predictor associated with property prop.
PredictorMeasurements
PredictorMeasurements[predictor,testset,prop] gives measurements associated with the property prop when predictor is evaluated on testset.
PredictorMeasurements[predictor,testset] yields a measurement report that can be applied to any property.
PredictorMeasurements[data,…] use predictions data instead of a predictor.
PredictorMeasurements[…,{prop1,prop2,…}] gives properties prop1, prop2, etc.
PredictorMeasurementsObject
PredictorMeasurementsObject[…] represents an object generated by PredictorMeasurements that can be applied to properties.
PreemptProtect
PreemptProtect[expr] evaluates expr, without any interruption from preemptive evaluations.
PreferencesPath
PreferencesPath is a global option that specifies which directories are searched for user-specific settings when the Wolfram System is started.
Prefix
Prefix[f[expr]] prints with f[expr] given in default prefix form: f@expr.
Prefix[f[expr],h] prints as hexpr.
PreIncrement
++x increases the value of x by 1, returning the new value of x.
Prepend
Prepend[expr,elem] gives expr with elem prepended.
Prepend[elem] represents an operator form of Prepend that can be applied to an expression.
PrependLayer
PrependLayer[] represents a net layer that takes an input array and prepends another array to it.
PrependTo
PrependTo[x,elem] prepends elem to the value of x, and resets x to the result.
PreprocessingRules
PreprocessingRules is an option that specifies how the input should be preprocessed.
PreserveColor
PreserveColor is an option for ImageRestyle and related functions that specifies whether to preserve colors in the original image.
PreserveImageOptions
PreserveImageOptions is an option to graphics and related functions that specifies whether image size and certain other options should be preserved from the previous version of a graphic if the graphic is replaced by a new one in output.
PreviousDate
PreviousDate[gran] gives the previously occurring date of the specified granularity type gran.
PreviousDate[daytype] gives the previous day corresponding to the specified daytype.
PreviousDate[date,gran] gives the previous date of the given granularity relative to the specified date.
PriceGraphDistribution
PriceGraphDistribution[n,k,a] represents a de Solla Price graph distribution for n-vertex graphs where a new vertex with k edges is added at each step, using attractiveness parameter a.
Prime
Prime[n] gives the nth prime number pn.
PrimeNu
PrimeNu[n] gives the number of distinct primes ν(n) in n.
PrimeOmega
PrimeOmega[n] gives the number of prime factors counting multiplicities Ω(n) in n.
PrimePi
PrimePi[x] gives the number of primes π(x) less than or equal to x.
PrimePowerQ
PrimePowerQ[expr] yields True if expr is a power of a prime number, and yields False otherwise.
PrimeQ
PrimeQ[n] yields True if n is a prime number, and yields False otherwise.
Primes
Primes represents the domain of prime numbers, as in x∈Primes.
PrimeZetaP
PrimeZetaP[s] gives prime zeta function P(s).
PrimitivePolynomialQ
PrimitivePolynomialQ[poly,p] tests whether poly is a primitive polynomial modulo a prime p.
PrimitiveRoot
PrimitiveRoot[n] gives a primitive root of n.
PrimitiveRoot[n,k] gives the smallest primitive root of n greater than or equal to k.
PrimitiveRootList
PrimitiveRootList[n] gives a list of primitive roots of n.
PrincipalComponents
PrincipalComponents[matrix] transforms elements of matrix into unscaled principal components.
PrincipalValue
PrincipalValue is an option for Integrate that specifies whether the Cauchy principal value should be found for a definite integral.
Print
Print[expr] prints expr as output.
PrintableASCIIQ
PrintableASCIIQ[string] yields True if the string contains only printable ASCII characters, and yields False otherwise.
PrintAction
PrintAction is an option for notebooks that specifies the action taken when a Print[] command is evaluated by the kernel.
PrintingCopies
PrintingCopies is an option for notebooks that specifies the number of copies of a notebook printed when a print command is given.
PrintingOptions
PrintingOptions is an option that specifies settings for printing.
PrintingPageRange
PrintingPageRange is an option for notebooks that specifies the range of pages of a notebook to be printed.
PrintingStartingPageNumber
PrintingStartingPageNumber is an option for notebooks that specifies what number to assign to the first page of a notebook when printed.
PrintingStyleEnvironment
PrintingStyleEnvironment is an option for notebooks that specifies the style environment to be used in printing the notebook on paper.
Printout3D
Printout3D[model] prints out the 3D model using a 3D print previewer.
Printout3D[model,service] prints out the 3D model using the specified 3D printing service.
Printout3D[model,"file.ext"] saves a print-ready form of the model to a file in the format indicated by the file extension ext.
Printout3DPreviewer
Printout3DPreviewer is an option for Printout3D that specifies a previewer for generating outputs to print.
PrintPrecision
PrintPrecision is an option for selections that specifies the maximum number of digits used for displaying a machine-precision number.
Prism
Prism[{p1,…,p6}] represents a filled prism connecting the triangles {p1,p2,p3} and {p4,p5,p6}.
PrivateEvaluationOptions
PrivateEvaluationOptions is an option for selections that specifies settings for evaluation-related suboptions.
PrivateFontOptions
PrivateFontOptions is an option for selections that specifies settings for various font suboptions.
PrivateKey
PrivateKey[assoc] represents the private part of a key pair for a public-key cryptographic system.
Probability
Probability[pred,xdist] gives the probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution dist.
Probability[pred,xdata] gives the probability for an event that satisfies the predicate pred under the assumption that x follows the probability distribution given by data.
Probability[pred,{x1,x2,…}dist] gives the probability that an event satisfies pred under the assumption that {x1,x2,…} follows the multivariate distribution dist.
Probability[pred,{x1dist1,x2dist2,…}] gives the probability that an event satisfies pred under the assumption that x1, x2, … are independent and follow the distributions dist1, dist2, ….
Probability[pred1pred2,…] gives the conditional probability of pred1 given pred2.
ProbabilityDistribution
ProbabilityDistribution[pdf,{x,xmin,xmax}] represents the continuous distribution with PDF pdf in the variable x where the pdf is taken to be zero for x<xmin and x>xmax.
ProbabilityDistribution[pdf,{x,xmin,xmax,1}] represents the discrete distribution with PDF pdf in the variable x where the pdf is taken to be zero for x<xmin and x>xmax.
ProbabilityDistribution[pdf,{x,…},{y,…},…] represents a multivariate distribution with PDF pdf in the variables x, y, …, etc.
ProbabilityDistribution[{"CDF",cdf},…] represents a probability distribution with CDF given by cdf.
ProbabilityDistribution[{"SF",sf},…] represents a probability distribution with survival function given by sf.
ProbabilityDistribution[{"HF",hf},…] represents a probability distribution with hazard function given by hf.
ProbabilityPlot
ProbabilityPlot[list] generates a plot of the CDF of list against the CDF of a normal distribution.
ProbabilityPlot[dist] generates a plot of the CDF of the distribution dist against the CDF of a normal distribution.
ProbabilityPlot[data,rdata] generates a plot of the CDF of data against the CDF of rdata.
ProbabilityPlot[data,rdist] generates a plot of the CDF of data against the CDF of symbolic distribution rdist.
ProbabilityPlot[{data1,data2,…},ref] generates a plot of the CDF of datai against the CDF of a reference distribution ref.
ProbabilityScalePlot
ProbabilityScalePlot[{x1,x2,…}] generates a normal probability plot of the samples xi.
ProbabilityScalePlot[{x1,x2,…},"dist"] generates a probability plot scaled for the distribution "dist".
ProbabilityScalePlot[{data1,data2,…},"dist"] generates several scaled probability plots for data1, data2, ….
ProcessConnection
ProcessConnection[proc, "stream"] returns the stream object for a given stream.
ProcessDirectory
ProcessDirectory is an option specifying the initial working directory to use when executing a process in functions like StartProcess and RunProcess.
ProcessEnvironment
ProcessEnvironment is an option specifying the initial settings of environment variables to use when executing a process in functions like StartProcess and RunProcess.
Processes
Processes[] returns a list of currently running external processes, started in this Wolfram Language session.
ProcessEstimator
ProcessEstimator is an option to EstimatedProcess and FindProcessParameters that specifies what process parameter estimator to use.
ProcessInformation
ProcessInformation[proc] gives information about an external process proc.
ProcessInformation[proc, "prop"] gives information about the property "prop".
ProcessObject
ProcessObject[...] is an object that represents a runnable external process.
ProcessParameterAssumptions
ProcessParameterAssumptions[proc] gives a logical expression for assumptions on parameters in the random process proc.
ProcessParameterQ
ProcessParameterQ[proc] yields True if proc is a valid random process, and yields False otherwise.
ProcessStatus
ProcessStatus[proc] gives the current status of the external process represented by the ProcessObject proc.
ProcessStatus[proc, "status"] returns True if the process has the status given, and returns False otherwise.
ProductDistribution
ProductDistribution[dist1,dist2,…] represents the joint distribution with independent component distributions dist1, dist2, ….
ProductLog
ProductLog[z] gives the principal solution for w in zwew.
ProductLog[k,z] gives the kth solution.
ProgressReporting
ProgressReporting is an option for various algorithmic functions that specifies whether to report the progress of the computation.
Projection
Projection[u,v] finds the projection of the vector u onto the vector v.
Projection[u,v,f] finds projections with respect to the inner product function f.
Prolog
Prolog is an option for graphics functions which gives a list of graphics primitives to be rendered before the main part of the graphics is rendered.
PromptForm
PromptForm[prompt, expr] prints as an output prompt and expression.
ProofObject
ProofObject[…] represents a proof object generated by FindEquationalProof.
Properties
Properties is an option that allows specification of properties to objects and items of objects.
Property
Property[item,name->value] associates the property name->value with item.
PropertyList
PropertyList[{obj,itemspec}] lists the properties available for itemspec in obj.
PropertyValue
PropertyValue[{obj,item},name] gives the property value associated with name for item in obj.
PropertyValue[{obj,itemspec},name] gives the property values associated with name for items indicated by itemspec in obj.
PropertyValue[…,{name1,name2,…}] gives a list of property values associated with name1, name2, etc.
Proportion
Proportion[x,y,…] displays as x∷y∷….
Proportional
Proportional[x,y,…] displays as x∝y∝….
Protect
Protect[s1,s2,…] sets the attribute Protected for the symbols si.
Protect[patt1,patt2,…] protects all symbols whose names textually match any of the arbitrary string patterns patti.
Protect[{spec1,spec2,…}] protects any symbols that are equal to or whose names match any of the speci.
Protected
Protected is an attribute that prevents any values associated with a symbol from being modified.
ProteinData
ProteinData[entity] gives the reference amino acid sequence for the protein entity.
ProteinData[entity,property] gives the value of the specified property for the protein entity.
ProteinData[entity,property,annotation] gives the specified annotation associated with the given property.
Pruning
Pruning[image] removes the outermost branches of thin objects in image by setting their values to black.
Pruning[image,n] removes branches that are at most n pixels long.
Pruning[image,{n}] removes n pixels from each branch.
Pruning[image,n,t] treats values above t as foreground.
PseudoInverse
PseudoInverse[m] finds the pseudoinverse of a rectangular matrix.
PsychrometricPropertyData
PsychrometricPropertyData[spec] returns the psychrometric properties of moist air for the specified parameters.
PsychrometricPropertyData[spec,property] returns the specified property for the given parameters.
PublicKey
PublicKey[assoc] represents the public part of a key pair for a public-key cryptographic system.
PublicKey[PrivateKey[…]] creates a matching public key for the given private key.
PublisherID
PublisherID is an option for ResourceSubmit that specifies the ID used to submit a resource for publication in the resource system.
PulsarData
PulsarData[entity,property] gives the value of the specified property for the pulsar entity.
PulsarData[{entity1,entity2,…},property] gives a list of property values for the specified pulsar entities.
PulsarData[entity,property,annotation] gives the specified annotation associated with the given property.
PunctuationCharacter
PunctuationCharacter represents a punctuation character in StringExpression.
Purple
Purple represents the color purple in graphics or style specifications.
Put
expr>>filename writes expr to a file.
Put[expr1,expr2,…,"filename"] writes a sequence of expressions expri to a file.
Put["filename"] creates an empty file with the specified name.
PutAppend
expr>>>filename appends expr to a file.
PutAppend[expr1,expr2,…,"filename"] appends a sequence of expressions expri to a file.
Pyramid
Pyramid[{p1,…,p5}] represents a filled pyramid with base {p1,…,p4} and top p5.
QBinomial
QBinomial[n,m,q] gives the q-binomial coefficient (�)q.
QFactorial
QFactorial[n,q] gives the q-factorial [n]q!.
QGamma
QGamma[z,q] gives the q-gamma function Γq (z).
QHypergeometricPFQ
QHypergeometricPFQ[{a1,…,ar},{b1,…,bs},q,z] gives the basic hypergeometric series rϕs(a;b;q;z).
QnDispersion
QnDispersion[list] gives the Qn statistic of the elements in list.
QnDispersion[list,c] gives the Qn statistic with a scaling factor c.
QPochhammer
QPochhammer[a,q,n] gives the q-Pochhammer symbol (a;q)n.
QPochhammer[a,q] gives the q-Pochhammer symbol (a;q)∞.
QPochhammer[q] gives the q-Pochhammer symbol (q;q)∞.
QPolyGamma
QPolyGamma[z,q] gives the q-digamma function ψq(z).
QPolyGamma[n,z,q] gives the nth derivative of the q-digamma function ψq(n)(z).
QRDecomposition
QRDecomposition[m] yields the QR decomposition for a numerical matrix m. The result is a list {q,r}, where q is a unitary matrix and r is an upper‐triangular matrix.
QuadraticIrrationalQ
QuadraticIrrationalQ[x] gives True if x is a quadratic irrational and False otherwise.
QuadraticOptimization
QuadraticOptimization[f,cons,vars] finds values of variables vars that minimize the quadratic objective f subject to linear constraints cons.
QuadraticOptimization[{q,c},{a,b}] finds a vector x that minimizes the quadratic objective 1/2x.q.x+c.x subject to the linear inequality constraints a.x+b⪰0.
QuadraticOptimization[{q,c},{a,b},{aeq,beq}] includes the linear equality constraints aeq.x+beq0.
QuadraticOptimization[{q,c},…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.
QuadraticOptimization[…,"prop"] specifies what solution property "prop" should be returned.
Quantile
Quantile[data,p] gives the estimate of the pth quantile q&^p of data.
Quantile[data,{p1,p2,…}] gives a list of quantiles p1,p2,….
Quantile[data,p,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.
Quantile[dist,p] gives a quantile of the distribution dist.
QuantilePlot
QuantilePlot[list] generates a plot of quantiles of list against the quantiles of a normal distribution.
QuantilePlot[dist] generates a plot of quantiles of the distribution dist against the quantiles of a normal distribution.
QuantilePlot[data,rdata] generates a plot of the quantiles of data against the quantiles of rdata.
QuantilePlot[data,rdist] generates a plot of the quantiles of data against the quantiles of a symbolic distribution rdist.
QuantilePlot[{data1,data2,…},ref] generates a plot of quantiles of datai against the quantiles of a reference distribution ref.
Quantity
Quantity[magnitude,unit] represents a quantity with size magnitude and unit specified by unit.
Quantity[unit] assumes the magnitude of the specified unit to be 1.
QuantityArray
QuantityArray[mags,unit] represents an array of quantities with magnitudes mags and common unit.
QuantityArray[mags,{unit1,unit2,…}] represents an array of lists of quantities with units {unit1,unit2,…}.
QuantityArray[quants] converts an array of Quantity objects into a single QuantityArray object.
QuantityDistribution
QuantityDistribution[dist,unit] represents a distribution dist of quantities with unit specified by unit.
QuantityDistribution[dist,{unit1,unit2,…}] represents a multivariate distribution with units {unit1,unit2,…}.
QuantityForm
QuantityForm[expr,form] prints expr with all Quantity expressions using the specified unit display form form.
QuantityForm[expr,{forms}] prints expr using the appropriate combination of the specified unit display forms forms.
QuantityMagnitude
QuantityMagnitude[quantity] gives the amount of the specified quantity.
QuantityMagnitude[quantity,unit] gives the value corresponding to quantity when converted to unit.
QuantityQ
QuantityQ[expr] gives True if expr is a Quantity with valid arguments, and False otherwise.
QuantityQ[expr,dims] gives True if expr is a Quantity with physical dimensions dims, and False otherwise.
QuantityUnit
QuantityUnit[quantity] returns the unit associated with the specified quantity.
QuantityVariable
QuantityVariable[var,"pq"] represents a variable with the label var and the corresponding physical quantity "pq".
QuantityVariable["pq"] represents the unlabeled physical quantity "pq".
QuantityVariableCanonicalUnit
QuantityVariableCanonicalUnit[quantityvariable] returns the canonical unit associated with the specified quantityvariable.
QuantityVariableDimensions
QuantityVariableDimensions[quantityvariable] returns a list of base dimensions associated with the specified quantityvariable.
QuantityVariableIdentifier
QuantityVariableIdentifier[quantityvariable] returns the identifier associated with the specified quantityvariable.
QuantityVariablePhysicalQuantity
QuantityVariablePhysicalQuantity[var] returns the physical quantity associated with the quantity variable var.
QuantityVariablePhysicalQuantity[var,type] returns the physical quantity using the format type.
Quartics
Quartics is an option for functions that involve solving algebraic equations that specifies whether explicit forms for solutions to quartic equations should be given.
QuartileDeviation
QuartileDeviation[data] gives the quartile deviation or semi-interquartile range of the elements in data.
QuartileDeviation[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.
QuartileDeviation[dist] gives the quartile deviation or semi-interquartile range of the distribution dist.
Quartiles
Quartiles[data] gives the {q&^1/4,q&^2/4,q&^3/4} quantile estimates of the elements in data.
Quartiles[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.
Quartiles[dist] gives the {q1/4,q2/4,q3/4} quantiles of the distribution dist.
QuartileSkewness
QuartileSkewness[data] gives the coefficient of quartile skewness for the elements in list.
QuartileSkewness[data,{{a,b},{c,d}}] uses the quantile definition specified by parameters a, b, c, d.
QuartileSkewness[dist] gives the coefficient of quartile skewness for the distribution dist.
Query
Query[operator1,operator2,…] represents a query that can be applied to a Dataset object, in which the successive operatori are applied at successively deeper levels.
QuestionInterface
QuestionInterface[type,<|p1->s1,p2->s2,…|>] defines an interface for a QuestionObject using the given type and properties pi with settings si.
QuestionObject
QuestionObject[q,assess] represents the question q and the corresponding assessment assess.
QuestionObject[assess] derives a question from the assessment.
QueueingNetworkProcess
QueueingNetworkProcess[γ,r,μ,c] represents an open (Jackson) queueing network process with arrival vector γ, routing probability matrix r, service vector μ, and service channel vector c.
QueueingNetworkProcess[γ,r,μ,c,k] represents a closed (Gordon–Newell) queueing network process with k jobs in the system.
QueueingProcess
QueueingProcess[λ,μ] represents an M/M/1 queue with arrival rate λ and service rate μ.
QueueingProcess[λ,sdist] represents an M/G/1 queue with arrival rate λ and service distribution sdist.
QueueingProcess[adist,μ] represents a G/M/1 queue with arrival distribution adist and service rate μ.
QueueingProcess[adist,sdist] represents a G/G/1 queue with arrival distribution adist and service distribution sdist.
QueueingProcess[…,…,c] represents a queueing process with c service channels.
QueueingProcess[…,…,c,k] represents a queueing process with system capacity k.
QueueingProcess[…,…,c,k,x0] represents a queueing process with initial state x0.
Quiet
Quiet[expr] evaluates expr "quietly", without actually outputting any messages generated.
Quiet[expr,{s1::t1,s2::t2,…}] quietens only the specified messages during the evaluation of expr.
Quiet[expr,"name"] quietens only the named group of messages.
QuietEcho
QuietEcho[expr] evaluates expr without letting Echo and related functions inside expr print any result.
Quit
Quit[] terminates a Wolfram Language kernel session.
Quotient
Quotient[m,n] gives the integer quotient of m and n.
Quotient[m,n,d] uses an offset d.
QuotientRemainder
QuotientRemainder[m,n] gives a list of the quotient and remainder from division of m by n.
RadialAxisPlot
RadialAxisPlot[{y1,y2,…,yn}] generates a radial axis plot where the yi are displayed on radial axes equally spaced around the origin.
RadialAxisPlot[{data1,data2,…}] plots several datasets datai on the axes.
RadialGradientFilling
RadialGradientFilling[{col1,col2,…,coln}] is a two-dimensional graphics directive specifying that faces of polygons and other filled graphics objects are to be drawn using concentric circles of colors coli.
RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln}] uses the colors coli at radii ri.
RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{x,y}] radiates from the center point {x,y}.
RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{{x,y},{r1,r2}}] radiates from the center point {x,y} in concentric axis-aligned ellipsoids with semiaxes length proportional to ri.
RadialGradientFilling[{r1,r2,…,rn}->{col1,col2,…,coln},{{x,y},{r1,r2}},padding] uses the specified padding when drawing beyond the boundary radii r1 and rn.
RadialGradientImage
RadialGradientImage[gcol] returns an image with values radially changing from center to corners based on gradient color gcol.
RadialGradientImage[{pos1,pos2}->gcol] returns an image where the gradient starts at pos1 and ends at pos2.
RadialGradientImage[…,size] returns a radial gradient image of the specified size.
RadialGradientImage[…,size,"type"] gives an image converted to the specified type.
RadialityCentrality
RadialityCentrality[g] gives a list of radiality centralities for the vertices in the graph g.
RadialityCentrality[g,"In"] gives a list of in-centralities for a directed graph g.
RadialityCentrality[g,"Out"] gives a list of out-centralities for a directed graph g.
RadialityCentrality[{v->w,…},…] uses rules v->w to specify the graph g.
Radon
Radon[image] gives an image representing the discrete Radon transform of image.
Radon[image,{w,h}] specifies the width w and the height h of the resulting image.
Radon[image,{w,h},{θ1,θ2}] computes the Radon transform only for angles from θ1 to θ2.
RadonTransform
RadonTransform[expr,{x,y},{p,ϕ}] gives the Radon transform of expr.
RamanujanTau
RamanujanTau[n] gives the Ramanujan τ function τ(n).
RamanujanTauL
RamanujanTauL[s] gives the Ramanujan tau Dirichlet L-function L(s).
RamanujanTauTheta
RamanujanTauTheta[t] gives the Ramanujan tau theta function θ(t).
RamanujanTauZ
RamanujanTauZ[t] gives the Ramanujan tau Z-function Z(t).
Ramp
Ramp[x] gives x if x≥0 and 0 otherwise.
Random
Random[] gives a uniformly distributed pseudorandom Real in the range 0 to 1.
Random[type,range] gives a pseudorandom number of the specified type, lying in the specified range. Possible types are: Integer, Real and Complex. The default range is 0 to 1. You can give the range {min,max} explicitly; a range specification of max is equivalent to {0,max}.
RandomArrayLayer
RandomArrayLayer[dist] represents a net layer that has no input and produces a random array from the univariate distribution dist.
RandomArrayLayer[dfunc] uses the univariate distribution dfunc[input] for each input value.
RandomChoice
RandomChoice[{e1,e2,…}] gives a pseudorandom choice of one of the ei.
RandomChoice[list,n] gives a list of n pseudorandom choices.
RandomChoice[list,{n1,n2,…}] gives an n1×n2×… array of pseudorandom choices.
RandomChoice[{w1,w2,…}->{e1,e2,…}] gives a pseudorandom choice weighted by the wi.
RandomChoice[wlist->elist,n] gives a list of n weighted choices.
RandomChoice[wlist->elist,{n1,n2,…}] gives an n1×n2×… array of weighted choices.
RandomColor
RandomColor[] gives a pseudorandom color directive in the RGBColor space.
RandomColor[n] gives n pseudorandom colors.
RandomColor[model] gives a color from the specified model.
RandomColor[model,n] gives n colors.
RandomColor[model,{n1,n2,…}] gives an array of colors.
RandomComplex
RandomComplex[] gives a pseudorandom complex number with real and imaginary parts in the range 0 to 1.
RandomComplex[{zmin,zmax}] gives a pseudorandom complex number in the rectangle with corners given by the complex numbers zmin and zmax.
RandomComplex[zmax] gives a pseudorandom complex number in the rectangle whose corners are the origin and zmax.
RandomComplex[range,n] gives a list of n pseudorandom complex numbers.
RandomComplex[range,{n1,n2, …}] gives an n1×n2×… array of pseudorandom complex numbers.
RandomEntity
RandomEntity[spec] gives a pseudorandom entity with a type determined by the specification spec.
RandomEntity[spec,n] gives a list of n pseudorandom entities.
RandomFunction
RandomFunction[proc,{tmin,tmax}] generates a pseudorandom function from the process proc from tmin to tmax.
RandomFunction[proc,{tmin,tmax,dt}] generates a pseudorandom function from tmin to tmax in steps of dt.
RandomFunction[proc,…, n] generates an ensemble of n pseudorandom functions.
RandomGeneratorState
RandomGeneratorState[…] gives a representation of the internal state of a pseudorandom generator.
RandomGeoPosition
RandomGeoPosition[] gives a pseudorandom geo position uniformly distributed on the surface of the Earth.
RandomGeoPosition[{{latmin,lonmin},{latmax,lonmax}}] gives a pseudorandom geo position uniformly distributed in the given geo bounding box.
RandomGeoPosition[g] gives a pseudorandom geo position uniformly distributed in the geo region g.
RandomGeoPosition[g,n] gives a list of n pseudorandom geo positions uniformly distributed in the geo region g.
RandomGeoPosition[g,{n1,n2,…}] gives an n1× n2×… pseudorandom geo position array.
RandomGraph
RandomGraph[{n,m}] gives a pseudorandom graph with n vertices and m edges.
RandomGraph[{n,m},k] gives a list of k pseudorandom graphs.
RandomGraph[gdist,…] samples from the random graph distribution gdist.
RandomImage
RandomImage[max] gives an image with pseudorandom pixel values in the range 0 to max.
RandomImage[{min,max}] generates pseudorandom pixel values in the range min to max.
RandomImage[dist] generates pixel values using a symbolic distribution dist.
RandomImage[…,size] generates a random image of the specified size.
RandomImage[…,size,"type"] gives an image converted to the specified type.
RandomInstance
RandomInstance[expr] finds a random instance of an expression such as a geometric scene.
RandomInstance[expr] finds a random instance of an expression such as a geometric scene or biomolecular sequence.
RandomInstance[expr,n] finds n instances.
RandomInteger
RandomInteger[{imin,imax}] gives a pseudorandom integer in the range {imin,imax}.
RandomInteger[imax] gives a pseudorandom integer in the range {0,…,imax}.
RandomInteger[] pseudorandomly gives 0 or 1.
RandomInteger[range,n] gives a list of n pseudorandom integers.
RandomInteger[range,{n1,n2,…}] gives an n1×n2×… array of pseudorandom integers.
RandomPermutation
RandomPermutation[gr] gives a pseudorandom permutation in the permutation group gr.
RandomPermutation[gr,n] gives a list of n pseudorandom permutations in the permutation group gr.
RandomPoint
RandomPoint[reg] gives a pseudorandom point uniformly distributed in the region reg.
RandomPoint[reg,n] gives a list of n pseudorandom points uniformly distributed in the region reg.
RandomPoint[reg,{n1,n2,…}] gives an n1× n2×… array of pseudorandom points.
RandomPoint[reg,…,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.
RandomPointConfiguration
RandomPointConfiguration[pproc,reg] generates a pseudorandom spatial point configuration from the spatial point process pproc in the observation region reg.
RandomPointConfiguration[pproc,reg, n] generates an ensemble of n spatial point configurations.
RandomPolygon
RandomPolygon[n] gives a pseudorandom simple polygon with n vertex points.
RandomPolygon[spec] gives a pseudorandom polygon with the specified specification spec.
RandomPolygon[spec,k] gives a list of k pseudorandom polygons.
RandomPolygon[d->spec,…] gives a pseudorandom polygon in dimension d.
RandomPolyhedron
RandomPolyhedron[spec] gives a pseudorandom polyhedron with the specified specification spec.
RandomPolyhedron[spec,k] gives a list of k pseudorandom polyhedra.
RandomPrime
RandomPrime[{imin,imax}] gives a pseudorandom prime number in the range imin to imax.
RandomPrime[imax] gives a pseudorandom prime number in the range 2 to imax.
RandomPrime[range,n] gives a list of n pseudorandom primes.
RandomReal
RandomReal[] gives a pseudorandom real number in the range 0 to 1.
RandomReal[{xmin,xmax}] gives a pseudorandom real number in the range xmin to xmax.
RandomReal[xmax] gives a pseudorandom real number in the range 0 to xmax.
RandomReal[range,n] gives a list of n pseudorandom reals.
RandomReal[range,{n1,n2,…}] gives an n1×n2×… array of pseudorandom reals.
RandomSample
RandomSample[{e1,e2,…},n] gives a pseudorandom sample of n of the ei.
RandomSample[{w1,w2,…}->{e1,e2,…},n] gives a pseudorandom sample of n of the ei chosen using weights wi.
RandomSample[{e1,e2,…}] gives a pseudorandom permutation of the ei.
RandomSeeding
RandomSeeding is an option that specifies what seeding of pseudorandom generators should be done inside the operation of a function.
RandomTree
RandomTree[n] gives a pseudorandom tree with n nodes.
RandomTree[n,k] gives a list of k pseudorandom trees.
RandomTree[n,{k1,k2,…}] gives a k1× k2×… array of trees.
RandomVariate
RandomVariate[dist] gives a pseudorandom variate from the symbolic distribution dist.
RandomVariate[dist,n] gives a list of n pseudorandom variates from the symbolic distribution dist.
RandomVariate[dist,{n1,n2,…}] gives an n1× n2×… array of pseudorandom variates from the symbolic distribution dist.
RandomWalkProcess
RandomWalkProcess[p] represents a random walk on a line with the probability of a positive unit step p and the probability of a negative unit step 1-p.
RandomWalkProcess[p,q] represents a random walk with the probability of a positive unit step p, the probability of a negative unit step q, and the probability of a zero step 1-p-q.
RandomWord
RandomWord[] gives a pseudorandom commonly used word.
RandomWord[n] gives a list of n pseudorandom words.
RandomWord[type] gives a pseudorandom word of the specified type.
RandomWord[type,n] gives a list of n pseudorandom words of the specified type.
Range
Range[imax] generates the list {1,2,…,imax}.
Range[imin,imax] generates the list {imin,…,imax}.
Range[imin,imax,di] uses step di.
RankedMax
RankedMax[list,n] gives the nth largest element in list.
RankedMax[list,-n] gives the nth smallest element in list.
RankedMin
RankedMin[list,n] gives the nth smallest element in list.
RankedMin[list,-n] gives the nth largest element in list.
RarerProbability
RarerProbability[dist,example] computes the probability for distribution dist to generate a sample that has a lower or equal PDF than example.
RarerProbability[dist,{ex1,ex2,…}] computes the rarer probability for each exi.
Raster
Raster[{{a11,a12,…},…}] is a two-dimensional graphics primitive which represents a rectangular array of gray cells.
Raster[{{{r11,g11,b11},…},…}] represents an array of RGB color cells.
Raster[{{{r11,g11,b11,α11},…},…}] represents an array of color cells with opacity αij.
Raster[{{{a11,α11},…},…}] represents an array of gray cells with the specified opacities.
Raster3D
Raster3D[{{{a11,a12,…},…},…}] is a three-dimensional graphics primitive that represents a cubical array of gray cells.
Raster3D[{{{{r11,g11,b11},…},…},…}] represents an array of RGB color cells.
Raster3D[{{{{r11,g11,b11,α11},…},…},…}] represents an array of color cells with opacity αij.
Raster3D[array,{{xmin,ymin,zmin},{xmax,ymax,zmax}}] represents a three-dimensional graphics primitive by giving the coordinates of opposite corners.
Raster3D[array,coordinates,{amin,amax}] represents a three-dimensional graphics primitive whose voxel values should be scaled so that amin corresponds to 0 and amax corresponds to 1.
RasterArray
RasterArray[{{g11,g12,…},…}] is a two-dimensional graphics primitive that represents a rectangular array of cells colored according to the graphics directives gij.
Rasterize
Rasterize[expr] returns a rasterized version of the displayed form of expr.
Rasterize[expr,elem] gives the element elem associated with the rasterized form of expr.
Rasterize[expr,{elem1,elem2,…}] gives a list of the specified elemi.
RasterSize
RasterSize is an option for Rasterize and related functions that determines the absolute pixel size of the raster generated.
Rational
Rational is the head used for rational numbers.
RationalExpressionQ
RationalExpressionQ[expr,x] gives True if expr is structurally a rational expression in x, and False otherwise.
RationalExpressionQ[expr,{x,y,…}] gives True if expr is structurally a rational expression in x,y,…, and False otherwise.
RationalExpressionQ[expr,{x,y,…},test] gives True if expr is structurally a rational expression in x,y,… with coefficients satisfying test, and False otherwise.
Rationalize
Rationalize[x] converts an approximate number x to a nearby rational with small denominator.
Rationalize[x,dx] yields the rational number with smallest denominator that lies within dx of x.
Rationals
Rationals represents the domain of rational numbers, as in x∈Rationals.
Ratios
Ratios[list] gives the successive ratios of elements in list.
Ratios[list,n] gives the nth iterated ratios of list.
Ratios[list,{n1,n2,…}] gives the successive nkth ratios at level k in a nested list.
RawMedium
RawMedium is an internal symbol.
RayleighDistribution
RayleighDistribution[σ] represents the Rayleigh distribution with scale parameter σ.
Re
Re[z] gives the real part of the complex number z.
ReactionBalance
ReactionBalance[rxn] returns a version of the reaction rxn in which the stoichiometric coefficients for elements in the reactants and products are balanced.
ReactionBalancedQ
ReactionBalancedQ[rxn] returns True if the given chemical reaction is balanced, and False otherwise.
ReactionPDETerm
ReactionPDETerm[vars,a] represents a reaction term a u with reaction coefficient a and with model variables vars.
ReactionPDETerm[{u,{x1,…,xn}},a,pars] uses model parameters pars.
Read
Read[stream] reads one expression from an input stream and returns the expression.
Read[stream,type] reads one object of the specified type.
Read[stream,{type1,type2,…}] reads a sequence of objects of the specified types.
ReadByteArray
ReadByteArray[src] gives the contents of src as a ByteArray object.
ReadByteArray[src,n] reads the first n bytes from src.
ReadByteArray[src,term] reads until the termination condition term is satisfied.
ReadLine
ReadLine[stream] reads a line of text from a stream and returns it as a string.
ReadLine[proc] reads a line of text generated by an external process and returns it as a string.
ReadList
ReadList["file"] reads all the remaining expressions in a file and returns a list of them.
ReadList["file",type] reads objects of the specified type from a file, until the end of the file is reached. The list of objects read is returned.
ReadList["file",{type1,type2,…}] reads objects with a sequence of types, until the end of the file is reached.
ReadList["file",types,n] reads only the first n objects of the specified types.
ReadProtected
ReadProtected is an attribute that prevents values associated with a symbol from being seen.
ReadString
ReadString["file"] reads the complete contents of a file and returns it as a string.
ReadString[stream] reads everything from a stream and returns it as a string.
ReadString[proc] reads everything generated by an external process and returns it as a string.
ReadString[src,term] reads until the terminator term is encountered.
Real
Real is the head used for real (floating‐point) numbers.
RealAbs
RealAbs[x] gives the absolute value of the real number x.
RealBlockDiagonalForm
RealBlockDiagonalForm is an option for SchurDecomposition and related functions which specifies whether 2×2 blocks of real values should be used on matrix diagonals in place of complex values.
RealExponent
RealExponent[x] gives log10(x).
RealExponent[x,b] gives logb(x).
Reals
Reals represents the domain of real numbers, as in x∈Reals.
RealSign
RealSign[x] gives -1, 0 or 1 depending on whether x is negative, zero or positive.
Reap
Reap[expr] gives the value of expr together with all expressions to which Sow has been applied during its evaluation. Expressions sown using Sow[e] or Sow[e,tagi] with different tags are given in different lists.
Reap[expr,patt] reaps only expressions sown with tags that match patt.
Reap[expr,{patt1,patt2,…}] puts expressions associated with each of the patti in a separate list.
Reap[expr,patt,f] returns {expr,{f[tag1,{e11,e12,…}],…}}.
RebuildPacletData
The experimental function RebuildPacletData is now obsolete and is superseded by PacletDataRebuild.
RecalibrationFunction
RecalibrationFunction is an option for Classify, Predict and related functions that specifies how to post-process model predictions.
RecognitionPrior
RecognitionPrior is an option for recognition functions that specifies the prior probability or class for recognition.
RecognitionThreshold
RecognitionThreshold is an option for ImageInstanceQ and related functions that specifies the minimum estimated probability at which recognition is considered acceptable.
Record
Record represents a record in Read, Find, and related functions.
RecordLists
RecordLists is an option for ReadList that specifies whether objects from separate records should be returned in separate sublists.
RecordSeparators
RecordSeparators is an option for Read, Find, and related functions that specifies the list of strings to be taken as delimiters for records.
Rectangle
Rectangle[{xmin,ymin},{xmax,ymax}] represents an axis-aligned filled rectangle from {xmin,ymin} to {xmax,ymax}.
Rectangle[{xmin,ymin}] corresponds to a unit square with its bottom-left corner at {xmin,ymin}.
RectangleChart
RectangleChart[{{x1,y1},{x2,y2},…}] makes a rectangle chart with bars of width xi and height yi.
RectangleChart[{…,wi[{xi,yi},…],…,wj[{xi,yj},…],…}] makes a rectangle chart with bar features defined by the symbolic wrappers wk.
RectangleChart[{data1,data2,…}] makes a rectangle chart from multiple datasets datai.
RectangleChart3D
RectangleChart3D[{{x1,y1,z1},{x2,y2,z2},…}] makes a 3D rectangle chart with bars of width xi, depth yi, and height zi.
RectangleChart3D[{…,wi[{xi,yi,zi},…],…,wj[{xi,yj,zj},…],…}] makes a 3D rectangle chart with bar features defined by the symbolic wrappers wk.
RectangleChart3D[{data1,data2,…}] makes a 3D rectangle chart from multiple datasets datai.
RectangularRepeatingElement
RectangularRepeatingElement[elem] represents a rectangular array of elements of type spec in an interpreter, API or form specification.
RectangularRepeatingElement[elem,{maxrows,maxcolumns}] represents a rectangular array of elements of maximum size maxrows×maxcolums.
RectangularRepeatingElement[elem,{{minrows,maxrows},{mincolumns,maxcolumns}}] represents a rectangular array of elements of dimensions between minrows×mincolumns and maxrows×maxcolums.
RecurrenceFilter
RecurrenceFilter[{α,β},x] filters x using a linear recurrence equation with coefficients α and β.
RecurrenceFilter[tf,x] uses a discrete-time filter defined by the TransferFunctionModel tf.
RecurrenceFilter[…,x,{y0,y-1,…}] uses a specified list {y0,y-1,…} as the initial condition.
RecurrenceFilter[…,image] filters image.
RecurrenceFilter[…,sound] filters sampled sound object.
RecurrenceTable
RecurrenceTable[eqns,expr,{n,nmax}] generates a list of values of expr for successive n based on solving the recurrence equations eqns.
RecurrenceTable[eqns,expr,nspec] generates a list of values of expr over the range of n values specified by nspec.
RecurrenceTable[eqns,expr,{n1,…},{n2,…},…] generates an array of values of expr for successive n1, n2, … .
Red
Red represents the color red in graphics or style specifications.
Reduce
Reduce[expr,vars] reduces the statement expr by solving equations or inequalities for vars and eliminating quantifiers.
Reduce[expr,vars,dom] does the reduction over the domain dom. Common choices of dom are Reals, Integers, and Complexes.
ReferenceLineStyle
ReferenceLineStyle is an option for QuantilePlot and similar functions that specifies the style used for the reference line.
Refine
Refine[expr,assum] gives the form of expr that would be obtained if symbols in it were replaced by explicit numerical expressions satisfying the assumptions assum.
Refine[expr] uses default assumptions specified by any enclosing Assuming constructs.
ReflectionMatrix
ReflectionMatrix[v] gives the matrix that represents reflection of points in a mirror normal to the vector v.
ReflectionTransform
ReflectionTransform[v] gives a TransformationFunction that represents a reflection in a mirror through the origin, normal to the vector v.
ReflectionTransform[v,p] gives a reflection in a mirror through the point p, normal to the vector v.
Refresh
Refresh[expr,interval,opts] represents an object whose value should be refreshed at times specified by the options opts.
RefreshRate
RefreshRate is an option to Animate and related functions which specifies the refresh rate for frames in animations.
Region
Region[reg] represents a geometric region.
Region[reg,options] gives a region that uses the specified options.
RegionBinarize
RegionBinarize[image,marker,d] gives a binary version of image that includes the foreground pixels of marker and also connected regions whose pixel values are within a distance d.
RegionBinarize[image,marker,d,{t1,t2}] grows regions in marker by adding pixels whose average intensity is also constrained within an interval {t1,t2}.
RegionBoundary
RegionBoundary[reg] represents the boundary of the region reg.
RegionBoundaryStyle
RegionBoundaryStyle is an option for plotting functions that specifies the boundary style for the region over which the plot is being drawn.
RegionBounds
RegionBounds[reg] gives the bounds for the region reg.
RegionBounds[reg,"type"] gives region bounds of the specified "type".
RegionCentroid
RegionCentroid[reg] gives the centroid of the region reg.
RegionCongruent
RegionCongruent[reg1,reg2] tests whether the regions reg1 and reg2 are congruent.
RegionConvert
RegionConvert[reg,form] converts the region representation reg to the specified form.
RegionDifference
RegionDifference[reg1,reg2] gives the difference of the regions reg1 and reg2.
RegionDilation
RegionDilation[reg,r] gives the dilation of the region reg by a disk of radius r centered at the origin.
RegionDilation[reg1,reg2] gives the dilation of the region reg1 by the region reg2.
RegionDilation[reg1,reg2,{u,v}] gives the dilation of reg1 scaled by a factor u and reg2 scaled by a factor v.
RegionDimension
RegionDimension[reg] gives the geometric dimension of the region reg.
RegionDisjoint
RegionDisjoint[reg1,reg2] returns True if the regions reg1 and reg2 are disjoint.
RegionDisjoint[reg1,reg2,reg3,…] returns True if the regions reg1, reg2, reg3, … are pairwise disjoint.
RegionDistance
RegionDistance[reg,p] gives the minimum distance from the point p to the region reg.
RegionDistance[reg1,reg2] gives the minimum distance between points in the regions reg1 and reg2.
RegionDistance[reg] gives a RegionDistanceFunction[…] that can be applied repeatedly to different points.
RegionDistanceFunction
RegionDistanceFunction[reg,…] represents a function whose values give the distance from a point to the region reg.
RegionEmbeddingDimension
RegionEmbeddingDimension[reg] gives the dimension of the space in which the region reg is embedded.
RegionEqual
RegionEqual[reg1,reg2] returns True if the regions reg1 and reg2 are equal.
RegionEqual[reg1,reg2,reg3,…] returns True if the regions reg1, reg2, reg3, … are all equal.
RegionErosion
RegionErosion[reg,r] gives the erosion of the region reg by a disk of radius r centered at the origin.
RegionErosion[reg1,reg2] gives the erosion of the region reg1 by the region reg2.
RegionErosion[reg1,reg2,{u,v}] gives the erosion of reg1 scaled by a factor u and reg2 scaled by a factor v.
RegionFillingStyle
RegionFillingStyle is an option for plotting functions that specifies the style for the filled region over which the plot is being drawn.
RegionFit
RegionFit[{p1,p2,…},"model"] finds a geometric region "model" that best fits the points p1,p2,….
RegionFit[{p1,p2,…},"model","prop"] specifies what fit property "prop" should be returned.
RegionFunction
RegionFunction is an option for plotting functions that specifies the region to include in the plot drawn.
RegionImage
RegionImage[reg] returns a rasterized grayscale 2D or 3D image of reg.
RegionImage[reg,{{xmin,xmax},…}] restricts to the bounds [xmin,xmax]×⋯.
RegionIntersection
RegionIntersection[reg1,reg2,…] gives the intersection of the regions reg1, reg2, ….
RegionMeasure
RegionMeasure[reg] gives the measure of the region reg.
RegionMeasure[reg,d] gives the d-dimensional measure of the region reg.
RegionMeasure[{x1,…,xn},{{t1,a1,b1},…,{tk,ak,bk}}] gives the k-measure of the parametric formula whose Cartesian coordinates xi are functions of tj.
RegionMeasure[{x1,…,xn},{{t1,a1,b1},…,{tk,ak,bk}},chart] interprets the xi as coordinates in the specified coordinate chart.
RegionMember
RegionMember[reg,{x,y,…}] gives True if the numeric point {x,y,…} is a member of the constant region reg and False otherwise.
RegionMember[reg,{x,y,…}] gives conditions for the point {x,y,…} to be a member of reg.
RegionMember[reg] returns a RegionMemberFunction[…] that can be applied repeatedly to different points.
RegionMemberFunction
RegionMemberFunction[reg, …] represents a function whose values give whether a point is in a region reg or not.
RegionMoment
RegionMoment[reg,{i1,i2,…,in}] computes the polynomial moment ∫x∈regx1i1 x2i2 ⋯ xnin for the region reg.
RegionNearest
RegionNearest[reg,p] gives a point in the region reg that is nearest the point p.
RegionNearest[reg] gives a RegionNearestFunction[…] that can be repeatedly applied to points.
RegionNearestFunction
RegionNearestFunction[reg,…] represents a function whose values give the nearest point in the region reg.
RegionPlot
RegionPlot[pred,{x,xmin,xmax},{y,ymin,ymax}] makes a plot showing the region in which pred is True.
RegionPlot[{pred1,pred2,…},…] plots several regions corresponding to the predi.
RegionPlot[{…,w[predi,…],…},…] plots predi with features defined by the symbolic wrapper w.
RegionPlot3D
RegionPlot3D[pred,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] makes a plot showing the three-dimensional region in which pred is True.
RegionPlot3D[{pred1,pred2,…},…] plots several regions corresponding to the predi.
RegionProduct
RegionProduct[reg1,reg2] represents the Cartesian product of the regions reg1 and reg2.
RegionProduct[reg1,reg2,…] represents the Cartesian product of the regions reg1, reg2, ….
RegionQ
RegionQ[reg] gives True if reg is a valid region and False otherwise.
RegionResize
RegionResize[reg,l] resize the region reg to have the first side length l preserving side length ratios.
RegionResize[reg,{lmax}] resize into a box with maximum side length lmax preserving side length ratios.
RegionResize[reg,{l1,l2,…}] resize into a box with side lengths li.
RegionResize[reg,{{x1,min,x1,max},{x2,min,x2,max},…}] resize into a box with corners {x1,min,x2,min,…} and {x1,max,x2,max,…}.
RegionSimilar
RegionSimilar[reg1,reg2] tests whether the regions reg1 and reg2 are similar.
RegionSize
RegionSize is an option used by Printout3D to specify the overall size of an object to print for a region.
RegionSymmetricDifference
RegionSymmetricDifference[reg1,reg2,…] represents the symmetric difference of the regions reg1, reg2, ….
RegionUnion
RegionUnion[reg1,reg2,…] gives the union of the regions reg1, reg2, ….
RegionWithin
RegionWithin[reg1,reg2] returns True if reg2 is contained within reg1.
RegisterExternalEvaluator
RegisterExternalEvaluator[sys,evaluator] registers the evaluator for use as an external evaluator with the language or system sys.
RegisterExternalEvaluator[sys,evaluator,name] registers the evaluator using the assigned name name.
RegularExpression
RegularExpression["regex"] represents the generalized regular expression specified by the string "regex".
Regularization
Regularization is an option for Sum and Product that specifies what type of regularization to use.
RegularlySampledQ
RegularlySampledQ[tseries] gives True if tseries is a regular time series, and False otherwise.
RegularPolygon
RegularPolygon[n] gives the regular polygon with n vertices equally spaced around the unit circle.
RegularPolygon[r,n] gives the regular polygon of radius r.
RegularPolygon[{r,θ},n] starts at angle θ with respect to the x axis.
RegularPolygon[{x,y},rspec,n] centers the polygon at {x,y}.
ReIm
ReIm[z] gives the list {Re[z],Im[z]} of the number z.
ReImLabels
ReImLabels is an option for ReImPlot that specifies labels to use for the real and imaginary components.
ReImPlot
ReImPlot[f,{x,xmin,xmax}] generates a plot of Re[f] and Im[f] as functions of x∈ from xmin to xmax.
ReImPlot[{f1,f2,…},{x,xmin,xmax}] plots several functions.
ReImPlot[{…,w[fi],…},…] plots fi with features defined by the symbolic wrapper w.
ReImPlot[…,{x}∈reg] takes the variable x to be in the geometric region reg.
ReImStyle
ReImStyle is an option for ReImPlot that specifies styles to use for the real and imaginary components.
Reinstall
Reinstall[link] un-installs the specified external package and installs it again.
RelationalDatabase
RelationalDatabase[…] represents schema information about a relational database.
RelationalDatabase[db] gives the complete schema of the database referenced by db.
RelationalDatabase[{table1 table2,…},db] gives schema information related to the tables tablei.
RelationGraph
RelationGraph[f,{v1,v2,…}] gives the graph with vertices vi and edges from vi to vj whenever f[vi,vj] is True.
RelationGraph[f,{v1,v2,…},{w1,w2,…}] gives the graph with vertices vi,wj and edges from vi to wj whenever f[vi,wj] is True.
ReleaseHold
ReleaseHold[expr] removes Hold, HoldForm, HoldPattern, HoldComplete and HoldCompleteForm in expr.
ReliabilityDistribution
ReliabilityDistribution[bexpr,{{x1,dist1},{x2,dist2},…}] represents the reliability distribution for a system with components xi having reliability distribution disti, where the whole system is working when the Boolean expression bexpr is True, and component xi is working when xi is True.
ReliefImage
ReliefImage[array] generates a relief image of an array of height values.
ReliefPlot
ReliefPlot[array] generates a relief plot of an array of height values.
RemoteAuthorizationCaching
RemoteAuthorizationCaching is an option for RemoteConnect and related functions that determines whether caching of authorization information on remote hosts should be used.
RemoteBatchJobAbort
RemoteBatchJobAbort[job] aborts a remote batch job.
RemoteBatchJobObject
RemoteBatchJobObject[…] represents a remote batch job submitted by RemoteBatchSubmit or RemoteBatchMapSubmit.
RemoteBatchJobs
RemoteBatchJobs[env] gives a list of RemoteBatchJobObject expressions representing batch jobs submitted using env.
RemoteBatchJobs[env,type] returns only jobs of given type.
RemoteBatchJobs[] gives a list of jobs submitted using $DefaultRemoteBatchSubmissionEnvironment.
RemoteBatchMapSubmit
RemoteBatchMapSubmit[env,f,list] submits an array batch job in which f is applied to each element on the first level of list, using the remote batch submission environment env.
RemoteBatchMapSubmit[f,list] submits an array job using $DefaultRemoteBatchSubmissionEnvironment.
RemoteBatchSubmissionEnvironment
RemoteBatchSubmissionEnvironment["provider",assoc] represents a remote batch job submission environment for provider with properties assoc.
RemoteBatchSubmissionEnvironment["provider"] represents a submission environment for provider with default optional properties.
RemoteBatchSubmit
RemoteBatchSubmit[env,expr] submits expr for evaluation using the remote batch submission environment env.
RemoteBatchSubmit[expr] submits expr for evaluation using $DefaultRemoteBatchSubmissionEnvironment.
RemoteConnect
RemoteConnect["host"] connects to the specified remote host.
RemoteConnect[IPAddress["address"]] connects to the machine with the specified IP address.
RemoteConnect["host",username] connects using the specified username for the remote host.
RemoteConnect["host",username,password] connects using the specified username and password.
RemoteConnectionObject
RemoteConnectionObject[…] is an object that represents a remote connection.
RemoteEvaluate
RemoteEvaluate[expr] gives the result of evaluating expr using your current default remote Wolfram Language kernel.
RemoteEvaluate[ker, expr] gives the result of evaluating expr using the kernel specified by ker.
RemoteEvaluate[{ker1,ker2,…},expr] gives a list of the results of evaluating expr using each of the kernels keri.
RemoteEvaluate[ker,expr,h] wraps the head h around the result produced before returning it.
RemoteFile
RemoteFile[URL["uri"]] is a symbolic representation of a file on a remote machine.
RemoteInputFiles
RemoteInputFiles is an option for RemoteBatchSubmit and RemoteBatchMapSubmit that specifies local files to be uploaded and made available within remote jobs.
RemoteKernelObject
RemoteKernelObject[spec] specifies a remote kernel that can be used for RemoteEvaluate or LaunchKernels.
RemoteProviderSettings
RemoteProviderSettings is an option for RemoteBatchSubmit and RemoteBatchMapSubmit that specifies provider-specific settings for a batch job.
RemoteRun
RemoteRun["host","command"] runs the specified operating system command on the remote host, returning the exit code obtained.
RemoteRun[IPAddress["address"],"command"] runs the command on the machine with the specified IP address.
RemoteRun[obj,"command"] run the command on the remote host specified by the RemoteConnectionObject obj.
RemoteRunProcess
RemoteRunProcess["host","command"] runs the specified system command on the remote host, returning information on the outcome.
RemoteRunProcess[IPAddress["address"],"command"] runs the command on the machine with the specified IP address.
RemoteRunProcess[obj,"command"] run the command on the remote host specified by the RemoteConnectionObject obj.
RemoteRunProcess["host",{"command",arg1,arg2,…}] runs the specified command, with command-line arguments argi.
RemoteRunProcess["host", command,"prop"] returns only the specified property.
RemoteRunProcess["host", command,prop,input] feeds the specified initial input to the command.
RemovalConditions
RemovalConditions is an option for AttachCell that specifies conditions under which to remove the attached cell.
Remove
Remove[s1,s2,…] removes the symbols si completely, so that their names are no longer recognized by the Wolfram Language.
Remove[patt1,patt2,…] removes all symbols whose names textually match any of the arbitrary string patterns patti.
Remove[{spec1,spec2,…}] removes any symbols that are equal to or whose names match any of the speci.
RemoveAlphaChannel
RemoveAlphaChannel[color] removes opacity from color.
RemoveAlphaChannel[color,bg] removes opacity by blending color with the background color bg.
RemoveAlphaChannel[image,…] removes opacity from all pixels in image.
RemoveAlphaChannel[video,…] removes opacity from frames of video.
RemoveAsynchronousTask
RemoveAsynchronousTask[asyncTask] stops asynchronous evaluations and removes asyncTask from the system.
RemoveAudioStream
RemoveAudioStream[] deletes all AudioStream objects.
RemoveAudioStream[stream] deletes the AudioStream object stream.
RemoveAudioStream[audio] deletes all the AudioStream objects stemming from audio.
RemoveBackground
RemoveBackground[image] returns an image with an alpha channel where the background is transparent.
RemoveBackground[image,model] uses foreground or background model specification.
RemoveBackground[video,…] performs background removal on frames of video.
RemoveChannelListener
RemoveChannelListener[obj] removes obj from the list of currently active channel listeners.
RemoveChannelListener[{obj1,obj2,…}] removes all the obji.
RemoveChannelListener[] removes all currently active channel listeners.
RemoveChannelSubscribers
RemoveChannelSubscribers[channel] removes all subscribers from the specified channel.
RemoveChannelSubscribers[channel,user] removes the specified user from the subscriber list.
RemoveChannelSubscribers[channel,{user1,user2,…}] removes the specified subscribers useri.
Removed
Removed[string] is printed to indicate a symbol that has been removed.
RemoveDiacritics
RemoveDiacritics[string] replaces characters in string that have diacritics by their base ASCII characters, when possible.
RemoveInputStreamMethod
RemoveInputStreamMethod["name"] removes a custom input stream method.
RemoveOutputStreamMethod
RemoveOutputStreamMethod["name"] removes a custom output stream method.
RemoveProperty
RemoveProperty[{obj,itemspec}] removes all properties associated with itemspec in obj.
RemoveProperty[{obj,itemspec},name] removes the property name associated with itemspec in obj.
RemoveUsers
RemoveUsers[group,{user1,…}] removes the users useri from the permissions group group.
RemoveVideoStream
RemoveVideoStream[] deletes all VideoStream objects.
RemoveVideoStream[stream] deletes the VideoStream object stream.
RenameDirectory
RenameDirectory[dir1,dir2] renames the directory dir1 to dir2.
RenameFile
RenameFile[file1,file2] renames file1 to file2.
RenderAll
RenderAll is an option for Graphics3D that specifies whether or not PostScript should be generated for all polygons.
RenderingOptions
RenderingOptions is an option for Style, Cell and related constructs that specifies options related to 3D rendering.
RenewalProcess
RenewalProcess[rdist] represents a renewal process with interarrival times distributed according to rdist.
RenkoChart
RenkoChart[{{date1,p1},{date2,p2},…}] makes a Renko chart with prices pi at date datei.
RenkoChart[{"name",daterange}] makes a Renko chart of closing prices for the financial entity "name" over the date range daterange.
RenkoChart[{…},s] makes a Renko chart with brick height of fraction s of the average price.
RepairMesh
RepairMesh[mreg] repairs defects in the mesh region mreg.
RepairMesh[mreg,{def1,…}] repairs only the specified defects def1,….
Repeated
p.. or Repeated[p] is a pattern object that represents a sequence of one or more expressions, each matching p.
Repeated[p,max] represents from 1 to max expressions matching p.
Repeated[p,{min,max}] represents between min and max expressions matching p.
Repeated[p,{n}] represents exactly n expressions matching p.
RepeatedNull
p... or RepeatedNull[p] is a pattern object that represents a sequence of zero or more expressions, each matching p.
RepeatedNull[p,max] represents from 0 to max expressions matching p.
RepeatedNull[p,{min,max}] represents between min and max expressions matching p.
RepeatedNull[p,{n}] represents exactly n expressions matching p.
RepeatedTiming
RepeatedTiming[expr] evaluates expr repeatedly and returns a list of the average time in seconds used, together with the result obtained.
RepeatedTiming[expr,t] does repeated evaluation for at least t seconds.
RepeatingElement
RepeatingElement[spec] represents an arbitrarily repeated type of element in an interpreter, API or form specification.
RepeatingElement[spec,max] represents an element that can appear at most max times.
RepeatingElement[spec,{min,max}] represents an element that can appear between min and max times.
RepeatingElement[spec,{n,{min,max}}] represents an element that initially appears n times in a form.
RepeatingElement[spec,{{i,n},{min,max}}] represents an element where i takes successive values.
Replace
Replace[expr,rules] applies a rule or list of rules in an attempt to transform the entire expression expr.
Replace[expr,rules,levelspec] applies rules to parts of expr specified by levelspec.
Replace[rules] represents an operator form of Replace that can be applied to an expression.
ReplaceAll
expr/.rules or ReplaceAll[expr,rules] applies a rule or list of rules in an attempt to transform each subpart of an expression expr.
ReplaceAll[rules] represents an operator form of ReplaceAll that can be applied to an expression.
ReplaceImageValue
ReplaceImageValue[image,pos->val] changes the pixel values at position pos in image to val.
ReplaceImageValue[image,pos->val,"type"] assumes val to be of the specified type.
ReplaceList
ReplaceList[expr,rules] attempts to transform the entire expression expr by applying a rule or list of rules in all possible ways, and returns a list of the results obtained.
ReplaceList[expr,rules,n] gives a list of at most n results.
ReplaceList[rules] is an operator form of ReplaceList that can be applied to an expression.
ReplacePart
ReplacePart[expr,i->new] yields an expression in which the ith part of expr is replaced by new.
ReplacePart[expr,{i1->new1,i2->new2,…}] replaces parts at positions in by newn.
ReplacePart[expr,{i,j,…}->new] replaces the part at position {i,j,…}.
ReplacePart[expr,{{i1,j1,…}->new1,…}] replaces parts at positions {in,jn,…} by newn.
ReplacePart[expr,{{i1,j1,…},…}->new] replaces all parts at positions {in,jn,…} by new.
ReplacePart[i->new] represents an operator form of ReplacePart that can be applied to an expression.
ReplacePixelValue
ReplacePixelValue[image,ppos->val] changes the pixel values at pixel position ppos in image to val.
ReplacePixelValue[image,ppos->val,"type"] assumes val to be of the specified type.
ReplaceRepeated
expr//.rules repeatedly performs replacements until expr no longer changes.
ReplaceRepeated[rules] represents an operator form of ReplaceRepeated that can be applied to an expression.
ReplicateLayer
ReplicateLayer[n] represents a net layer that takes an input of dimensions {d1,d2,…} and replicates it n times to produce an output of dimensions {n,d1,d2,…}.
ReplicateLayer[{n1,n2,…,nm}] represents a net layer that takes an input of dimensions {d1,d2,…} and replicates it to produce an output of dimensions {n1,n2,…,nm,d1,d2,…}.
ReplicateLayer[dims,m] replicates so that dims appears at position m in the list of output dimensions.
RequiredPhysicalQuantities
RequiredPhysicalQuantities is an option for FormulaLookup that specifies physical quantities that must be used by the formulas returned.
Resampling
Resampling is an option that specifies the method to be used for resampling images or arrays.
ResamplingAlgorithmData
ResamplingAlgorithmData[rs,"prop"] gives the specified property "prop" for the resampling rs.
ResamplingMethod
ResamplingMethod is an option for functions such as TemporalData and MovingMap that specifies how values in between given times should be computed.
Rescale
Rescale[x,{min,max}] gives x rescaled to run from 0 to 1 over the range min to max.
Rescale[x,{min,max},{ymin,ymax}] gives x rescaled to run from ymin to ymax over the range min to max.
Rescale[list] rescales each element of list to run from 0 to 1 over the range Min[list] to Max[list].
RescalingTransform
RescalingTransform[{{xmin,xmax},{ymin,ymax},…},{{xpmin,xpmax},…}] gives a TransformationFunction that rescales the region with coordinate ranges xmin to xmax, etc. to the region with coordinate ranges xpmin to xpmax, etc.
RescalingTransform[{{xmin,xmax},{ymin,ymax},…}] gives a TransformationFunction that rescales to the unit square, cube, etc.
ResetDirectory
ResetDirectory[] resets the current working directory to its previous value.
ResetScheduledTask
ResetScheduledTask[obj,timespec] resets the timing for a scheduled task to timespec.
ResetScheduledTask[obj,timespec,offset] resets the time offset for a scheduled task to offset.
ReshapeLayer
ReshapeLayer[spec] represents a net layer that reshapes the input array according to the specification spec.
Residue
Residue[expr,{z,z0}] finds the residue of expr at the point z=z0.
ResizeLayer
ResizeLayer[{d}] represents a layer performing one-dimensional resizing of a two-dimensional array.
ResizeLayer[{d1,…,dn}] represents a layer performing n-dimensional resizing of a (n+1)-dimensional array.
Resolve
Resolve[expr] attempts to resolve expr into a form that eliminates ForAll and Exists quantifiers.
Resolve[expr,dom] works over the domain dom. Common choices of dom are Complexes, Reals, and Booleans.
ResolveContextAliases
ResolveContextAliases is an option for Names, Contexts and related functions to control whether to resolve aliases when searching for symbols that match a string pattern.
ResourceData
ResourceData[resource] gives the primary content of the specified resource.
ResourceData[resource,elem] gives element elem of the content of the resource.
ResourceFunction
ResourceFunction[resource] represents the function associated with the specified resource.
ResourceFunction[resource,prop] gives the specified property of the resource.
ResourceObject
ResourceObject["name"] represents a resource with the specified name.
ResourceObject["uuid"] represents a resource with the specified UUID.
ResourceObject[loc] imports a resource from the specified location.
ResourceObject[assoc] gives a resource with content and metadata specified by the association assoc.
ResourceRegister
ResourceRegister[resource] creates a persistent cache of a resource object that can be referenced by name.
ResourceRegister[resource, loc] stores the resource in persistence location loc.
ResourceRegister[resource, {loc1,…}] stores the resource in multiple persistence locations.
ResourceRemove
ResourceRemove[resource] removes the specified resource from the system on which it is run.
ResourceSearch
ResourceSearch[form] gives a dataset of resources that contain text matching form.
ResourceSearch[form,prop] returns the property prop of the search results.
ResourceSubmit
ResourceSubmit[resource] submits the specified resource object to be reviewed for publication.
ResourceSubmit[new,old] submits the resource new as the updated version of the resource old.
ResourceUpdate
ResourceUpdate[resource] updates to the latest version of the specified resource object.
ResourceUpdate["name"] updates the resource with the specified name.
ResourceVersion
ResourceVersion is an option for ResourceObject, ResourceFunction and related functions for specifying the version of a resource.
ResponseForm
ResponseForm[expr,"fmt"] represents a response record to be given in a specified format when requested during the execution of a function specified by APIFunction, FormFunction, etc.
ResponseForm[expr,"fmt",{elem1,elem2,…}] includes only the response record elements elemi.
Rest
Rest[expr] gives expr with the first element removed.
RestartInterval
RestartInterval is an option controlling the restart behavior of functions such as ContinuousTask.
Restricted
Restricted[form,cond,…] represents a form for Interpreter and related functions restricted according to the conditions cond.
Resultant
Resultant[poly1,poly2,var] computes the resultant of the polynomials poly1 and poly2 with respect to the variable var.
Resultant[poly1,poly2,var,Modulus->p] computes the resultant modulo the prime p.
ResumePacket
ResumePacket[] is a WSTP packet used for synchronization with the Wolfram Language kernel.
Return
Return[expr] returns the value expr from a function.
Return[] returns the value Null.
ReturnExpressionPacket
ReturnExpressionPacket[expr] is a WSTP packet that contains the expression expr, the result of an EnterExpressionPacket evaluation.
ReturnPacket
ReturnPacket[expr] is a WSTP packet that contains the expression expr, the result of an EvaluatePacket evaluation.
ReturnReceiptFunction
ReturnReceiptFunction is an option for MailReceiverFunction that specifies what function to apply if a return receipt is requested for mail received by a MailReceiverFunction.
ReturnTextPacket
ReturnTextPacket[string] is a WSTP packet containing string, the result of an EnterTextPacket evaluation.
Reverse
Reverse[expr] reverses the order of the elements in expr.
Reverse[expr,n] reverses elements at level n in expr.
Reverse[expr,{n1,n2,…}] reverses elements at levels n1, n2, … in expr.
ReverseApplied
ReverseApplied[f] represents a form of f that takes arguments in reverse order so that ReverseApplied[f][x1,…,xn] is equivalent to f[xn,…,x1].
ReverseApplied[f,n] represents a form of f that reverses the first n arguments before evaluation.
ReverseElement
ReverseElement[x,y,…] displays as x∋y∋….
ReverseEquilibrium
ReverseEquilibrium[x,y,…] displays as x⇋y⇋….
ReverseGraph
ReverseGraph[g] gives the reverse graph of the directed graph g.
ReverseGraph[{v->w,…}] uses rules v->w to specify the graph g.
ReverseSort
ReverseSort[list] sorts the elements of list into reverse canonical order.
ReverseSort[list,p] sorts using the ordering function p.
ReverseSortBy
ReverseSortBy[list,f] sorts the elements of list using the reverse canonical order defined by applying f to each of them.
ReverseSortBy[list,f,p] sorts the elements of list using the function p to compare pairs of results of applying f to each element.
ReverseSortBy[f] represents an operator form of ReverseSortBy that can be applied to an expression.
ReverseUpEquilibrium
ReverseUpEquilibrium[x,y,…] displays as x⥯y⥯….
RevolutionAxis
RevolutionAxis is an option for RevolutionPlot3D which specifies the revolution axis around which the curve should be rotated.
RevolutionPlot3D
RevolutionPlot3D[fz,{t,tmin,tmax}] generates a plot of the surface of revolution with height fz at radius t.
RevolutionPlot3D[fz,{t,tmin,tmax},{θ,θmin,θmax}] takes the azimuthal angle θ to vary between θmin and θmax.
RevolutionPlot3D[{fx,fz},{t,tmin,tmax}] generates a plot of the surface obtained by rotating the parametric curve with x, z coordinates {fx,fz} around the z axis.
RevolutionPlot3D[{fx,fz},{t,tmin,tmax},{θ,θmin,θmax}] takes the azimuthal angle θ to vary from θmin to θmax.
RevolutionPlot3D[{fx,fy,fz},{t,tmin,tmax},…] plots the surface obtained by rotating the parametric curve with x, y, z coordinates {fx,fy,fz}.
RGBColor
RGBColor[r,g,b] represents a color in the RGB color space, using red, blue and green components.
RGBColor[r,g,b,a] specifies opacity a.
RGBColor["string"] returns a color from a hex color or an HTML color name.
RGBColor[color] returns the RGB representation of color.
RiceDistribution
RiceDistribution[α,β] represents a Rice distribution with shape parameters α and β.
RiceDistribution[m,α,β] represents a Norton–Rice distribution with parameters m, α, and β.
RidgeFilter
RidgeFilter[data] computes a measure for the presence of a ridge at every position of data.
RidgeFilter[data,σ] uses the specified ridge scale σ.
RiemannR
RiemannR[x] gives the Riemann prime counting function R(x).
RiemannSiegelTheta
RiemannSiegelTheta[t] gives the Riemann–Siegel function ϑ(t).
RiemannSiegelZ
RiemannSiegelZ[t] gives the Riemann–Siegel function Z(t).
RiemannXi
RiemannXi[s] gives the Riemann xi function ξ(s).
Right
Right is a symbol that represents the right-hand side for purposes of alignment and positioning.
RightArrow
RightArrow[x,y,…] displays as x→y→….
RightArrowBar
RightArrowBar[x,y,…] displays as x⇥y⇥….
RightArrowLeftArrow
RightArrowLeftArrow[x,y,…] displays as x⇄y⇄….
RightComposition
RightComposition[f1,f2,f3,…] represents a composition on the right of the functions f1, f2, f3, ….
RightCosetRepresentative
RightCosetRepresentative[group,g] returns the smallest element in the right coset of products of the elements of group by g.
RightDownTeeVector
RightDownTeeVector[x,y,…] displays as x⥝y⥝….
RightDownVector
RightDownVector[x,y,…] displays as x⇂y⇂….
RightDownVectorBar
RightDownVectorBar[x,y,…] displays as x⥕y⥕….
RightTee
RightTee[x,y] displays as x⊢y.
RightTeeArrow
RightTeeArrow[x,y,…] displays as x↦y↦….
RightTeeVector
RightTeeVector[x,y,…] displays as x⥛y⥛….
RightTriangle
RightTriangle[x,y,…] displays as x⊳y⊳….
RightTriangleBar
RightTriangleBar[x,y,…] displays as x⧐y⧐….
RightTriangleEqual
RightTriangleEqual[x,y,…] displays as x⊵y⊵….
RightUpDownVector
RightUpDownVector[x,y,…] displays as x⥏y⥏….
RightUpTeeVector
RightUpTeeVector[x,y,…] displays as x⥜y⥜….
RightUpVector
RightUpVector[x,y,…] displays as x↾y↾….
RightUpVectorBar
RightUpVectorBar[x,y,…] displays as x⥔y⥔….
RightVector
RightVector[x,y,…] displays as x⇀y⇀….
RightVectorBar
RightVectorBar[x,y,…] displays as x⥓y⥓….
RipleyK
RipleyK[pdata,r] estimates Ripley's K function K(r) at radius r for point data pdata.
RipleyK[pproc,r] computes K(r) for the point process pproc.
RipleyK[bdata,r] computes K(r) for binned data bdata.
RipleyK[pspec] generates the function K that can be applied repeatedly at different radii r.
RipleyRassonRegion
RipleyRassonRegion[pdata] gives an estimated observation based on the point data pdata.
RiskAchievementImportance
RiskAchievementImportance[rdist,t] gives the risk achievement importances for all components in the ReliabilityDistribution rdist at time t.
RiskAchievementImportance[fdist,t] gives the risk achievement importances for all components in the FailureDistribution fdist at time t.
RiskReductionImportance
RiskReductionImportance[rdist,t] gives the risk reduction importances for all components in the ReliabilityDistribution rdist at time t.
RiskReductionImportance[fdist,t] gives the risk reduction importances for all components in the FailureDistribution fdist at time t.
RobustConvexOptimization
RobustConvexOptimization[f,ForAll[pars,pcons,vcons],vars] finds values of vars that give the minimum value of f for vars that satisfy the constraints vcons for all possible values of the parameters pars that satisfy the parametric constraints pcons.
RobustConvexOptimization[…,"prop"] specifies what solution property "prop" should be returned.
RogersTanimotoDissimilarity
RogersTanimotoDissimilarity[u,v] gives the Rogers–Tanimoto dissimilarity between Boolean vectors u and v.
RollPitchYawAngles
RollPitchYawAngles[r] gives the roll-pitch-yaw angles {α,β,γ} corresponding to the rotation matrix r.
RollPitchYawAngles[r,{a,b,c}] gives the roll-pitch-yaw angles {α,β,γ} corresponding to rotation order {a,b,c}.
RollPitchYawMatrix
RollPitchYawMatrix[{α,β,γ}] gives the 3D rotation matrix formed by rotating by α around the initial z axis, then by β around the initial y axis, and then by γ around the initial x axis.
RollPitchYawMatrix[{α,β,γ},{a,b,c}] gives the 3D rotation matrix formed by rotating by α around the fixed a axis, then by β around the fixed b axis, and then by γ around the fixed c axis.
RomanNumeral
RomanNumeral[n] gives a string corresponding to the Roman numeral form of the integer n.
RootApproximant
RootApproximant[x] converts the number x to one of the "simplest" algebraic numbers that approximates it well.
RootApproximant[x,n] finds an algebraic number of degree at most n that approximates x.
RootIntervals
RootIntervals[{poly1,poly2,…}] gives a list of isolating intervals for the real roots of any of the polyi, together with a list of which polynomials actually have each successive root.
RootIntervals[poly] gives isolating intervals for real roots of a single polynomial.
RootIntervals[polys,Complexes] gives bounding rectangles for complex roots.
RootLocusPlot
RootLocusPlot[lsys,{k,kmin,kmax}] generates a root locus plot of a linear time-invariant system lsys as the parameter k ranges from kmin to kmax.
RootMeanSquare
RootMeanSquare[list] gives the root mean square of values in list.
RootMeanSquare[dist] gives the root mean square of the distribution dist.
RootOfUnityQ
RootOfUnityQ[a] yields True if a is a root of unity, and yields False otherwise.
RootReduce
RootReduce[expr] attempts to reduce expr to a single Root object.
Roots
Roots[lhs==rhs,var] yields a disjunction of equations which represent the roots of a polynomial equation.
RootSum
RootSum[f,form] represents the sum of form[x] for all x that satisfy the polynomial equation f[x]==0.
Rotate
Rotate[g,θ] represents 2D graphics primitives or any other objects g rotated counterclockwise by θ radians about the center of their bounding box.
Rotate[g,θ,{x,y}] rotates about the point {x,y}.
Rotate[g,{u,v}] rotates around the origin, transforming the 2D or 3D vector u to v.
Rotate[g,θ,w] rotates 3D graphics primitives by θ radians around the 3D vector w anchored at the origin.
Rotate[g,θ,w,p] rotates around the 3D vector w anchored at p.
Rotate[g,θ,{u,v}] rotates by angle θ in the plane spanned by 3D vectors u and v.
RotateLabel
RotateLabel is an option for graphics and related functions that specifies whether labels on vertical frame axes should be rotated to be vertical.
RotateLeft
RotateLeft[expr,n] cycles the elements in expr n positions to the left.
RotateLeft[expr] cycles one position to the left.
RotateLeft[expr,{n1,n2,…}] cycles elements at successive levels ni positions to the left.
RotateRight
RotateRight[expr,n] cycles the elements in expr n positions to the right.
RotateRight[expr] cycles one position to the right.
RotateRight[expr,{n1,n2,…}] cycles elements at successive levels ni positions to the right.
RotationAction
RotationAction is an option for three-dimensional graphics functions that specifies how to render 3D objects when they are interactively rotated.
RotationMatrix
RotationMatrix[θ] gives the 2D rotation matrix that rotates 2D vectors counterclockwise by θ radians.
RotationMatrix[θ,w] gives the 3D rotation matrix for a counterclockwise rotation around the 3D vector w.
RotationMatrix[{u,v}] gives the matrix that rotates the vector u to the direction of the vector v in any dimension.
RotationMatrix[θ,{u,v}] gives the matrix that rotates by θ radians in the plane spanned by u and v.
RotationTransform
RotationTransform[θ] gives a TransformationFunction that represents a rotation in 2D by θ radians about the origin.
RotationTransform[θ,p] gives a 2D rotation about the 2D point p.
RotationTransform[θ,w] gives a 3D rotation around the direction of the 3D vector w.
RotationTransform[θ,w,p] gives a 3D rotation around the axis w anchored at the point p.
RotationTransform[{u,v}] gives a rotation about the origin that transforms the vector u to the direction of the vector v.
RotationTransform[{u,v},p] gives a rotation about the point p that transforms u to the direction of v.
RotationTransform[θ,{u,v},…] gives a rotation by θ radians in the plane spanned by u and v.
Round
Round[x] gives the integer closest to x.
Round[x,a] rounds to the nearest multiple of a.
RoundingRadius
RoundingRadius is an option for Rectangle, Framed and related functions that specifies the radius of the circle to use in rendering rounded corners.
Row
Row[{expr1,expr2,…}] is an object that formats with the expri arranged in a row, potentially extending over several lines.
Row[list,s] inserts s as a separator between successive elements.
RowReduce
RowReduce[m] gives the row‐reduced form of the matrix m.
RSolve
RSolve[eqn,a[n],n] solves a recurrence equation for a[n].
RSolve[{eqn1,eqn2,…},{a1[n],a2[n],…},n] solves a system of recurrence equations.
RSolve[eqn,a[n1,n2,…],{n1,n2,…}] solves a partial recurrence equation.
RSolveValue
RSolveValue[eqn,expr,n] gives the value of expr determined by a symbolic solution to the ordinary difference equation eqn with independent variable n.
RSolveValue[{eqn1,eqn2,…},expr,…] uses a symbolic solution for a list of difference equations.
RSolveValue[eqn,expr,{n1,n2,…}] uses a solution for the partial recurrence equation eqn.
RudinShapiro
RudinShapiro[n] gives the nth term in the Rudin–Shapiro sequence.
RudvalisGroupRu
RudvalisGroupRu[] represents the sporadic simple Rudvalis group Ru.
Rule
lhs->rhs or lhs->rhs represents a rule that transforms lhs to rhs.
RuleCondition
RuleCondition is an internal symbol.
RuleDelayed
lhs:>rhs or lhsrhs represents a rule that transforms lhs to rhs, evaluating rhs only after the rule is used.
RulePlot
RulePlot[sys] generates a plot representing the rule for the computational system sys.
RulePlot[sys,init,t] generates a plot of the evolution of the system sys from initial condition init for t steps.
RulePlot[sys,evol] generates a plot of the evolution evol assuming it is derived from a system of the form sys.
RulerUnits
RulerUnits is an option for notebooks that specifies the units in the ruler toolbar.
RulesTree
RulesTree[data->{rule1,rule2,…}] gives a tree whose root contains data and that has children specified by the rulei.
Run
Run["command"] runs command as an external operating system command, returning the exit code obtained.
RunProcess
RunProcess["command"] runs the specified external command, returning information on the outcome.
RunProcess[{"command", arg 1, arg 2, …}] runs the specified command, with command-line arguments arg i.
RunProcess[command, "prop"] returns only the specified property.
RunProcess[command, prop, input] feeds the specified initial input to the command.
RunScheduledTask
RunScheduledTask[expr] schedules and starts a local scheduled task that will repeatedly evaluate expr once per second.
RunScheduledTask[expr,time] schedules and starts a task that will repeatedly evaluate expr every time seconds.
RunScheduledTask[expr,{time}] schedules and starts a task that will evaluate expr once after time seconds.
RunScheduledTask[expr,{time,count}] schedules and starts a task that will try evaluating expr once every time seconds up to count times.
RunScheduledTask[expr,timespec,start] schedules a task that will automatically start at start time.
RunScheduledTask[CloudObject[…]] asynchronously executes an existing cloud task or document generator.
RunThrough
RunThrough["command",expr] executes an external command, giving the printed form of expr as input and taking the output, reading it as Wolfram Language input, and returning the result.
RuntimeAttributes
RuntimeAttributes is an option for Compile that specifies attributes for the compiled function it creates.
RuntimeOptions
RuntimeOptions is an option for Compile that specifies runtime settings for the compiled function it creates.
RussellRaoDissimilarity
RussellRaoDissimilarity[u,v] gives the Russell–Rao dissimilarity between Boolean vectors u and v.
SameQ
lhs===rhs yields True if the expression lhs is identical to rhs, and yields False otherwise.
SameTest
SameTest is an option whose setting gives a pairwise comparison function to determine whether expressions should be considered the same.
SameTestProperties
SameTestProperties is an option for set operations on entity classes whose setting gives the properties that are used to decide whether two given entities are the same.
SampledEntityClass
SampledEntityClass[class,n] represents an entity class containing n entities from class.
SampledEntityClass[class,{m,n}] represents an entity class containing entities m through n of class.
SampleDepth
SampleDepth is an option for sound primitives that specifies how many bits should be used to encode sound amplitude levels.
SampledSoundFunction
SampledSoundFunction[f,n,r] is a sound primitive that represents a sound whose amplitude sampled r times a second is generated by applying the function f to successive integers from 1 to n.
SampledSoundList
SampledSoundList[{a1,a2,…},r] is a sound primitive that represents a sound whose amplitude has levels ai sampled r times a second.
SampleRate
SampleRate is an option that specifies the number of samples per second for sound and signal processing functions.
SamplingPeriod
SamplingPeriod is an option to StateSpaceModel etc. that specifies the sampling period.
SARIMAProcess
SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},v] represents a seasonal integrated autoregressive moving-average process with ARIMA coefficients ai, d, and bj; seasonal order s; seasonal ARIMA coefficients αi, δ, and βj; seasonal integration order δ; and normal white noise with variance v.
SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},Σ] represents a vector SARIMA process with coefficient matrices ai, bj, αi, and βj and covariance matrix Σ.
SARIMAProcess[{a1,…},{d1,…},{b1,…},{{s1,…},{α1,…},{δ1,…},{β1,…}},Σ] represents a vector SARIMA process with multiple integration orders di, seasonal orders sj, and seasonal integration orders δk.
SARIMAProcess[{a1,…,ap},d,{b1,…,bq},{s,{α1,…,αm},δ,{β1,…,βr}},v,init] represents a SARIMA process with initial data init.
SARIMAProcess[c,…] represents a SARIMA process with constant c.
SARMAProcess
SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},v] represents a weakly stationary seasonal autoregressive moving-average process with ARMA coefficients ai and bj, seasonal order s, seasonal ARMA coefficients αi and βj, and normal white noise with variance v.
SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},Σ] represents a weakly stationary vector SARMA process driven by normal white noise, with covariance matrix Σ.
SARMAProcess[{a1,…,ap},{b1,…,bq},{{s1,…},{α1,…,αm},{β1,…,βr}},Σ] represents a weakly stationary vector SARMA process with multiple seasonal orders si.
SARMAProcess[{a1,…,ap},{b1,…,bq},{s,{α1,…,αm},{β1,…,βr}},v,init] represents a SARMA process with initial data init.
SARMAProcess[c,…] represents a SARMA process with a constant c.
SASTriangle
SASTriangle[a,γ,b] returns a filled triangle with sides of length a and b and angle γ between them.
SatelliteData
SatelliteData[entity,property] gives the value of the specified property for the satellite entity.
SatelliteData[{entity1,entity2,…},property] gives a list of property values for the specified satellite entities.
SatelliteData[entity,property,annotation] gives the specified annotation associated with the given property.
SatisfiabilityCount
SatisfiabilityCount[bf] counts the number of possible combinations of variable values that yield True when supplied as arguments to the Boolean function bf.
SatisfiabilityCount[expr,{a1,a2,…}] counts the number of possible combinations of the ai that make the Boolean expression expr be true.
SatisfiabilityInstances
SatisfiabilityInstances[bf] attempts to find a choice of variables that makes the Boolean function bf yield True.
SatisfiabilityInstances[expr,{a1,a2,…}] attempts to find a choice of the ai that makes the Boolean expression expr be True.
SatisfiabilityInstances[…,…,m] attempts to find m choices of variables that yield True.
SatisfiableQ
SatisfiableQ[bf] gives True if a combination of values of variables exists that makes the Boolean function bf yield True.
SatisfiableQ[expr,{a1,a2,…}] gives True if a combination of values of the ai exists that makes the Boolean expression expr yield True.
Saturday
Saturday is a day of the week.
Save
Save["filename",symbol] appends definitions associated with the specified symbol to a file.
Save["filename","patt"] appends definitions associated with all symbols whose names match the string pattern "patt".
Save["filename","context`"] appends definitions associated with all symbols in the specified context.
Save["filename",{object1,object2,…}] appends definitions associated with several objects.
Saveable
Saveable is an option for notebooks that specifies whether a notebook can be saved.
SaveConnection
SaveConnection is an option for ServiceConnect that determines whether the connection should be saved in the authenticated user's account.
SaveDefinitions
SaveDefinitions is an option to Manipulate and related functions that specifies whether current definitions relevant for the evaluation of the expression being manipulated should automatically be saved.
SawtoothWave
SawtoothWave[x] gives a sawtooth wave that varies from 0 to 1 with unit period.
SawtoothWave[{min,max},x] gives a sawtooth wave that varies from min to max with unit period.
Scale
Scale[g,s] represents graphics primitives g scaled by a factor s.
Scale[g,s,{x,y,…}] scales with the point {x,y,…} kept fixed.
Scale[g,{sx,sy,…},…] scales by different factors along different axes.
Scaled
Scaled[{x,y,…}] gives the position of a graphical object in terms of coordinates scaled to run from 0 to 1 across the whole plot range in each direction.
Scaled[{dx,dy,…},{x0,y0,…}] gives a position obtained by starting at ordinary coordinates {x0,y0,…}, then moving by a scaled offset {dx,dy,…}.
ScaleDivisions
ScaleDivisions is an option for gauge functions that specifies how many tick marks should be drawn on the scale.
ScaleOrigin
ScaleOrigin is an option for gauge functions that describes how to position the scale on the gauge.
ScalePadding
ScalePadding is an option for gauge functions that specifies how much space to leave around the scale.
ScaleRanges
ScaleRanges is an option for gauge functions that describes how to draw sections of the scale.
ScaleRangeStyle
ScaleRangeStyle is an option for gauge functions to describe how to style different sections of the scale.
ScalingFunctions
ScalingFunctions is an option for ListPlot, BarChart, Histogram, and other plotting functions that specifies what scaling functions should be used.
ScalingMatrix
ScalingMatrix[{sx,sy,…}] gives the matrix corresponding to scaling by a factor si along each coordinate axis.
ScalingMatrix[s,v] gives the matrix corresponding to scaling by a factor s along the direction of the vector v.
ScalingTransform
ScalingTransform[{sx,sy,…}] gives a TransformationFunction that represents scaling by a factor si along each coordinate axis from the origin.
ScalingTransform[{sx,sy,…},p] gives scaling centered at the point p.
ScalingTransform[s,v] gives scaling by a factor s along the direction of the vector v.
ScalingTransform[s,v,p] gives scaling along the direction of v, centered at the point p.
Scan
Scan[f,expr] evaluates f applied to each element of expr in turn.
Scan[f,expr,levelspec] applies f to parts of expr specified by levelspec.
Scan[f] represents an operator form of Scan that can be applied to an expression.
ScheduledTask
ScheduledTask[expr,timespec] represents a scheduled task to be evaluated on the schedule defined by timespec.
ScheduledTaskActiveQ
ScheduledTaskActiveQ[obj] yields True if obj represents an active task, and False otherwise.
ScheduledTaskInformation
ScheduledTaskInformation[cloudobj] returns the properties of the ScheduledTask cloudobj.
ScheduledTaskInformation[cloudobj,property] returns the value of the property property.
ScheduledTaskObject
ScheduledTaskObject[id,expr,spec,…] is a task object specifying future evaluation of expr according to spec.
ScheduledTasks
ScheduledTasks[] returns a list of ScheduledTaskObject and CloudObject expressions that represent current tasks.
SchurDecomposition
SchurDecomposition[m] yields the Schur decomposition for a numerical matrix m, given as a list {q,t} where q is an orthonormal matrix and t is a block upper‐triangular matrix.
SchurDecomposition[{m,a}] gives the generalized Schur decomposition of m with respect to a.
ScientificForm
ScientificForm[expr] prints with all real numbers in expr given in scientific notation.
ScientificForm[expr,n] prints with numbers given to n‐digit precision.
ScientificNotationThreshold
ScientificNotationThreshold is an option for NumberForm and related functions that specifies the threshold between the use of decimal notation and scientific notation to represent real numbers.
ScorerGi
ScorerGi[z] gives the Scorer function Gi(z).
ScorerGiPrime
ScorerGiPrime[z] gives the derivative of the Scorer function Gi′(z).
ScorerHi
ScorerHi[z] gives the Scorer function Hi(z).
ScorerHiPrime
ScorerHiPrime[z] gives the derivative of the Scorer function Hi′(z).
ScreenRectangle
ScreenRectangle is a global option that specifies the position of the primary screen by giving the coordinates of two diagonally opposite corners.
ScreenStyleEnvironment
ScreenStyleEnvironment is an option for notebooks that specifies the style environment to be used in displaying a notebook on the screen.
ScriptBaselineShifts
ScriptBaselineShifts is an option for Style that specifies the minimum distance in x‐heights to shift subscripts and superscripts.
ScriptLevel
ScriptLevel is an option for selections that is used in determining the font size of modifiers such as subscripts and superscripts in a nested expression.
ScriptMinSize
ScriptMinSize is an option for Style which specifies the minimum font size to use in rendering subscripts, etc.
ScriptSizeMultipliers
ScriptSizeMultipliers is an option for Style that specifies how much smaller to render each successive level of subscripts, etc.
Scrollbars
Scrollbars is an option for Pane that specifies whether scrollbars should be displayed.
ScrollingOptions
ScrollingOptions is an option for notebooks that specifies settings for scrolling.
ScrollPosition
ScrollPosition is an option for Pane that specifies the scroll position of the contents of the pane.
SearchAdjustment
SearchAdjustment[query,w] represents a component of a search query that is to be treated as having weight w.
SearchAdjustment[query,…,opts] represents a component of a search query with certain options.
SearchIndexObject
SearchIndexObject[loc] represents a search index object, as created by CreateSearchIndex.
SearchIndexObject["name"] represents the search index with the specified name in the SearchIndices[] list.
SearchIndices
SearchIndices[] returns a list with all the locally stored instances of SearchIndexObject.
SearchQueryString
SearchQueryString["query"] represents a search engine-style query in TextSearch and related functions.
SearchResultObject
SearchResultObject[…] represents a result from TextSearch[…] and related functions.
Sec
Sec[z] gives the secant of z.
Sech
Sech[z] gives the hyperbolic secant of z.
SechDistribution
SechDistribution[μ,σ] represents the hyperbolic secant distribution with location parameter μ and scale parameter σ.
SechDistribution[] represents the hyperbolic secant distribution with location parameter 0 and scale parameter 1.
SecondOrderConeOptimization
SecondOrderConeOptimization[f,cons,vars] finds values of variables vars that minimize the linear objective f subject to second-order cone and/or linear constraints cons.
SecondOrderConeOptimization[c,{{a1,b1,α1,β1},…,{ak,bk,αk,βk}}] finds a vector x that minimizes c.x subject to the constraints ai.x+bi≤αi.x+βi.
SecondOrderConeOptimization[c,…,{dom1,dom2,…}] takes xi to be in the domain domi, where domi is Integers or Reals.
SecondOrderConeOptimization[…,"prop"] specifies what solution property "prop" should be returned.
SectorChart
SectorChart[{{x1,y1},{x1,y2},…}] makes a sector chart with sector angles proportional to xi and radii yi.
SectorChart[{…,wi[{xi,yi},…],…,wj[{xj,yj},…],…}] makes a sector chart with sector features defined by the symbolic wrappers wk.
SectorChart[{data1,data2,…}] makes a sector chart from multiple datasets datai.
SectorChart3D
SectorChart3D[{{x1,y1,z1},{x2,y2,z2},…}] makes a 3D sector chart with sector angle proportional to xi, radius yi, and height zi.
SectorChart3D[{…,wi[{xi,yi,zi},…],…,wj[{xj,yj,zj},…],…}] makes a 3D sector chart with sector features defined by the symbolic wrappers wk.
SectorChart3D[{data1,data2,…}] makes a 3D sector chart from multiple datasets datai.
SectorOrigin
SectorOrigin is an option to PieChart and related functions that specifies where sectors should start.
SectorSpacing
SectorSpacing is an option to PieChart and related functions that specifies radial spacing of sectors.
SecuredAuthenticationKey
SecuredAuthenticationKey[assoc] represents a secured authentication key with credentials and details specified by the association assoc.
SecuredAuthenticationKeys
SecuredAuthenticationKeys[] retrieves a list of all instances of SecuredAuthenticationKey owned by the currently connected user.
SecuredAuthenticationKeys["name"] retrieves a SecuredAuthenticationKey identified by "name" owned by the currently connected user, if it exists.
SecurityCertificate
SecurityCertificate[assoc] represents the security certificate issued for a public key.
SeedRandom
SeedRandom[s] resets the pseudorandom generator, using s as a seed.
SeedRandom[] resets the generator, using as a seed the time of day and certain attributes of the current Wolfram System session.
Select
Select[data,crit] picks out all elements ei of data for which crit[ei] is True.
Select[data,crit->prop] returns the property prop of the selected elements.
Select[data,crit,n] picks out the first n elements for which crit[ei] is True.
Select[crit] represents an operator form of Select that can be applied to an expression.
SelectComponents
SelectComponents[{image,lmat},crit] selects components of image indicated by the label matrix lmat that satisfy crit, replacing other parts with black.
SelectComponents[image,crit] selects connected components of image.
SelectComponents[…,"prop",n] computes the property "prop" and selects the first n in sorted order.
SelectComponents[…,"prop",n,p] sorts computed properties using the ordering function p.
SelectedCells
SelectedCells[notebook] returns a list of CellObject expressions corresponding to the currently selected cells in notebook.
SelectedCells[] returns the currently selected cells in the notebook in which this function is being evaluated.
SelectFirst
SelectFirst[data,crit] gives the first ei of data for which crit[ei] is True, or Missing["NotFound"] if none is found.
SelectFirst[data,crit->prop] returns the property prop of the selected elements.
SelectFirst[data,crit,default] gives default if there is no ei of data such that crit[ei] is True.
SelectFirst[crit] represents an operator form of SelectFirst that can be applied to an expression.
SelfLoopStyle
SelfLoopStyle is an option for GraphPlot and related functions that specifies how to draw self-loops that connect a vertex to itself.
SemanticImport
SemanticImport[file] attempts to import a file semantically to give a Dataset object.
SemanticImport[file,type] attempts to interpret all elements in the file as being of the specified type.
SemanticImport[file,{type1,type2,…}] attempts to interpret elements in successive columns as being of the specified types.
SemanticImport[file,<|col1->type1,col2->type2,…|>] keeps only the columns coli specified by their positions or names.
SemanticImport[file,typespec,form] puts the result in the specified form.
SemanticImportString
SemanticImportString["string"] attempts to import a string semantically to give a Dataset object.
SemanticImportString["string",type] attempts to interpret all elements in the string as being of the specified type.
SemanticImportString["string",{type1,type2,…}] attempts to interpret elements in successive columns as being of the specified types.
SemanticImportString["string",<|col1->type1,col2->type2,…|>] attempts to interpret elements in the named columns as being of the specified types.
SemanticImportString["string",typespec,form] puts the result in the specified form.
SemanticInterpretation
SemanticInterpretation["string"] attempts to give the best semantic interpretation of the specified free-form string as a Wolfram Language expression.
SemanticInterpretation["string",pattern] filters possible semantic interpretations, returning the best one that matches the specified pattern.
SemanticInterpretation["string",pattern,head] returns the semantic interpretation wrapped with the specified head.
SemialgebraicComponentInstances
SemialgebraicComponentInstances[ineqs,{x1,x2,…}] gives at least one sample point in each connected component of the semialgebraic set defined by the inequalities ineqs in the variables x1, x2, ….
SendMail
SendMail[body] sends mail consisting of body to the address specified by $CloudUserID.
SendMail[{"subject"}] sends mail with the specified subject and no body.
SendMail[{"subject",body}] sends mail with the specified subject and body.
SendMail[{"subject",body,att}] sends mail with the attachment or attachments att.
SendMail["to",content] sends mail to the specified To: address.
SendMail[{to1,to2,…},content] sends mail to multiple To: addresses.
SendMail[{{to1,…},{cc1,…}},content] includes the cci as Cc: addresses.
SendMail[{{to1,…},{cc1,…},{bcc1,…}},content] also includes the bcci as Bcc: addresses.
SendMail[assoc] sends mail with elements specified in the association assoc.
SendMessage
SendMessage[channel,message] sends a message to the specified channel.
SendMessage[channel->dest,message] sends a message to the destination dest through the specified channel.
Sequence
Sequence[expr1,expr2,…] represents a sequence of arguments to be spliced automatically into any function.
SequenceAlignment
SequenceAlignment[s1,s2] finds an optimal alignment of sequences of elements in the strings, lists or biomolecular sequences s1 and s2, and yields a list of successive matching and differing sequences.
SequenceAttentionLayer
SequenceAttentionLayer[] is equivalent to AttentionLayer[] with a single "Input" port instead of ports "Key" and "Value". It should no longer be used.
SequenceAttentionLayer[net] is equivalent to AttentionLayer[net] with a single "Input" port instead of ports "Key" and "Value". It should no longer be used.
SequenceCases
SequenceCases[list,patt] gives a list of the sublists in list that match the sequence pattern patt.
SequenceCases[list,patt->rhs] gives a list of the values of rhs corresponding to sublists that match patt.
SequenceCases[list,patt,n] includes only the first n matches.
SequenceCount
SequenceCount[list,sub] gives a count of the number of times sub appears as a sublist of list.
SequenceCount[list,patt] gives the number of sublists in list that match the general sequence pattern patt.
SequenceFold
SequenceFold[f,{x1,…,xn},{a1,a2,…}] gives the last element of SequenceFoldList[f,{x1,…,xn},{a1,a2,…}].
SequenceFold[f,{x1,…,xn},{a1,a2,…},k] applies f to k arguments at each step, with the first n coming from the xi or previous results, and the last k-n coming from the ai.
SequenceFoldList
SequenceFoldList[f,{x1,…,xn},{a1,a2,…}] gives {x1,…,xn,f[x1,…,xn,a1],f[x2,…,xn,f[x1,…,xn,a1],a2],…}.
SequenceFoldList[f,{x1,…,xn},{a1,a2,…},k] applies f to k arguments at each step, with the first n coming from the xi or previous results, and the last k-n coming from the ai.
SequenceForm
SequenceForm[expr1,expr2,…] prints as the textual concatenation of the printed forms of the expri.
SequenceHold
SequenceHold is an attribute that specifies that Sequence objects appearing in the arguments of a function should not automatically be flattened out.
SequenceIndicesLayer
SequenceIndicesLayer[] represents a net layer that produces a list of indices for an input sequence.
SequenceLastLayer
SequenceLastLayer[] represents a net that takes a sequence of inputs and returns the last element of the sequence.
SequenceMostLayer
SequenceMostLayer[] represents a net that takes a sequence of inputs and removes its last element.
SequencePosition
SequencePosition[list,sublist] gives a list of the starting and ending positions at which sublist appears in list.
SequencePosition[list,patt] gives all positions at which sequences matching patt occur in list.
SequencePosition[list,patt,n] includes only the first n occurrences of patt.
SequencePredict
SequencePredict[{seq1,seq2,…}] generates a SequencePredictorFunction[…] based on the sequences given.
SequencePredict[training,seq] attempts to predict the next element in the sequence seq from the training sequences given.
SequencePredict[training,{seq1,seq2,…}] gives predictions for each of the sequences seqi.
SequencePredict["name",seq] uses the built-in sequence predictor represented by "name".
SequencePredict[…,seq,prop] give the specified property of the prediction associated with seq.
SequencePredictorFunction
SequencePredictorFunction[…] represents a function generated by SequencePredict that predicts the next elements from a sequence.
SequenceReplace
SequenceReplace[list,rules] replaces sequences in list according to the specified rule or list of rules.
SequenceReplace[list,rules,n] does only the first n replacements.
SequenceReplace[rules] represents an operator form of SequenceReplace that can be applied to an expression.
SequenceRestLayer
SequenceRestLayer[] represents a net that takes a sequence of inputs and removes its first element.
SequenceReverseLayer
SequenceReverseLayer[] represents a net that reverses the order of an input sequence.
SequenceSplit
SequenceSplit[list,patt] splits list into sublists separated by sequences that match the sequence pattern patt.
SequenceSplit[list,patt->rhs] inserts rhs at the position of each matched sequence.
SequenceSplit[list,{patt1->rhs1,…}] inserts rhsi at the position of each patti.
SequenceSplit[list,patt,n] splits into at most n sublists.
SeriesCoefficient
SeriesCoefficient[series,n] finds the coefficient of the nth-order term in a power series in the form generated by Series.
SeriesCoefficient[f,{x,x0,n}] finds the coefficient of (x-x0)n in the expansion of f about the point x=x0.
SeriesCoefficient[f,{x,x0,nx},{y,y0,ny},…] finds a coefficient in a multivariate series.
SeriesData
SeriesData[x,x0,{a0,a1,…},nmin,nmax,den] represents a power series in the variable x about the point x0. The ai are the coefficients in the power series. The powers of (x-x0) that appear are nmin/den, (nmin+1)/den, …, nmax/den.
SeriesTermGoal
SeriesTermGoal is an option for Asymptotic, DiscreteAsymptotic and similar functions that specifies the number of desired terms in an asymptotic approximation.
ServiceConnect
ServiceConnect["service"] creates a connection to an external service.
ServiceConnect["service",id] uses the specified connection identifier.
ServiceDisconnect
ServiceDisconnect[service] disconnects from an external service specified by a ServiceObject.
ServiceExecute
ServiceExecute[service,"req"] executes "req" on an external service.
ServiceExecute[service,"req",{par1->val1,…}] executes "req" with the specified settings for parameters.
ServiceExecute[req] executes ServiceRequest req on an external service.
ServiceObject
ServiceObject["service",…] represents an open connection to an external service.
ServiceRequest
ServiceRequest[service,"req"] represents a service request built from service, which might be a connected ServiceObject or a valid service name, and request "req".
ServiceRequest[service,"req",param] represents a service request, built from the service service, request "req" and parameters param.
ServiceRequest[assoc] represents a service request, built from association assoc.
ServiceSubmit
ServiceSubmit[ServiceRequest[assoc]] submits a request to be executed by an external service specified by assoc.
ServiceSubmit[ScheduledTask[req,spec]] submits a task to evaluate ServiceRequest req on an external service following the schedule defined by spec.
ServiceSubmit[ContinuousTask[req,spec]] submits a task to evaluate ServiceRequest req on an external service; the result of the request is updated whenever available.
SessionSubmit
SessionSubmit[expr] submits an asynchronous task to evaluate expr in the current session.
SessionSubmit[ScheduledTask[expr,spec]] submits a task to evaluate expr in the current session on the schedule defined by spec.
SessionTime
SessionTime[] gives the total number of seconds of real time that have elapsed since the beginning of your Wolfram System session.
Set
lhs=rhs evaluates rhs and assigns the result to be the value of lhs. From then on, lhs is replaced by rhs whenever it appears.
{l1,l2,…}={r1,r2,…} evaluates the ri, and assigns the results to be the values of the corresponding li.
SetAccuracy
SetAccuracy[expr,a] yields a version of expr in which all numbers have been set to have accuracy a.
SetAlphaChannel
SetAlphaChannel[color] adds full opacity to color.
SetAlphaChannel[color,a] adds opacity a to color.
SetAlphaChannel[image,…] adds an alpha channel to image.
SetAlphaChannel[video,…] adds an alpha channel to the frames of video.
SetAttributes
SetAttributes[symbol,attr] adds attr to the list of attributes of the symbol symbol.
SetAttributes["symbol",attr] adds attr to the attributes of the symbol named "symbol" if it exists.
SetAttributes[s,{attr1,attr2,…}] sets several attributes at a time.
SetAttributes[{s1,s2,…},attrs] sets attributes of several symbols at a time.
SetCookies
SetCookies[assoc] sets cookies with attributes specified by the association assoc, to be used by functions such as URLExecute.
SetCookies[{assoc1,assoc2,…}] sets a list of cookies.
SetDelayed
lhs:=rhs assigns rhs to be the delayed value of lhs. rhs is maintained in an unevaluated form. When lhs appears, it is replaced by rhs, evaluated afresh each time.
SetDirectory
SetDirectory["dir"] sets the current working directory to dir.
SetDirectory[] sets the current working directory to your "home" directory.
SetEnvironment
SetEnvironment["var"->value] sets the value of an operating system environment variable.
SetEnvironment[{"var"->value,…}] sets values for several environment variables.
SetFileDate
SetFileDate["file"] sets the modification and access dates for a file to be the current date.
SetFileFormatProperties
SetFileFormatProperties["fmt","prop"->val] sets the value of a property "prop" for the specified format "fmt".
SetFileFormatProperties["fmt",{prop1->val1,prop2->val2,…}] sets the value of multiple properties "propi".
SetOptions
SetOptions[s,name1->value1,name2->value2,…] sets the specified default options for a symbol s.
SetOptions[stream,…] or SetOptions["name",…] sets options associated with a particular stream.
SetOptions[object,…] sets options associated with an external object such as a NotebookObject or CloudObject.
SetPrecision
SetPrecision[expr,p] yields a version of expr in which all numbers have been set to have precision p.
SetProperty
SetProperty[{obj,itemspec},name->value] sets the property name->value for itemspec in obj.
SetSharedFunction
SetSharedFunction[f1,f2,…] declares the symbols fi as shared functions that are synchronized among all parallel kernels.
SetSharedVariable
SetSharedVariable[s1,s2,…] declares the symbols si as shared variables whose values are synchronized among all parallel kernels.
SetStreamPosition
SetStreamPosition[stream,n] sets the current point in an open stream.
Shallow
Shallow[expr] prints as a shallow form of expr.
Shallow[expr,depth] prints with all parts of expr below the specified depth given in skeleton form.
Shallow[expr,{depth,length}] also gives parts whose lengths are above the specified limit in skeleton form.
Shallow[expr,{depth,length},form] uses skeleton form for any parts that match the pattern form.
ShannonWavelet
ShannonWavelet[] represents the Shannon wavelet evaluated on the equally spaced interval {-10,10}.
ShannonWavelet[lim] represents the Shannon wavelet evaluated on the equally spaced interval {-lim,lim}.
ShapiroWilkTest
ShapiroWilkTest[data] tests whether data is normally distributed using the Shapiro–Wilk test.
ShapiroWilkTest[data,"property"] returns the value of "property".
Share
Share[expr] changes the way expr is stored internally, to try and minimize the amount of memory used.
Share[] tries to minimize the memory used to store all expressions.
SharingList
SharingList is an option for CloudObject and related constructs that specifies with whom the object has been shared.
Sharpen
Sharpen[image] gives a sharpened version of image.
Sharpen[image,r] gives a version of image sharpened over pixel radius r.
ShearingMatrix
ShearingMatrix[θ,v,n] gives the matrix corresponding to shearing by θ radians along the direction of the vector v, and normal to the vector n.
ShearingTransform
ShearingTransform[θ,v,n] gives a TransformationFunction that represents a shear by θ radians along the direction of the vector v, normal to the vector n, and keeping the origin fixed.
ShearingTransform[θ,v,n,p] gives a shear that keeps the point p fixed, rather than the origin.
ShellRegion
ShellRegion[reg] gives a solid shell of a 3D region reg.
ShellRegion[reg,t] gives a solid shell of reg with minimal thickness t.
ShiftedGompertzDistribution
ShiftedGompertzDistribution[λ,ξ] represents a shifted Gompertz distribution with scale parameter λ and shape parameter ξ.
ShiftRegisterSequence
ShiftRegisterSequence[n] gives a complete maximum-length sequence for a size n linear-feedback shift register.
ShiftRegisterSequence[{n,{tap1,tap2,…}}] gives the complete sequence for a linear-feedback shift register with size n and taps at positions tapi.
ShiftRegisterSequence[poly] gives the sequence for a linear-feedback shift register with feedback polynomial poly.
ShiftRegisterSequence[{n,{tap1,tap2,…},f}] gives the sequence for a shift register with feedback function f.
ShiftRegisterSequence[spec,s] gives the first s elements of the shift register sequence.
ShiftRegisterSequence[spec,init,s] gives the shift register sequence starting from state init.
Short
Short[expr] prints as a short form of expr, less than about one line long.
Short[expr,n] prints as a form of expr about n lines long.
ShortDownArrow
ShortDownArrow[x,y,…] displays as xy….
Shortest
Shortest[p] is a pattern object that matches the shortest sequence consistent with the pattern p.
ShortestMatch
ShortestMatch[p] is a string pattern object matching the shortest sequence of characters consistent with the string pattern p.
ShortestPathFunction
ShortestPathFunction[type,data] represents a function that gives the shortest path from a source vertex s to target vertex t in a graph.
ShortLeftArrow
ShortLeftArrow[x,y,…] displays as xy….
ShortRightArrow
ShortRightArrow[x,y,…] displays as xy….
ShortTimeFourier
ShortTimeFourier[data] returns the short-time Fourier transform (STFT) of data as a ShortTimeFourierData object.
ShortTimeFourier[data,n] uses partitions of length n.
ShortTimeFourier[data,n,d] uses partitions with offset d.
ShortTimeFourier[data,n,d,wfun] applies a smoothing window wfun to each partition.
ShortTimeFourier[data,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
ShortTimeFourierData
ShortTimeFourierData[assoc] represents the result and properties of a short-time Fourier transform (STFT) of a signal.
ShortUpArrow
ShortUpArrow[x,y,…] displays as xy….
Show
Show[graphics,options] shows graphics with the specified options added.
Show[g1,g2,…] shows several graphics combined.
ShowAutoSpellCheck
ShowAutoSpellCheck is an option for Cell that specifies whether to highlight misspelled words.
ShowAutoStyles
ShowAutoStyles is an option for Cell that specifies whether styles that are specified to be automatically used for various syntactic and other constructs should be shown.
ShowCellBracket
ShowCellBracket is an option for Cell that specifies whether to display the bracket that indicates the extent of the cell.
ShowCursorTracker
ShowCursorTracker is an option for Cell that specifies whether an elliptical spot should appear momentarily to guide the eye if the cursor position jumps.
ShowPageBreaks
ShowPageBreaks is a notebook option that specifies whether to indicate in the on‐screen display of a notebook where page breaks would occur if the notebook were printed.
ShrinkingDelay
ShrinkingDelay is an option for dynamic objects that specifies how long to delay before shrinking the size of the region in which the object is displayed to the actual size of the object.
SiderealTime
SiderealTime[] gives the right ascension of the local meridian for the current date and location.
SiderealTime[date] gives the right ascension of the local meridian for the specified date.
SiderealTime[loc] gives the right ascension of the local meridian for the specified location.
SiderealTime[loc,date] gives the right ascension of the local meridian for the specified date and location.
SiderealTime[{{loc1,date1},{loc2,date2},…}] gives the right ascensions of the local meridians for all specified locations on the specified dates.
SiderealTime[loc,date,func] uses func to determine what to return for extended locations.
SiderealTime["MeanTime",loc,date,func] gives the mean sidereal time for the specified date, location and aggregation function.
SiegelTheta
SiegelTheta[Ω,s] gives the Siegel theta function Θ (Ω,s) with Riemann modular matrix Ω and vector s.
SiegelTheta[{ν1,ν2},Ω,s] gives the Siegel theta function Θ [ν1,ν2]( Ω,s) with characteristics ν1 and ν2.
SierpinskiCurve
SierpinskiCurve[n] gives the line segments representing the nth-step Sierpiński curve.
SierpinskiMesh
SierpinskiMesh[n] gives a mesh region representing the nth-step Sierpiński triangle.
SierpinskiMesh[n,d] gives the nth-step Sierpiński sponge in dimension d.
Sign
Sign[x] gives -1, 0, or 1 depending on whether x is negative, zero, or positive.
Signature
Signature[list] gives the signature of the permutation needed to place the elements of list in canonical order.
SignedRankTest
SignedRankTest[data] tests whether the median of data is zero.
SignedRankTest[{data1,data2}] tests whether the median of data1-data2 is zero.
SignedRankTest[dspec,μ0] tests a location measure against μ0.
SignedRankTest[dspec,μ0,"property"] returns the value of "property".
SignedRegionDistance
SignedRegionDistance[reg,p] gives the minimum distance from the point p to the region reg if p is outside the region and the minimum distance to the complement of reg if p is inside the region.
SignedRegionDistance[reg] gives a RegionDistanceFunction[…] that can be applied repeatedly to different points.
SignificanceLevel
SignificanceLevel is an option to VarianceTest and similar functions that controls cutoffs for diagnostic tests as well as test conclusions.
SignPadding
SignPadding is an option for NumberForm and related functions that specifies whether padding should be inserted after signs.
SignTest
SignTest[data] tests whether the median of data is zero.
SignTest[{data1,data2}] tests whether the median of data1– data2 is zero.
SignTest[dspec,μ0] tests a location measure against μ0.
SignTest[dspec,μ0,"property"] returns the value of "property".
SimilarityRules
SimilarityRules is an option for functions such as SequenceAlignment that gives a list of rules for similarity scores to assume between pairs of elements.
SimpleGraph
SimpleGraph[g] gives the underlying simple graph from the graph g.
SimpleGraph[{v->w,…}] uses rules v->w to specify the graph g.
SimpleGraphQ
SimpleGraphQ[g] yields True if the graph g is a simple graph and False otherwise.
SimplePolygonQ
SimplePolygonQ[poly] gives True if the polygon poly is simple and False otherwise.
SimplePolyhedronQ
SimplePolyhedronQ[poly] gives True if the polyhedron poly is simple and False otherwise.
Simplex
Simplex[{p1,…,pk}] represents the simplex spanned by points pi.
Simplify
Simplify[expr] performs a sequence of algebraic and other transformations on expr and returns the simplest form it finds.
Simplify[expr,assum] does simplification using assumptions.
Sin
Sin[z] gives the sine of z.
Sinc
Sinc[z] gives sinc(z).
SinghMaddalaDistribution
SinghMaddalaDistribution[q,a,b] represents the Singh–Maddala distribution with shape parameters q and a and scale parameter b.
SingleLetterItalics
SingleLetterItalics is an option for Cell that specifies whether single‐letter names should be displayed in italics.
SingularValueDecomposition
SingularValueDecomposition[m] gives the singular value decomposition for a numerical matrix m as a list of matrices {u,σ,v}, where σ is a diagonal matrix and m can be written as u.σ.ConjugateTranspose[v].
SingularValueDecomposition[{m,a}] gives the generalized singular value decomposition of m with respect to a.
SingularValueDecomposition[m,k] gives the singular value decomposition associated with the k largest singular values of m.
SingularValueDecomposition[m,UpTo[k]] gives the decomposition for the k largest singular values, or as many as are available.
SingularValueList
SingularValueList[m] gives a list of the nonzero singular values of a matrix m.
SingularValueList[{m,a}] gives the generalized singular values of m with respect to a.
SingularValueList[m,k] gives the k largest singular values of m.
SingularValueList[{m,a},k] gives the k largest generalized singular values of m.
SingularValuePlot
SingularValuePlot[lsys] generates a plot of the singular values of the transfer function for the system lsys.
SingularValuePlot[lsys,{ωmin,ωmax}] plots for the frequency range ωmin to ωmax.
SingularValuePlot[expr,{ω,ωmin,ωmax}] plots expr using the variable ω.
SingularValues
SingularValues[m] gives the singular value decomposition for a numerical matrix m. The result is a list {u,w,v}, where w is the list of singular values, and m can be written as ConjugateTranspose[u]. DiagonalMatrix[w].v.
Sinh
Sinh[z] gives the hyperbolic sine of z.
SinhIntegral
SinhIntegral[z] gives the hyperbolic sine integral function Shi(z).
SinIntegral
SinIntegral[z] gives the sine integral function Si(z)=∫0zsin(t)/t dt.
SixJSymbol
SixJSymbol[{j1,j2,j3},{j4,j5,j6}] gives the values of the Wigner 6‐j symbol.
Skeleton
Skeleton[n] represents a sequence of n omitted elements in an expression printed with Short or Shallow. The standard print form for Skeleton is n.
SkeletonTransform
SkeletonTransform[image] gives the skeleton transform of image, in which the value of each skeleton pixel is its distance to the nearest background pixel.
SkeletonTransform[image,t] treats values above t as foreground.
SkellamDistribution
SkellamDistribution[μ1,μ2] represents a Skellam distribution with shape parameters μ1 and μ2.
Skewness
Skewness[data] gives the coefficient of skewness estimate for the elements in data.
Skewness[dist] gives the coefficient of skewness for the distribution dist.
SkewNormalDistribution
SkewNormalDistribution[μ,σ,α] represents a skew-normal distribution with shape parameter α, location parameter μ, and scale parameter σ.
SkinStyle
SkinStyle is an option of AnatomyPlot3D that specifies what style to use for automatically included skin subparts.
Skip
Skip[stream,type] skips one object of the specified type in an input stream.
Skip[stream,type,n] skips n objects of the specified type.
SliceContourPlot3D
SliceContourPlot3D[f,surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a contour plot of f over the slice surface surf as a function of x, y, and z.
SliceContourPlot3D[f,surf,{x,y,z}∈reg] restricts the surface to be within region reg.
SliceContourPlot3D[f,{surf1,surf2,…},…] generates contour plots over several slices.
SliceDensityPlot3D
SliceDensityPlot3D[f,surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a density plot of f over the slice surface surf as a function of x, y, and z.
SliceDensityPlot3D[f,surf,{x,y,z}∈reg] restricts the surface to be within region reg.
SliceDensityPlot3D[f,{surf1,surf2,…},…] generates density plots over several slices.
SliceDistribution
SliceDistribution[proc,t] represents the distribution of the process state at time t.
SliceDistribution[proc,{t1,…,tk}] represents the joint distribution of process states at times t1<⋯<tk.
SliceVectorPlot3D
SliceVectorPlot3D[{vx,vy,vz},surf,{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a vector plot of the field {vx,vy,vz} over the slice surface surf.
SliceVectorPlot3D[{vx,vy,vz},surf,{x,y,z}∈reg] restricts the surface surf to be within the region reg.
SliceVectorPlot3D[{vx,vy,vz},{surf1,surf2,…},…] generates vector plots over several slice surfaces surfi.
Slot
# represents the first argument supplied to a pure function.
#n represents the nth argument.
#name represents the value associated with key "name" in an association in the first argument.
Small
Small is a style or option setting that specifies that objects should be small.
SmallCircle
SmallCircle[x,y,…] displays as x∘y∘….
Smaller
Smaller is a style or option setting that specifies that objects should be smaller.
SmithDecomposition
SmithDecomposition[m] gives the Smith normal form decomposition of an integer matrix m.
SmithDelayCompensator
SmithDelayCompensator[sys,con] gives the Smith compensator for the time-delay system sys and the delay-free controller con.
SmithWatermanSimilarity
SmithWatermanSimilarity[u,v] gives a number representing the Smith–Waterman similarity between strings or vectors u and v.
SmithWatermanSimilarity[u,v] gives a number representing the Smith–Waterman similarity between strings, vectors or bio sequences u and v.
SmoothDensityHistogram
SmoothDensityHistogram[{{x1,y1},{x2,y2},…}] plots a smooth kernel histogram of the values {xi,yi}.
SmoothDensityHistogram[{{x1,y1},{x2,y2},…},espec] plots a smooth kernel histogram with estimator specification espec.
SmoothDensityHistogram[{{x1,y1},{x2,y2},…},espec,dfun] plots the distribution function dfun.
SmoothHistogram
SmoothHistogram[{x1,x2,…}] plots a smooth kernel histogram for the PDF of the values xi.
SmoothHistogram[{x1,x2,…},espec] plots a smooth kernel histogram with estimator specification espec.
SmoothHistogram[{x1,x2,…},espec,dfun] plots the distribution function dfun.
SmoothHistogram[{data1,data2,…},…] plots smooth kernel histograms for multiple datasets datai.
SmoothHistogram3D
SmoothHistogram3D[{{x1,y1},{x2,y2},…}] plots a 3D smooth kernel histogram of the values {xi,yi}.
SmoothHistogram3D[{{x1,y1},{x2,y2},…},espec] plots a 3D smooth kernel histogram with estimator specification espec.
SmoothHistogram3D[{{x1,y1},{x2,y2},…},espec,dfun] plots the distribution function dfun.
SmoothHistogram3D[{data1,data2,…},…] plots smooth kernel histograms for multiple datasets datai.
SmoothKernelDistribution
SmoothKernelDistribution[{x1,x2,…}] represents a smooth kernel distribution based on the data values xi.
SmoothKernelDistribution[{{x1,y1,…},{x2,y2,…},…}] represents a multivariate smooth kernel distribution based on the data values {xi,yi,…}.
SmoothKernelDistribution[…,bw] represents a smooth kernel distribution with bandwidth bw.
SmoothKernelDistribution[…,bw,ker] represents a smooth kernel distribution with bandwidth bw and smoothing kernel ker.
SmoothPointDensity
SmoothPointDensity[pdata] estimates the point density function μ(x) for point data pdata.
SmoothPointDensity[pdata,bw] estimates the density for point data pdata with bandwidth bw.
SmoothPointDensity[pdata,bw,ker] estimates the density for point data pdata with bandwidth bw and smoothing kernel ker.
SmoothPointDensity[bdata,…] estimates the point density function μ(x) for binned data bdata.
SmoothPointDensity[pproc,…] computes the density function μ(x) for point process pproc.
SnDispersion
SnDispersion[list] gives the Sn statistic of the elements in list.
SnDispersion[list,c] gives the Sn statistic with scaling factor c.
Snippet
Snippet[doc] gives a snippet of text from a document or other content object.
Snippet[doc,n] gives about n lines from the beginning.
Snippet[doc,-n] gives about n lines from the end.
Snippet[doc,n1;;n2] gives a span from lines n1 to n2
Snippet[doc,n1;;n2;;n3] gives a span from lines n1 to n2 in steps of n3.
Snippet[ContentObject[…],SearchResultObject[…]] gives contextual snippets from a content object based on search results.
SnippetsVideo
SnippetsVideo[video,n] returns a summary video based on n snippets from video.
SnippetsVideo[video,timespec] returns a summary video based on snippets taken at times specified by timespec.
SnubPolyhedron
SnubPolyhedron[poly] gives the snub polyhedron of poly by truncating some corners.
SocialMediaData
SocialMediaData["name"] gives information about the social media entity "name".
SocialMediaData["name","property"] gives the value of the specified property for the social media entity "name".
SocialMediaData[{"name",id},"property"] gives the value of a property for the specified identifier id.
Socket
Socket is a possible value returned by FileType and related functions.
SocketConnect
SocketConnect[address] makes a socket connection to the TCP host at the specified address and returns a SocketObject representing the connection.
SocketConnect[address,"protocol"] makes a connection to the host at address with the specified protocol.
SocketConnect[socket] makes a connection to a local socket opened in the current session.
SocketListen
SocketListen[socket,fun] starts listening on the specified socket, asynchronously applying fun whenever data is received on the socket.
SocketListen[port,fun] starts listening for active connections on the specified port of 127.0.0.1.
SocketListen[address,fun] starts listening for active connections on the specified address address on the local machine.
SocketListen[spec,opts] starts listening for active connections defined by spec using the options opts.
SocketListen[spec] starts listening for active connections defined by spec, but does not set up handler functions, etc.
SocketListener
SocketListener[…] represents a socket listener created by SocketListen.
SocketObject
SocketObject[…] represents a network socket connection.
SocketOpen
SocketOpen[port] opens a socket that accepts TCP connections to localhost:port and returns a SocketObject representing the socket.
SocketOpen[address] opens a socket that accepts TCP connections to the specified local address.
SocketOpen[address,"protocol"] opens a socket that accepts connections with the specified protocol.
SocketOpen[address,{"protocol","type"}] opens a socket that accepts connections of the specified protocol and type.
SocketReadMessage
SocketReadMessage[socket] reads the next available message on the specified socket, returning it as a byte array.
SocketReadyQ
SocketReadyQ[socket] tests if there is any data immediately available to read from the specified socket.
SocketReadyQ[socket,t] waits for up to t seconds to see if data becomes available to read.
Sockets
Sockets[] returns all active socket connections initiated by your current Wolfram Language session.
Sockets[All] returns all sockets connected to your current session, including remote sockets originating outside your current session.
Sockets[spec] returns only sockets specified by spec.
SocketWaitAll
SocketWaitAll[{socket1,socket2,…}] waits until there is data ready to read on all of the socketi.
SocketWaitNext
SocketWaitNext[{socket1,socket2,…}] waits until there is data ready to read on any of the socketi, then returns that socket.
SoftmaxLayer
SoftmaxLayer[] represents a softmax net layer.
SoftmaxLayer[n] represents a softmax net layer that uses level n as the normalization dimension.
SokalSneathDissimilarity
SokalSneathDissimilarity[u,v] gives the Sokal–Sneath dissimilarity between Boolean vectors u and v.
SolarEclipse
SolarEclipse[] gives the date of the next solar eclipse.
SolarEclipse[date] gives the date of the next solar eclipse after the specified date.
SolarEclipse[prop] gives the value of property prop for the next solar eclipse.
SolarEclipse[date,prop] gives the value of property prop for the next solar eclipse after date.
SolarTime
SolarTime[] gives the angle on the celestial equator between the Sun and the local antimeridian for the current location and date.
SolarTime[loc] gives the solar time angle for the specified location and current date.
SolarTime[date] gives the solar time angle for the specified date and current location.
SolarTime[loc,date] gives the solar time for the specified location and date.
SolarTime["MeanTime",loc,date] gives the mean solar time for the specified location and date.
SolidAngle
SolidAngle[p,{u1,…,ud}] gives the solid angle at the point p and spanned by the vectors u1,…,ud.
SolidAngle[p,reg] gives the solid angle subtended by the region reg.
SolidBoundaryLoadValue
SolidBoundaryLoadValue[pred,vars,pars] represents a boundary load condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
SolidBoundaryLoadValue[pred,vars,pars,lkeys] represents a boundary load condition with local parameters specified in pars[lkey].
SolidData
SolidData[entity,property] gives the value of the specified property for the solid entity.
SolidData[{entity1,entity2,…},property] gives a list of property values for the specified solid entities.
SolidData[entity,property,annotation] gives the specified annotation associated with the given property.
SolidDisplacementCondition
SolidDisplacementCondition[pred,vars,pars] represents a prescribed displacement on a solid boundary for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
SolidDisplacementCondition[pred,vars,pars,lkeys] represents a prescribed displacement with local parameters specified in pars[lkey].
SolidFixedCondition
SolidFixedCondition[pred,vars,pars] represents a fully constrained solid boundary for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
SolidMechanicsPDEComponent
SolidMechanicsPDEComponent[vars,pars] yields solid mechanics PDE terms with variables vars and parameters pars.
SolidMechanicsStrain
SolidMechanicsStrain[vars,pars,displ] yields a solid mechanics total strain with variables vars, parameters pars and displacements displ.
SolidMechanicsStress
SolidMechanicsStress[vars,pars,strain] yields solid mechanics internal stress with variables vars, parameters pars and total strain strain.
SolidMechanicsStress[vars,pars,strain,displacement] yields solid mechanics stress for nonlinear material laws.
SolidRegionQ
SolidRegionQ[reg] gives True if the 3D region reg is a solid region and False otherwise.
Solve
Solve[expr,vars] attempts to solve the system expr of equations or inequalities for the variables vars.
Solve[expr,vars,dom] solves over the domain dom. Common choices of dom are Reals, Integers, and Complexes.
SolveAlways
SolveAlways[eqns,vars] gives the values of parameters that make the equations eqns valid for all values of the variables vars.
SolveDelayed
SolveDelayed is an obsolete option to NDSolve. The option "EquationSimplification" should be used instead.
SolveValues
SolveValues[expr,vars] gives the values of vars determined by the solutions of the system expr.
SolveValues[expr,vars,dom] uses solutions over the domain dom. Common choices of dom are Reals, Integers and Complexes.
Sort
Sort[list] sorts the elements of list into canonical order.
Sort[list,p] sorts using the ordering function p.
SortBy
SortBy[list,f] sorts the elements of list in the order defined by applying f to each of them.
SortBy[list,{f1,f2,…}] breaks ties by successively using the values obtained from the fi.
SortBy[list,f,p] sorts the elements of list using the function p to compare the results of applying f to each element.
SortBy[f] represents an operator form of SortBy that can be applied to an expression.
SortedBy
SortedBy is an option that specifies a function by which to sort the results of a computation.
SortedEntityClass
SortedEntityClass[class,prop] represents an entity class derived from class by sorting according to the values of the property prop.
SortedEntityClass[class,prop->"order"] sorts according to prop in the order specified.
SortedEntityClass[class,{prop1,prop2,…}] breaks ties by successively using the values of the property specifications propi.
SortedEntityClass[class,sortspec,n] represents the first n entities of class when sorted by sortspec.
SortedEntityClass[class,sortspec,{m,n}] represents the entities m through n of class when sorted by sortspec.
Sound
Sound[primitives] represents a sound.
Sound[primitives,t] specifies that the sound should have duration t.
Sound[primitives,{tmin,tmax}] specifies that the sound should extend from time tmin to time tmax.
SoundNote
SoundNote[pitch] represents a music-like sound note with the specified pitch.
SoundNote[pitch,t] takes the note to have duration t.
SoundNote[pitch,{tmin,tmax}] takes the note to occupy the time interval tmin to tmax.
SoundNote[pitch,tspec,"style"] takes the note to be in the specified style.
SoundNote[pitch,tspec,"style",opts] uses the specified rendering options for the note.
SoundVolume
SoundVolume is an option to Sound and SoundNote and related functions that specifies the relative volume of the sound produced.
SourcePDETerm
SourcePDETerm[vars,f] represents a source term f with source coefficient f and model variables vars.
SourcePDETerm[vars,f,pars] uses model parameters pars.
Sow
Sow[e] specifies that e should be collected by the nearest enclosing Reap.
Sow[e,tag] specifies that e should be collected by the nearest enclosing Reap whose pattern matches tag.
Sow[e,{tag1,tag2,…}] specifies that e should be collected once for each pattern that matches a tagi.
SpaceCurveData
SpaceCurveData[entity,property] gives the value of the specified property for the space curve entity.
SpaceCurveData[{entity1,entity2,…},property] gives a list of property values for the specified space curve entities.
SpaceCurveData[entity,property,annotation] gives the specified annotation associated with the given property.
SpaceForm
SpaceForm[n] prints as n spaces.
Spacer
Spacer[w] displays as a spacer w printer's points wide.
Spacer[{w,h}] displays as a spacer w points wide and a total of h points high.
Spacer[{w,h,dh}] makes the spacer extend dh points below the baseline.
Spacings
Spacings is an option to Grid and related constructs that specifies the spacings to leave between successive objects.
Span
i;;j represents a span of elements i through j.
i;; represents a span from i to the end.
;;j represents a span from the beginning to j.
;; represents a span that includes all elements.
i;;j;;k represents a span from i through j in steps of k.
i;;;;k represents a span from i to the end in steps of k.
;;j;;k represents a span from the beginning to j in steps of k.
;;;;k represents a span from the beginning to the end in steps of k.
SpanAdjustments
SpanAdjustments is an option for selections that specifies the height and width of spanning characters.
SpanCharacterRounding
SpanCharacterRounding is an option for selections that specifies the method used for rounding a spanning character when its size is to be adjusted.
SpanFromAbove
SpanFromAbove is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears above it.
SpanFromBoth
SpanFromBoth is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears above and to its left.
SpanFromLeft
SpanFromLeft is a symbol that can appear at a particular position in a Grid or related construct to indicate that the corresponding position is occupied by a spanning element that appears to its left.
SpanLineThickness
SpanLineThickness is an option for selections that specifies the thickness in printer's points of line-spanning characters such as ∖[VerticalLine] and ∖[HorizontalLine].
SpanMaxSize
SpanMaxSize is an option for selections that specifies the maximum size of spanning characters such as parentheses and brackets.
SpanMinSize
SpanMinSize is an option for selections that specifies the minimum size of spanning characters such as parentheses and brackets.
SpanSymmetric
SpanSymmetric is an option for selections that specifies whether vertically expandable characters are symmetric about the axis of the selection.
SparseArray
SparseArray[{pos1->v1,pos2->v2,…}] yields a sparse array with all elements zero except for values vi at positions posi.
SparseArray[list] yields a sparse array version of list.
SparseArray[data,{d1,d2,…}] yields a sparse array representing a d1×d2×… array.
SparseArray[data,dims,val] yields a sparse array in which unspecified elements are taken to have value val.
SparseArrayQ
SparseArrayQ[s] yields True if s is a valid SparseArray object and False otherwise.
SpatialBinnedPointData
SpatialBinnedPointData[{reg1->val1,reg2->val2,…}] represents values vali associated with disjoint regions regi.
SpatialBinnedPointData[{reg1,reg2,…}->{val1,val2,…}] gives the same result.
SpatialBinnedPointData[…,reg] gives the overall observation region reg.
SpatialBoundaryCorrection
SpatialBoundaryCorrection is an option to various spatial statistics functions that control how to correct for boundary effects of observation regions.
SpatialEstimate
SpatialEstimate[{loc1->val1,loc2->val2,…}] creates a spatial prediction from values vali given at locations loci.
SpatialEstimate[{loc1,loc2,…}->{val1,val2,…}] generates the same result.
SpatialEstimatorFunction
SpatialEstimatorFunction[] represents a function generated by SpatialEstimate and predicts spatial field values from locations.
SpatialGraphDistribution
SpatialGraphDistribution[n,r] represents a spatial distribution for graphs with n vertices uniformly distributed over the unit square and edges between vertices that are at distance at most r.
SpatialGraphDistribution[n,r,d] represents a spatial distribution for graphs with vertices uniformly distributed over the d-dimensional unit square.
SpatialGraphDistribution[n,r,dist] represents a spatial distribution for graphs with vertices distributed according to the probability distribution dist.
SpatialGraphDistribution[n,r,reg] represents a spatial distribution for graphs with vertices uniformly distributed in the region reg.
SpatialJ
SpatialJ[pdata,r] estimates the J function J(r) for point data pdata at radius r.
SpatialJ[pproc,r] computes J(r) for the point process pproc.
SpatialJ[bdata,r] computes J(r) for binned data bdata.
SpatialJ[pspec] generates the function J that can be applied repeatedly to different radii r.
SpatialMedian
SpatialMedian[{x1,x2,…}] gives the spatial median of the elements xi.
SpatialMedian[data] gives the spatial median for several different forms of data.
SpatialNoiseLevel
SpatialNoiseLevel is an option to SpatialEstimate and other spatial functions that gives the noise variance level in the data.
SpatialObservationRegionQ
SpatialObservationRegionQ[reg] tests whether the geometric or geographic region reg can be an observation in spatial statistics.
SpatialPointData
SpatialPointData[points] represents a collection of spatial locations points.
SpatialPointData[points,reg] represents a collection of points within the region reg.
SpatialPointData[points->vals,…] associates the values vals with the location points.
SpatialPointData[points-><|key1->vals1,…|>,…] associates the key-value annotations keyi->valsi.
SpatialPointData[{p1->data1,p2->data2,…},…] represents the spatial point collection {p1,p2,…} with associated values {data1,data2,…}.
SpatialPointData[{points1,points2,…},…] represents multiple collections of spatial points.
SpatialPointData[{points1->anns1,points2->anns2,…},…] represents multiple collections of spatial points with annotations.
SpatialPointSelect
SpatialPointSelect[spdata,crit] selects a subset of the SpatialPointData spdata according to crit.
SpatialRandomnessTest
SpatialRandomnessTest[pdata] tests whether the point collection pdata is distributed uniformly over the observation region.
SpatialRandomnessTest[pdata,"property"] returns the value of "property".
SpatialTransformationLayer
SpatialTransformationLayer[{h,w}] represents a net layer that applies an affine transformation to an input of size c×h0×w0 and returns an output of size c×h×w.
SpatialTrendFunction
SpatialTrendFunction is an option to SpatialEstimate that specifies what global trend model to use for data.
Speak
Speak[expr] speaks a spoken representation of the expression expr.
SpeakerMatchQ
SpeakerMatchQ[audio,ref] gives True if speaker features in audio match the one from reference ref and returns False otherwise.
SpeakerMatchQ[{audio1,audio2,…},ref] gives a list of results for each of audioi.
SpeakerMatchQ[ref] represents an operator form of SpeakerMatchQ that can be applied to an audio object.
SpearmanRankTest
SpearmanRankTest[v1,v2] tests whether the vectors v1 and v2 are independent.
SpearmanRankTest[m1,m2] tests whether the matrices m1 and m2 are independent.
SpearmanRankTest[…,"property"] returns the value of "property".
SpeciesData
SpeciesData[name,property] gives the value of the specified property for the species entity.
SpeciesData[{entity1,entity2,…},property] gives a list of property values for the specified species entities.
SpeciesData[entity,property,annotation] gives the specified annotation associated with the given property.
SpecificityGoal
SpecificityGoal is an option for ImageIdentify and related functions that defines what specificity of object to seek to identify.
SpectralLineData
SpectralLineData[entity] gives the values of all known properties for an atomic state or state transition.
SpectralLineData[entity,property] gives the value of the specified property for the given entity.
SpectralLineData[quantity] returns the state transition with the closest wavelength or frequency specified.
SpectralLineData[class,quantity] returns the entity in the specified entity class with the closest wavelength or energy to the specified quantity.
SpectralLineData[spec,{quantity1,quantity2}] returns the entities in spec that fall within the range specified between quantity1 and quantity2.
Spectrogram
Spectrogram[list] plots the spectrogram of list.
Spectrogram[list,n] uses partitions of length n.
Spectrogram[list,n,d] uses partitions with offset d.
Spectrogram[list,n,d,wfun] applies a smoothing window wfun to each partition.
Spectrogram[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
Spectrogram[audio,…] plots the spectrogram of audio.
Spectrogram[video] plots the spectrogram of the first audio track in video.
SpectrogramArray
SpectrogramArray[list] returns the spectrogram data of list.
SpectrogramArray[list,n] uses partitions of length n.
SpectrogramArray[list,n,d] uses partitions with offset d.
SpectrogramArray[list,n,d,wfun] applies a smoothing window wfun to each partition.
SpectrogramArray[list,n,d,wfun,m] pads partitions with zeros to length m prior to the computation of the transform.
SpectrogramArray[audio,…] returns spectrogram data of audio.
SpectrogramArray[video] returns the spectrogram data of the first audio track in video.
Specularity
Specularity[s] is a graphics directive which specifies that surfaces of 3D graphics objects which follow are to be taken to have specularity s.
Specularity[s,n] uses specular exponent n.
SpeechCases
SpeechCases[audio,form] gives a list of cases of text identified as being of type form that appear in the transcription of audio.
SpeechCases[audio,{form1,form2,…}] gives an association of results for all the types formi.
SpeechCases[audio,formspec->prop] gives the specified property for each result found.
SpeechCases[audio,formspec->{prop1,prop2,…}] gives a list of properties for each result found.
SpeechCases[audio,spec,n] gives the first n cases found.
SpeechInterpreter
SpeechInterpreter[form] represents an interpreter object that can be applied to a speech input to try to interpret it as an object of the specified form.
SpeechInterpreter[form,test] returns the interpreted object only if applying test to it yields True; otherwise, it returns a Failure object.
SpeechInterpreter[form,test,fail] returns the result of applying the function fail if the test fails.
SpeechRecognize
SpeechRecognize[audio] recognizes speech in audio and returns it as a string.
SpeechRecognize[audio,level] returns a list of strings at the specified structural level.
SpeechRecognize[audio,level,prop] returns prop for text at the given level.
SpeechSynthesize
SpeechSynthesize[expr] synthesizes the contents of expr as an Audio object.
SpeechSynthesize[expr,voice] uses the specified voice to synthesize the speech signal.
SpellingCorrection
SpellingCorrection is an option for StringMatchQ, Names, and related functions that specifies whether strings should be considered to match even when a small fraction of the characters in them are different.
SpellingCorrectionList
SpellingCorrectionList["word"] gives a list of possible spelling corrections for "word".
SpellingDictionaries
SpellingDictionaries is a global option that specifies settings for spell checking.
SpellingDictionariesPath
SpellingDictionariesPath is a global option that specifies which directories are searched for spelling dictionaries when the Edit ▶ Check Spelling menu item is used.
Sphere
Sphere[p] represents a unit sphere centered at the point p.
Sphere[p,r] represents a sphere of radius r centered at the point p.
Sphere[{p1,p2,…},r] represents a collection of spheres of radius r.
SpherePoints
SpherePoints[n] gives the positions of n uniformly distributed points on the surface of a unit sphere.
SphericalBesselJ
SphericalBesselJ[n,z] gives the spherical Bessel function of the first kind jn(z).
SphericalBesselY
SphericalBesselY[n,z] gives the spherical Bessel function of the second kind yn(z).
SphericalHankelH1
SphericalHankelH1[n,z] gives the spherical Hankel function of the first kind hn(1)(z).
SphericalHankelH2
SphericalHankelH2[n,z] gives the spherical Hankel function of the second kind hn(2)(z).
SphericalHarmonicY
SphericalHarmonicY[l,m,θ,ϕ] gives the spherical harmonic Ylm(θ,ϕ).
SphericalPlot3D
SphericalPlot3D[r,θ,ϕ] generates a 3D plot with a spherical radius r as a function of spherical coordinates θ and ϕ.
SphericalPlot3D[r,{θ,θmin,θmax},{ϕ,ϕmin,ϕmax}] generates a 3D spherical plot over the specified ranges of spherical coordinates.
SphericalPlot3D[{r1,r2,…},{θ,θmin,θmax},{ϕ,ϕmin,ϕmax}] generates a 3D spherical plot with multiple surfaces.
SphericalRegion
SphericalRegion is an option for three-dimensional graphics functions that specifies whether the final image should be scaled so that a sphere drawn around the three‐dimensional bounding box would fit in the display area specified.
SphericalShell
SphericalShell[c,{rinner,router}] represents a filled spherical shell centered at c with inner radius rinner and outer radius router.
SpheroidalEigenvalue
SpheroidalEigenvalue[n,m,γ] gives the spheroidal eigenvalue with degree n and order m.
SpheroidalJoiningFactor
SpheroidalJoiningFactor[n,m,γ] gives the spheroidal joining factor with degree n and order m.
SpheroidalPS
SpheroidalPS[n,m,γ,z] gives the angular spheroidal function PSn,m(γ,z) of the first kind.
SpheroidalPSPrime
SpheroidalPSPrime[n,m,γ,z] gives the derivative with respect to z of the angular spheroidal function PSn,m(γ,z) of the first kind.
SpheroidalQS
SpheroidalQS[n,m,γ,z] gives the angular spheroidal function QSn,m(γ,z) of the second kind.
SpheroidalQSPrime
SpheroidalQSPrime[n,m,γ,z] gives the derivative with respect to z of the angular spheroidal function QSn,m(γ,z) of the second kind.
SpheroidalRadialFactor
SpheroidalRadialFactor[n,m,c] gives the spheroidal radial factor with degree n and order m.
SpheroidalS1
SpheroidalS1[n,m,γ,z] gives the radial spheroidal function Sn,m(1)(γ,z) of the first kind.
SpheroidalS2
SpheroidalS2[n,m,γ,z] gives the radial spheroidal function Sn,m(2)(γ,z) of the second kind.
Splice
Splice[{e1,e2,…}] represents an expression that will automatically be spliced into any list in which it appears as the sequence of elements ei.
Splice[{e1,e2,…},hpatt] represents an expression that will automatically be spliced into any expression whose head matches the pattern hpatt.
SplicedDistribution
SplicedDistribution[{w1,w2,…,wn},{c0,c1,…,cn},{dist1,dist2,…,distn}] represents the distribution obtained by splicing the distributions dist1, dist2, … truncated on the intervals {c0,c1}, {c1,c2}, … with weights w1, w2, … .
SplineClosed
SplineClosed is an option for B-spline functions and graphics primitives that specifies whether spline curves or surfaces should be closed.
SplineDegree
SplineDegree is an option for spline functions and graphics primitives that specifies the degree of polynomial basis to use.
SplineKnots
SplineKnots is an option for B-spline functions and graphics primitives that specifies the positions of knots.
SplineWeights
SplineWeights is an option for B-spline functions and graphics primitives that specifies weights of control points.
Split
Split[list] splits list into sublists consisting of runs of identical elements.
Split[list,test] treats pairs of adjacent elements as identical whenever applying the function test to them yields True.
SplitBy
SplitBy[list,f] splits list into sublists consisting of runs of successive elements that give the same value when f is applied.
SplitBy[list,{f1,f2,…}] recursively splits list into sublists by testing elements successively with each of the fi.
SpokenString
SpokenString[expr] gives a string of text corresponding to a spoken representation of the expression expr.
SpotLight
SpotLight[col,pt,α] is a three-dimensional graphics directive to use in coloring 3D surfaces that specifies the spotlight of color col at position pt aimed at the center with half-angle α.
SpotLight[col,{pt1,pt2},α] uses the spotlight at position pt1 aimed at pt2 with half-angle α.
SpotLight[col,{pt,tar},{α,s},att] uses the spotlight with spot exponent s and attenuation att.
Sqrt
Sqrt[z] or @z gives the square root of z.
Square
Square[x] displays as x.
SquaredEuclideanDistance
SquaredEuclideanDistance[u,v] gives the squared Euclidean distance between vectors u and v.
SquareFreeQ
SquareFreeQ[expr] gives True if expr is a square-free polynomial or number, and False otherwise.
SquareFreeQ[expr,vars] gives True if expr is square free with respect to the variables vars.
SquareIntersection
SquareIntersection[x,y,…] displays as x⊓y⊓….
SquareMatrixQ
SquareMatrixQ[m] gives True if m is a square matrix, and False otherwise.
SquareRepeatingElement
SquareRepeatingElement[spec] represents a square array of elements of type spec in an interpreter, API or form specification.
SquareRepeatingElement[spec,max] represents a square array of elements of maximum size max×max.
SquareRepeatingElement[spec,{min,max}] represents a square array of elements of size between min and max.
SquaresR
SquaresR[d,n] gives the number of ways rd(n) to represent the integer n as a sum of d squares.
SquareSubset
SquareSubset[x,y,…] displays as x⊏y⊏….
SquareSubsetEqual
SquareSubsetEqual[x,y,…] displays as x⊑y⊑….
SquareSuperset
SquareSuperset[x,y,…] displays as x⊐y⊐….
SquareSupersetEqual
SquareSupersetEqual[x,y,…] displays as x⊒y⊒….
SquareUnion
SquareUnion[x,y,…] displays as x⊔y⊔….
SquareWave
SquareWave[x] gives a square wave that alternates between +1 and -1 with unit period.
SquareWave[{y1,y2},x] gives a square wave that alternates between y1 and y2 with unit period.
SSSTriangle
SSSTriangle[a,b,c] returns a filled triangle with sides of lengths a, b, and c.
StabilityMargins
StabilityMargins is an option to frequency response plots such as BodePlot, NyquistPlot, and NicholsPlot that specifies the gain and phase margins to be shown on the plot.
StabilityMarginsStyle
StabilityMarginsStyle is an option to frequency response plots such as BodePlot, NyquistPlot, and NicholsPlot that specifies the styles in which the gain and phase margins are to be drawn.
StableDistribution
StableDistribution[type,α,β,μ,σ] represents the stable distribution Stype with index of stability α, skewness parameter β, location parameter μ, and scale parameter σ.
Stack
Stack[] shows the current evaluation stack, giving a list of the tags associated with evaluations that are currently being done.
Stack[pattern] gives a list of expressions currently being evaluated which match the pattern.
StackBegin
StackBegin[expr] evaluates expr, starting a fresh evaluation stack.
StackComplete
StackComplete[expr] evaluates expr with intermediate expressions in evaluation chains included on the stack.
StackedDateListPlot
StackedDateListPlot[{{date1,y1},{date2,y2},…}] plots points with values yi at a sequence of dates.
StackedDateListPlot[{y1,y2,…},datespec] plots points with dates at equal intervals specified by datespec.
StackedDateListPlot[tseries] plots the time series tseries.
StackedDateListPlot[{data1,data2,…}] plots data from all the datai.
StackedDateListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.
StackedListPlot
StackedListPlot[{data1,data2,…}] plots lines for each of the datai, with the ith curve being the accumulation of values in data1 through datai.
StackedListPlot[{…,w[datai],…}] plots datai with features defined by the symbolic wrapper w.
StackInhibit
StackInhibit[expr] evaluates expr without modifying the evaluation stack.
StadiumShape
StadiumShape[{{x1,y1},{x2,y2}},r] represents a stadium of radius r between the points {x1,y1} and {x2,y2}.
StandardAtmosphereData
StandardAtmosphereData[altitude,property] returns the value of the property at the specified geometrical altitude for the chosen model of the standard Earth atmosphere.
StandardAtmosphereData[layer,property] returns a piecewise symbolic approximation with the range of an atmospheric layer for the property.
StandardAtmosphereData["SymbolicApproximation",property] returns the full piecewise symbolic approximation for the property.
StandardDeviation
StandardDeviation[data] gives the standard deviation estimate of the elements in data.
StandardDeviation[dist] gives the standard deviation of the distribution dist.
StandardForm
StandardForm[expr] prints as the standard Wolfram Language two-dimensional representation of expr.
Standardize
Standardize[list] shifts and rescales the elements of list to have zero mean and unit sample variance.
Standardize[list,f1] shifts the elements in list by f1[list] and rescales them to have unit sample variance.
Standardize[list,f1,f2] shifts by f1[list] and scales by f2[list].
Standardized
Standardized is an option that determines whether to standardize the data.
StandardOceanData
StandardOceanData[spec] returns the thermodynamic properties of seawater for the specified parameters.
StandardOceanData[spec,property] returns the specified property for the given parameters.
Star
Star[x,y,…] displays as x⋆y⋆….
StarClusterData
StarClusterData[entity,property] gives the value of the specified property for the star cluster entity.
StarClusterData[{entity1,entity2,…},property] gives a list of property values for the specified star cluster entities.
StarClusterData[entity,property,annotation] gives the specified annotation associated with the given property.
StarData
StarData[entity,property] gives the value of the specified property for the star entity.
StarData[{entity1,entity2,…},property] gives a list of property values for the specified star entities.
StarData[entity,property,annotation] gives the specified annotation associated with the property.
StarGraph
StarGraph[n] gives the star graph with n vertices Sn.
StartAsynchronousTask
StartAsynchronousTask[task] allows asynchronous evaluations from task after it has been stopped.
StartExternalSession
StartExternalSession["sys"] starts an external session using the external evaluator sys, returning an external session object.
StartExternalSession[assoc] starts the external evaluator specified by assoc.
StartExternalSession[{"sys",opts}] uses the options opts for the external evaluator.
StartExternalSession[sys->type] specifies that output from the external evaluator should be converted to the specified type.
StartExternalSession[DatabaseReference[ref]] uses the database specified by ref to start a database session.
StartingStepSize
StartingStepSize is an option to NDSolve and related functions that specifies the initial step size to use in trying to generate results.
StartOfLine
StartOfLine represents the start of a line in a string for purposes of matching in StringExpression.
StartOfString
StartOfString represents the start of a string for purposes of matching in StringExpression.
StartProcess
StartProcess["executable"] executes an external program, yielding a ProcessObject to represent the resulting subprocess.
StartProcess[{"executable", arg 1, arg 2, ...}] executes an external program, passing it the specified arguments arg i.
StartWebSession
StartWebSession[] starts a web session and returns a web session object.
StartWebSession["browser"] starts a web session using the specified browser.
StateDimensions
StateDimensions is an option to TemporalData that specifies the dimensions of the state space.
StateFeedbackGains
StateFeedbackGains[sspec,{p1,…,pn}] gives the state feedback gains for the system specification sspec to place its closed-loop poles at pi.
StateFeedbackGains[…,"prop"] gives the value of the property "prop".
StateOutputEstimator
StateOutputEstimator[ssm,l] constructs an estimator for the StateSpaceModel ssm, with estimator gain matrix l.
StateOutputEstimator[{ssm,sensors},l] uses only sensors as the measurements of ssm.
StateOutputEstimator[{ssm,sensors,dinputs},l] specifies dinputs as the deterministic inputs of ssm.
StateResponse
StateResponse[sys,u,{t,tmin,tmax}] gives the numeric state response of the state-space model sys to input u for tmin≤t≤tmax.
StateResponse[sys,{u[0],u[1],…}] gives the response of the discrete-time state-space model sys to the input sequence u[i].
StateResponse[sys,u,t] gives the symbolic state response as a function of time t.
StateResponse[sys,{u1,…,um},…] gives the state response for multiple inputs ui.
StateResponse[{sys,{x10,x20,…,xn0}},…, …] gives the response with initial states xi0.
StateSpaceModel
StateSpaceModel[{a,b,c,d}] represents the standard state-space model with state matrix a, input matrix b, output matrix c, and transmission matrix d.
StateSpaceModel[{a,b,c,d,e}] represents a descriptor state-space model with descriptor matrix e.
StateSpaceModel[sys] gives a state-space model corresponding to the systems model sys.
StateSpaceModel[eqns,{{x1,x10},…},{{u1,u10},…},{g1,…},τ] gives the state-space model obtained by Taylor linearization about the point (xi0,ui0) of the differential or difference equations eqns with outputs gi and independent variable τ.
StateSpaceRealization
StateSpaceRealization is an option to StateSpaceModel that specifies its canonical representation.
StateSpaceTransform
StateSpaceTransform[sys,{p,q}] transforms the state-space model sys using the matrices p and q.
StateSpaceTransform[sys,{{x1->p1[z],…},{z1->q1[x],…}}] transforms using the variable transformations {x1->p1[z],…} and {z1->q1[x],…}.
StateTransformationLinearize
StateTransformationLinearize[asys] linearizes the AffineStateSpaceModel asys by state transformation.
StateTransformationLinearize[asys,{z,lform}] specifies the new states z and form of linearization lform.
StateTransformationLinearize[asys,…,"prop"] computes the property "prop".
StationaryDistribution
StationaryDistribution[proc] represents the stationary distribution of the process proc, when it exists.
StationaryWaveletPacketTransform
StationaryWaveletPacketTransform[data] gives the stationary wavelet packet transform (SWPT) of an array of data.
StationaryWaveletPacketTransform[data,wave] gives the stationary wavelet packet transform using the wavelet wave.
StationaryWaveletPacketTransform[data,wave,r] gives the stationary wavelet packet transform using r levels of refinement.
StationaryWaveletTransform
StationaryWaveletTransform[data] gives the stationary wavelet transform (SWT) of an array of data.
StationaryWaveletTransform[data,wave] gives the stationary wavelet transform using the wavelet wave.
StationaryWaveletTransform[data,wave,r] gives the stationary wavelet transform using r levels of refinement.
StatusCentrality
StatusCentrality[g] gives a list of status centralities for the vertices in the graph g.
StatusCentrality[{v->w,…}] uses rules v->w to specify the graph g.
StepMonitor
StepMonitor is an option for iterative numerical computation functions that gives an expression to evaluate whenever a step is taken by the numerical method used.
StereochemistryElements
StereochemistryElements is an option for Molecule that specifies the local stereochemical arrangement of atoms in a molecule.
StieltjesGamma
StieltjesGamma[n] gives the Stieltjes constant γn.
StieltjesGamma[n,a] gives the generalized Stieltjes constant γn(a).
StippleShading
StippleShading[] is a three-dimensional graphics directive specifying that objects that follow are to be drawn using small dots.
StippleShading[d] uses the density d of shading.
StippleShading[col] uses dots with the specified color col.
StippleShading[d,col] uses dots of color col with the density d of shading.
StirlingS1
StirlingS1[n,m] gives the Stirling number of the first kind Sn(m).
StirlingS2
StirlingS2[n,m] gives the Stirling number of the second kind n(m).
StopAsynchronousTask
StopAsynchronousTask[task] stops asynchronous evaluations from task.
StoppingPowerData
StoppingPowerData[entity,{"Particle"->particle,"Energy"->quantity},property] gives the value of the specific property for the substance for the specified particle and the energy of that particle.
StrataVariables
StrataVariables is an option for fitting functions such as CoxModelFit that specify the variables on which the model should be stratified.
StratonovichProcess
StratonovichProcess[{a,b},x,t] represents a Stratonovich process x(t), where x(t)a(t,x(t))t+b(t,x(t))◦ w(t) .
StratonovichProcess[{a,b,c},x,t] represents a Stratonovich process y(t)c(t,x(t)), where x(t)a(t,x(t))t+b(t,x(t))◦ w(t) .
StratonovichProcess[…,…,{x,x0},{t,t0}] represents a Stratonovich process with initial condition x(t0)x0.
StratonovichProcess[…,…,…,Σ] uses a Wiener process w(t), with covariance Σ.
StratonovichProcess[proc] converts proc to a standard Stratonovich process whenever possible.
StratonovichProcess[sdeqns,expr,x,t,wdproc] represents a Stratonovich process specified by a stochastic differential equation sdeqns, output expression expr, with state x and time t, driven by w following the process dproc.
StreamColorFunction
StreamColorFunction is an option for StreamPlot and related functions that specifies a function to apply to determine colors along streamlines.
StreamColorFunctionScaling
StreamColorFunctionScaling is an option for graphics functions that specifies whether arguments supplied to a stream color function should be scaled to lie between 0 and 1.
StreamDensityPlot
StreamDensityPlot[{{vx,vy},r},{x,xmin,xmax},{y,ymin,ymax}] generates a stream plot of the vector field {vx,vy} as a function of x and y, superimposed on a background density plot of the scalar field r.
StreamDensityPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] takes the scalar field to be the norm of the vector field.
StreamDensityPlot[{{vx,vy},{wx,wy},…,r},{x,xmin,xmax},{y,ymin,ymax}] generates plots of several vector fields.
StreamDensityPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
StreamMarkers
StreamMarkers is an option for StreamPlot, ListStreamPlot and related functions that specifies what markers to draw at the field points plotted.
StreamPlot
StreamPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a stream plot of the vector field {vx,vy} as a function of x and y.
StreamPlot[{{vx,vy},{wx,wy},…},{x,xmin,xmax},{y,ymin,ymax}] generates plots of several vector fields.
StreamPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
StreamPlot3D
StreamPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots streamlines for the vector field {vx,vy,vz} as functions of x, y and z.
StreamPlot3D[{vx,vy,vz},{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg.
StreamPoints
StreamPoints is an option to StreamPlot, ListStreamPlot, and related functions that determines how many streamlines to draw.
StreamPosition
StreamPosition[stream] returns an integer that specifies the position of the current point in an open stream.
Streams
Streams[] gives a list of all streams that are currently open.
Streams["name"] lists only streams with the specified name.
StreamScale
StreamScale is an option to StreamPlot, ListStreamPlot, and related functions that determines the length and arrowhead size of streamlines that are drawn.
StreamStyle
StreamStyle is an option to StreamPlot, StreamDensityPlot, and related functions that determines the style to use for drawing streamlines.
StrictInequalities
StrictInequalities is an option to FunctionSign and FunctionMonotonicity, etc. that determines whether strict inequalities should be used in definitions.
String
String is the head of a character string "text".
StringByteCount
StringByteCount["string"] gives the total number of bytes used to store the characters in a string.
StringCases
StringCases["string",patt] gives a list of the substrings in "string" that match the string expression patt.
StringCases["string",lhs->rhs] gives a list of the values of rhs corresponding to the substrings that match the string expression lhs.
StringCases["string",p,n] includes only the first n substrings that match.
StringCases["string",{p1,p2,…}] gives substrings that match any of the pi.
StringCases[{s1,s2,…},p] gives the list of results for each of the si.
StringCases[patt] represents an operator form of StringCases that can be applied to an expression.
StringContainsQ
StringContainsQ["string",patt] yields True if any substring in "string" matches the string expression patt, and yields False otherwise.
StringContainsQ["string",{patt1,patt2,…}] yields True if any substring matches any of the patti.
StringContainsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".
StringContainsQ[patt] represents an operator form of StringContainsQ that can be applied to an expression.
StringCount
StringCount["string","sub"] gives a count of the number of times "sub" appears as a substring of "string".
StringCount["string",patt] gives the number of substrings in "string" that match the general string expression patt.
StringCount["string",{patt1,patt2,…}] counts the number of occurrences of any of the patti.
StringCount[{s1,s2,…},p] gives the list of results for each of the si.
StringDelete
StringDelete["string",patt] yields the string obtained by deleting from string all occurrences of anything matching the string pattern patt.
StringDelete[patt] represents an operator form of StringDelete that can be applied to an expression.
StringEndsQ
StringEndsQ["string",patt] yields True if the end of "string" matches the string expression patt, and yields False otherwise.
StringEndsQ["string",{patt1,patt2,…}] yields True if the end of "string" matches any of the patti.
StringEndsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".
StringEndsQ[patt] represents an operator form of StringEndsQ that can be applied to an expression.
StringExpression
s1~~s2~~… or StringExpression[s1,s2,…] represents a sequence of strings and symbolic string objects si.
StringExtract
StringExtract["string",n] extracts the nth block of characters in string, where blocks of characters are defined as delimited by whitespace.
StringExtract["string",{pos1,pos2,…}] extracts blocks at several positions in string.
StringExtract["string",sep->pos] takes blocks to be delimited by separators that match sep.
StringExtract["string",pos1,pos2,…] extracts blocks at positions posi, delimiting with whitespace for the lowest level, newlines for the next level, and a successively increasing number of newlines thereafter.
StringExtract["string",sep1->pos1,sep2->pos2,…] gives a nested list of blocks, with the sepi used as separators for successive levels.
StringForm
StringForm["controlstring",expr1,…] prints as the text of the controlstring, with the printed forms of the expri embedded.
StringFormat
StringFormat["string"] attempts to determine what ImportString format could be used to import the string "string".
StringFormatQ
StringFormatQ["string","fmt"] gives True if the string "string" might be imported as format "fmt" and gives False otherwise.
StringFormatQ["string",{fmt1,fmt2,…}] gives True if "string" might be imported as one of "fmti".
StringFreeQ
StringFreeQ["string",patt] yields True if no substring in "string" matches the string expression patt, and yields False otherwise.
StringFreeQ["string",{patt1,patt2,…}] yields True if no substring matches any of the patti.
StringFreeQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".
StringFreeQ[patt] represents an operator form of StringFreeQ that can be applied to an expression.
StringInsert
StringInsert["string","snew",n] yields a string with "snew" inserted starting at position n in "string".
StringInsert["string","snew",-n] inserts at position n from the end of "string".
StringInsert["string","snew",{n1,n2,…}] inserts a copy of "snew" at each of the positions ni.
StringInsert[{s1,s2,…},"snew",n] gives the list of results for each of the si.
StringJoin
"s1"<>"s2"<>…, StringJoin["s1","s2",…], or StringJoin[{"s1","s2",…}] yields a string consisting of a concatenation of the si.
StringLength
StringLength["string"] gives the number of characters in a string.
StringMatchQ
StringMatchQ["string",patt] tests whether "string" matches the string pattern patt.
StringMatchQ["string",RegularExpression["regex"]] tests whether "string" matches the specified regular expression.
StringMatchQ["string",{patt1,patt2,…}] test whether "string" matches any of the patti.
StringMatchQ[{string1,string2,…},patt] gives the list of the results for each of the "stringi".
StringMatchQ[patt] represents an operator form of StringMatchQ that can be applied to an expression.
StringPadLeft
StringPadLeft["string",n] makes string be of length n, padding it on the left with spaces or truncating it if necessary.
StringPadLeft["string",n,"padding"] pads by repeating copies of the string padding.
StringPadLeft[{s1,s2,…}] pads strings with spaces on the left to make them all the same length.
StringPadLeft[{s1,s2,…},n,…] pads or truncates to make all strings of length n.
StringPadRight
StringPadRight["string",n] makes string be of length n, padding it on the right with spaces or truncating it if necessary.
StringPadRight["string",n,"padding"] pads by repeating copies of the string padding.
StringPadRight[{s1,s2,…}] pads strings with spaces on the right to make them all the same length.
StringPadRight[{s1,s2,…},n,…] pads or truncates to make all strings of length n.
StringPart
StringPart["string",n] gives the nth character in "string".
StringPart["string",{n1,n2,…}] gives a list of the nith characters in "string".
StringPart["string",m;;n;;s] gives a list of the characters in "string" from the mth through the nth in steps of s.
StringPart[{s1,s2,…},spec] gives the list of results for each of the si.
StringPartition
StringPartition["string",n] partitions string into nonoverlapping substrings of length n.
StringPartition["string",n,d] generates substrings with offset d.
StringPosition
StringPosition["string","sub"] gives a list of the starting and ending character positions at which "sub" appears as a substring of "string".
StringPosition["string",patt] gives all positions at which substrings matching the general string expression patt appear in "string".
StringPosition["string",patt,n] includes only the first n occurrences of patt.
StringPosition["string",{patt1,patt2,…}] gives positions of all the patti.
StringPosition[{s1,s2,…},p] gives the list of results for each of the si.
StringPosition[patt] represents an operator form of StringPosition that can be applied to an expression.
StringQ
StringQ[expr] gives True if expr is a string, and False otherwise.
StringRepeat
StringRepeat["str",n] creates a string consisting of "str" repeated n times.
StringRepeat["str",n,max] creates a string consisting of up to n copies of "str", truncated to be of maximum total length at most max.
StringReplace
StringReplace["string",s->sp] replaces the string expression s by sp wherever it appears in "string".
StringReplace["string",{s1->sp1,s2->sp2,…}] replaces the string expressions si by spi whenever they appear as substrings of "string".
StringReplace["string",srules,n] does only the first n replacements.
StringReplace[{s1,s2,…},srules] gives the list of results for each of the si.
StringReplace[srules] represents an operator form of StringReplace that can be applied to an expression.
StringReplaceList
StringReplaceList["string",s->sp] or StringReplaceList["string",{s1->sp1,s2->sp2,…}] gives a list of the strings obtained by replacing each individual occurrence of substrings in "string" matching the string expressions si.
StringReplaceList["string",srules,n] gives a list of the first n results obtained.
StringReplaceList[{s1,s2,…},srules] gives the list of results for each of the si.
StringReplacePart
StringReplacePart["string","snew",{m,n}] replaces the characters at positions m through n in "string" by "snew".
StringReplacePart["string","snew",{{m1,n1},{m2,n2},…}] inserts copies of "snew" at several positions.
StringReplacePart["string",{"snew1","snew2",…},{{m1,n1},{m2,n2},…}] replaces characters at positions mi through ni in "string" by "snewi".
StringReplacePart["snew",{m,n}] represents an operator form of StringReplacePart that can be applied to an expression.
StringReverse
StringReverse["string"] reverses the order of the characters in "string".
StringRiffle
StringRiffle[{s1,s2,s3,…}] creates a string by concatenating all the si, with spaces inserted between them.
StringRiffle[{{s11,s12,…},{s21,s22,…},…}] creates a string by concatenating the sij, and inserting spaces at the lowest level and newlines at the higher level.
StringRiffle[list,sep] inserts the separator sep between all elements in list.
StringRiffle[list,{"left","sep","right"}] use left and right as delimiters after concatenation.
StringRiffle[list,sep1,sep2,…] inserts separator sepi between elements of list at level i.
StringRotateLeft
StringRotateLeft[string,n] cycles the characters in string n positions to the left.
StringRotateLeft[string] cycles one position to the left.
StringRotateRight
StringRotateRight[string,n] cycles the characters in string n positions to the right.
StringRotateRight[string] cycles one position to the right.
StringSkeleton
StringSkeleton[n] represents a sequence of n omitted characters in a string printed with Short. The standard print form for StringSkeleton is an ellipsis.
StringSplit
StringSplit["string"] splits "string" into a list of substrings separated by whitespace.
StringSplit["string",patt] splits into substrings separated by delimiters matching the string expression patt.
StringSplit["string",{p1,p2,…}] splits at any of the pi.
StringSplit["string",patt->val] inserts val at the position of each delimiter.
StringSplit["string",{p1->v1,…}] inserts vi at the position of each delimiter pi.
StringSplit["string",patt,n] splits into at most n substrings.
StringSplit[{s1,s2,…},p] gives the list of results for each of the si.
StringStartsQ
StringStartsQ["string",patt] yields True if the beginning of "string" matches the string expression patt, and yields False otherwise.
StringStartsQ["string",{patt1,patt2,…}] yields True if the beginning of "string" matches any of the patti.
StringStartsQ[{string1,string2,…},patt] gives a list of the results for each of the "stringi".
StringStartsQ[patt] represents an operator form of StringStartsQ that can be applied to an expression.
StringTakeDrop
StringTakeDrop["string",n] gives a pair of strings containing the first n characters in "string" and the remaining characters.
StringTakeDrop["string",seq] gives the pair {StringTake["string",seq],StringDrop["string",seq]}.
StringTemplate
StringTemplate["string"] yields a TemplateObject expression that represents a string template to be applied to arguments.
StringTemplate[src] uses File[…], URL[…] or CloudObject[ …] as the source for the string template.
StringTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.
StringToByteArray
StringToByteArray["string"] returns a byte array corresponding to the UTF-8 encoding of the specified string.
StringToByteArray["string","encoding"] uses the specified character encoding.
StringToStream
StringToStream["string"] opens an input stream for reading from a string.
StringTrim
StringTrim["string"] trims whitespace from the beginning and end of "string".
StringTrim["string",patt] trims substrings matching patt from the beginning and end.
StructuralImportance
StructuralImportance[rdist] gives the structural importances for all components in the ReliabilityDistribution rdist.
StructuralImportance[fdist] gives the structural importances for all components in the FailureDistribution fdist.
StructuralImportance[bexpr,{x1,x2,…}] gives the structural importance for the components x1, x2, … in the Boolean expression bexpr.
StructuredArray
StructuredArray[st,{d1,d2,…},data] represents a d1×d2×… array with structure type st and specific content data.
StructuredSelection
StructuredSelection is an option for Cell that specifies whether to allow only complete subexpressions in the cell to be selected interactively using the front end.
StruveH
StruveH[n,z] gives the Struve function Hn(z).
StruveL
StruveL[n,z] gives the modified Struve function Ln(z).
Stub
Stub is an attribute which specifies that if a symbol is ever used, Needs should automatically be called on the context of the symbol.
StudentTDistribution
StudentTDistribution[ν] represents a standard Student t distribution with ν degrees of freedom.
StudentTDistribution[μ,σ,ν] represents a Student t distribution with location parameter μ, scale parameter σ, and ν degrees of freedom.
Style
Style[expr,options] displays with expr formatted using the specified option settings.
Style[expr,"style"] uses the option settings for the specified style in the current notebook.
Style[expr,color] displays using the specified color.
Style[expr,Bold] displays with fonts made bold.
Style[expr,Italic] displays with fonts made italic.
Style[expr,Underlined] displays with fonts underlined.
Style[expr,Larger] displays with fonts made larger.
Style[expr,Smaller] displays with fonts made smaller.
Style[expr,n] displays with font size n.
Style[expr,Tiny], Style[expr,Small], etc. display with fonts that are tiny, small, etc.
Subdivide
Subdivide[n] generates the list {0,1/n,2/n,…,1}.
Subdivide[xmax,n] generates the list of values obtained by subdividing the interval 0 to xmax into n equal parts.
Subdivide[xmin,xmax,n] generates the list of values from subdividing the interval xmin to xmax.
Subfactorial
Subfactorial[n] gives the number of permutations of n objects that leave no object fixed.
Subgraph
Subgraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices vi.
Subgraph[g,{e1,e2,…}] gives the subgraph generated by the edges ej.
Subgraph[g,patt] gives the subgraph generated by the vertices and edges that match the pattern patt.
Subgraph[{v->w,…},…] uses rules v->w to specify the graph g.
SubMinus
SubMinus[expr] displays as expr-.
SubPlus
SubPlus[expr] displays as expr+.
SubresultantPolynomialRemainders
SubresultantPolynomialRemainders[poly1,poly2,var] gives the subresultant polynomial remainder sequence of the polynomials poly1 and poly2 with respect to the variable var.
SubresultantPolynomialRemainders[poly1,poly2,var,Modulus->p] computes the subresultant polynomial remainder sequence modulo the prime p.
SubresultantPolynomials
SubresultantPolynomials[poly1,poly2,var] generates a list of subresultant polynomials of the polynomials poly1 and poly2 with respect to the variable var.
SubresultantPolynomials[poly1,poly2,var,Modulus->p] computes the subresultant polynomials modulo the prime p.
Subresultants
Subresultants[poly1,poly2,var] generates a list of the principal subresultant coefficients of the polynomials poly1 and poly2 with respect to the variable var.
Subresultants[poly1,poly2,var,Modulus->p] computes the principal subresultant coefficients modulo the prime p.
Subscript
Subscript[x,y] is an object that formats as xy.
Subscript[x,y1,y2,…] formats as xy1,y2,….
Subset
Subset[x,y,…] displays as x⊂y⊂….
SubsetCases
SubsetCases[list,patt] gives a list of the sublists in list that match the pattern patt in any order.
SubsetCases[list,patt->rhs] gives a list of the values of rhs corresponding to matching sublists.
SubsetCases[list,patt,n] includes only the first n matches.
SubsetCount
SubsetCount[list,sub] gives a count of the number of times sub appears in any order as a sublist of list.
SubsetCount[list,patt] gives the number of sublists in list that match the general pattern patt in any order.
SubsetEqual
SubsetEqual[x,y,…] displays as x⊆y⊆….
SubsetMap
SubsetMap[f,{e1,e2,…},{i,j,…}] yields an expression in which the elements ei, ej, … in the list {e1,e2,…} are replaced with the corresponding elements of the list obtained by evaluating f[{ei,ej,…}].
SubsetMap[f,expr,{pos1,pos2,…}] replaces elements of expr at positions pos1, pos2, ….
SubsetMap[f,{pos1,pos2,…}] represents an operator form of SubsetMap that can be applied to an expression.
SubsetPosition
SubsetPosition[list,sublist] gives a list of positions at which sublist appears in list in any order.
SubsetPosition[list,patt] gives all positions at which sublists matching patt in any order appear in list.
SubsetPosition[list,patt,n] includes only the first n positions.
SubsetQ
SubsetQ[list1,list2] yields True if list2 is a subset of list1, and False otherwise.
SubsetReplace
SubsetReplace[list,rules] replaces sublists in list according to the specified rule or list of rules.
SubsetReplace[list,rules,n] does only the first n replacements.
SubsetReplace[rules] represents an operator form of SubsetReplace that can be applied to an expression.
SubStar
SubStar[expr] displays as expr*.
Subsuperscript
Subsuperscript[x,y,z] is an object that formats as xyz.
SubtitleEncoding
SubtitleEncoding is an option for Export and other functions that specifies the subtitle encoding to use when creating a video file.
SubtitleTrackSelection
SubtitleTrackSelection is an option that specifies the subtitle tracks of interest.
Subtract
x-y is equivalent to x+(-1*y).
SubtractFrom
x-=dx subtracts dx from x and returns the new value of x.
SubtractSides
SubtractSides[rel,x] subtracts x from each side of the equation or inequality rel.
SubtractSides[rel1,rel2] subtracts the corresponding sides of two equations or inequalities.
SubtractSides[rel] subtracts the right-hand side of rel from each side, producing a zero right-hand side.
SubValues
SubValues[f] gives a list of transformation rules corresponding to all subvalues (values for f[…][…]…) defined for the symbol f.
SubValues["symbol"] gives a list of transformation rules corresponding to all subvalues defined for the symbol named "symbol" if it exists.
Succeeds
Succeeds[x,y,…] displays as x≻y≻….
SucceedsEqual
SucceedsEqual[x,y,…] displays as x⪰y⪰….
SucceedsSlantEqual
SucceedsSlantEqual[x,y,…] displays as x≽y≽….
SucceedsTilde
SucceedsTilde[x,y,…] displays as x≿y≿….
Success
Success["tag",assoc] represents a success of a type indicated by tag, with details given by the association assoc.
SuchThat
SuchThat[x,y] displays as x∍y.
SumConvergence
SumConvergence[f,n] gives conditions for the sum ∑+n%∞f to be convergent.
SumConvergence[f,{n1,n2,…}] gives conditions for the multiple sum ∑+n1%∞∑+n2%∞… f to be convergent.
SumConvergence[f,{n,a,∞}] gives conditions for the sum ∑+n=a%∞f to be convergent on the interval [a,∞).
SumConvergence[f,{n,a,∞},…,{m,b,∞}] gives conditions for the multiple sum ∑+n=a%∞…∑+m=b%∞f to be convergent.
SummationLayer
SummationLayer[] represents a net layer that sums all of its input elements.
Sunday
Sunday is a day of the week.
SunPosition
SunPosition[] gives the position of the Sun for the current date and location.
SunPosition[datespec] gives the position of the Sun for the specified date.
SunPosition[locationspec] gives the positions of the Sun for the specified location.
SunPosition[locationspec,datespec] gives the position of the Sun for the specified date and location.
SunPosition[{{location1,date1},{location2,date2},…}] gives the positions of the Sun for all specified locations on the specified dates.
SunPosition[locationspec,datespec,func] uses func to determine what to return for extended locations.
Sunrise
Sunrise[] gives the time of the next sunrise for the current date and location.
Sunrise[datespec] gives the times of the next sunrise for the specified dates.
Sunrise[locationspec] gives the times of the next sunrise for the specified locations.
Sunrise[locationspec,datespec] gives the time of the next sunrise for the specified date and location.
Sunrise[{{location1,date1},{location2,date2},…}] gives the times of the next sunrise for all specified locations on the specified dates.
Sunrise[locationspec,datespec,func] uses func to determine what to return for extended locations.
Sunset
Sunset[] gives the time of the next sunset for the current date and location.
Sunset[datespec] gives the time of the next sunset for the specified dates.
Sunset[locationspec] gives the times of the next sunset for the specified locations.
Sunset[locationspec,datespec] gives the time of the next sunset for the specified date and location.
Sunset[{{location1,date1},{location2,date2},…}] gives the times of the next sunset for all specified locations on the specified dates.
Sunset[locationspec,datespec,func] uses func to determine what to return for extended locations.
SuperDagger
SuperDagger[expr] displays as expr†.
SuperMinus
SuperMinus[expr] displays as expr-.
SupernovaData
SupernovaData[entity,property] gives the value of the specified property for the supernova entity.
SupernovaData[{entity1,entity2,…},property] gives a list of property values for the specified supernova entities.
SupernovaData[entity,property,annotation] gives the specified annotation associated with the given property.
SuperPlus
SuperPlus[expr] displays as expr+.
Superscript
Superscript[x,y] is an object that formats as xy.
Superset
Superset[x,y,…] displays as x⊃y⊃….
SupersetEqual
SupersetEqual[x,y,…] displays as x⊇y⊇….
SuperStar
SuperStar[expr] displays as expr*.
Surd
Surd[x,n] gives the real-valued nth root of x.
SurfaceArea
SurfaceArea[reg] gives the surface area of the three-dimensional region reg.
SurfaceArea[{x1,…,xn},{s,smin,ssmax},{t,tmin,tmax},{u,umin,umax}] gives the surface area of the parametrized region whose Cartesian coordinates xi are functions of s, t, u.
SurfaceArea[{x1,…,xn},{s,smin,ssmax},{t,tmin,tmax},{u,umin,umax},chart] interprets the xi as coordinates in the specified coordinate chart.
SurfaceColor
SurfaceColor[dcol] is a three-dimensional graphics directive which specifies that the surfaces which follow should act as diffuse reflectors of light with a color given by dcol.
SurfaceColor[dcol,scol] specifies that a specular reflection component should be included, with a color given by scol.
SurfaceColor[dcol,{scol,n}] specifies that the reflection should occur with specular exponent n.
SurfaceColor[dcol,scol,gcol] specifies that a color gcol should be added as if there were an intrinsic glow in the polygon.
SurfaceData
SurfaceData[entity,property] gives the value of the specified property for the surface entity.
SurfaceData[{entity1,entity2,…},property] gives a list of property values for the specified surface entities.
SurfaceData[entity, property, annotation] gives the specified annotation associated with the given property.
SurfaceGraphics
SurfaceGraphics[array] is a representation of a three-dimensional plot of a surface, with heights of each point on a grid specified by values in array.
SurfaceGraphics[array,shades] represents a surface, whose parts are shaded according to the array shades.
SurvivalDistribution
SurvivalDistribution[{e1,e2,…}] represents a survival distribution with event times ei.
SurvivalDistribution[{cw1,cw2,…}->{e1,e2,…}] represents a survival distribution where events ei occur with censor weights cwi.
SurvivalFunction
SurvivalFunction[dist,x] gives the survival function for the distribution dist evaluated at x.
SurvivalFunction[dist,{x1,x2,…}] gives the multivariate survival function for the distribution dist evaluated at {x1,x2,…}.
SurvivalFunction[dist] gives the survival function as a pure function.
SurvivalModel
SurvivalModel[…] represents the symbolic survival model obtained from functions like SurvivalModelFit.
SurvivalModelFit
SurvivalModelFit[{e1,e2,…}] creates a survival model for event times ei.
SuspendPacket
SuspendPacket[] is a WSTP packet used for synchronization with the Wolfram Language kernel.
SuzukiDistribution
SuzukiDistribution[μ,ν] represents the Suzuki distribution with shape parameters μ and ν.
SuzukiGroupSuz
SuzukiGroupSuz[] represents the sporadic simple Suzuki group Suz.
SwatchLegend
SwatchLegend[{col1,…},{lbl1,…}] generates a legend that associates swatches of colors coli with labels lbli.
SwatchLegend[{col1,…},Automatic] generates a legend with placeholder labels for the colors coli.
SwatchLegend[{lbl1,…}] represents a legend with inherited colors within visualization functions.
Switch
Switch[expr,form1,value1,form2,value2,…] evaluates expr, then compares it with each of the formi in turn, evaluating and returning the valuei corresponding to the first match found.
Symbol
Symbol["name"] refers to a symbol with the specified name.
SymbolName
SymbolName[symbol] gives the name of the specified symbol.
SymletWavelet
SymletWavelet[] represents the Symlet wavelet of order 4.
SymletWavelet[n] represents the Symlet wavelet of order n.
Symmetric
Symmetric[{s1,…,sn}] represents the symmetry of a tensor that is symmetric in the slots si.
SymmetricGroup
SymmetricGroup[n] represents the symmetric group of degree n.
SymmetricKey
SymmetricKey[assoc] represents all the information needed for encryption, decryption, and other operations in a symmetric cryptographic system.
SymmetricMatrixQ
SymmetricMatrixQ[m] gives True if m is explicitly symmetric, and False otherwise.
SymmetricPolynomial
SymmetricPolynomial[k,{x1,…,xn}] gives the kth elementary symmetric polynomial in the variables x1,…,xn.
SymmetricReduction
SymmetricReduction[f,{x1,…,xn}] gives a pair of polynomials {p,q} in x1,…,xn such that f==p+q, where p is the symmetric part and q is the remainder.
SymmetricReduction[f,{x1,…,xn},{s1,…,sn}] gives the pair {p,q} with the elementary symmetric polynomials in p replaced by s1,…,sn.
Symmetrize
Symmetrize[tensor,sym] returns the symmetrization of tensor under the symmetry sym.
SymmetrizedArray
SymmetrizedArray[{pos1->val1,pos2->val2,…},dims,sym] yields an array of dimensions dims whose entries are given by those in the rules posi->vali or through the symmetry sym.
SymmetrizedArray[list] yields a symmetrized array version of list.
SymmetrizedArrayRules
SymmetrizedArrayRules[sa] returns a list of rules posi->vali of the symmetrized array sa.
SymmetrizedArrayRules[a,sym] returns a list of rules posi->vali of the array a after being symmetrized with symmetry sym.
SymmetrizedDependentComponents
SymmetrizedDependentComponents[comp,sym] gives the list of components that are equivalent to the component comp by the symmetry sym.
SymmetrizedIndependentComponents
SymmetrizedIndependentComponents[dims,sym] gives the list of independent components of an array of dimensions dims with the symmetry sym.
SymmetrizedReplacePart
SymmetrizedReplacePart[sa,{pos1->val1,pos2->val2,…}] replaces independent values of the symmetrized array sa as given by the rules posi->vali.
Synonyms
Synonyms["word"] returns the synonyms associated with the specified word.
SyntaxInformation
SyntaxInformation[f] gives information used to generate syntax coloring and other advisories when f[…] is entered as input.
SyntaxLength
SyntaxLength["string"] finds the number of characters starting at the beginning of a string that correspond to syntactically correct input for a single Wolfram Language expression.
SyntaxPacket
SyntaxPacket[integer] is a WSTP packet where integer indicates the position at which a syntax error was detected in the input line.
SyntaxQ
SyntaxQ["string"] returns True if the string corresponds to syntactically correct input for a single Wolfram Language expression, and returns False otherwise.
SyntaxQ["string",form] uses interpretation rules corresponding to the specified form.
SynthesizeMissingValues
SynthesizeMissingValues[{example1,example2,…}] replaces missing values in each example by generated values.
SynthesizeMissingValues[dist,data] uses the distribution dist to generate values.
TabFilling
TabFilling is an option for character selections that specifies how a Tab character is represented on the screen.
Table
Table[expr,n] generates a list of n copies of expr.
Table[expr,{i,imax}] generates a list of the values of expr when i runs from 1 to imax.
Table[expr,{i,imin,imax}] starts with i=imin.
Table[expr,{i,imin,imax,di}] uses steps di.
Table[expr,{i,{i1,i2,…}}] uses the successive values i1, i2, ….
Table[expr,{i,imin,imax},{j,jmin,jmax},…] gives a nested list. The list associated with i is outermost.
TableAlignments
TableAlignments is an option for TableForm and MatrixForm which specifies how entries in each dimension should be aligned.
TableDepth
TableDepth is an option for TableForm and MatrixForm that specifies the maximum number of levels to be printed in tabular or matrix format.
TableDirections
TableDirections is an option for TableForm and MatrixForm which specifies whether successive dimensions should be arranged as rows or columns.
TableHeadings
TableHeadings is an option for TableForm and MatrixForm that gives the labels to be printed for entries in each dimension of a table or matrix.
TableSpacing
TableSpacing is an option for TableForm and MatrixForm that specifies how many spaces should be left between each successive row or column.
TableView
TableView[{{expr11,expr12,…},{expr21,expr22,…},…}] displays as a spreadsheet-like table view for editing and viewing exprij.
TabSpacings
TabSpacings is an option for character selections that specifies the number of spaces in ems that the cursor advances when the Tab key is pressed.
TaggingRules
TaggingRules is an option for selections that specifies a list of strings to be associated with a selection.
TagSet
f/:lhs=rhs assigns rhs to be the value of lhs, and associates the assignment with the symbol f.
TagSetDelayed
f/:lhs:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with the symbol f.
TagUnset
f/:lhs=. removes any rules defined for lhs, associated with the symbol f.
Take
Take[list,n] gives the first n elements of list.
Take[list,-n] gives the last n elements of list.
Take[list,{m,n}] gives elements m through n of list.
Take[list,seq1,seq2,…] gives a nested list in which elements specified by seqi are taken at level i in list.
TakeDrop
TakeDrop[list,n] gives the pair {list1,list2}, where list1 contains the first n elements of list and list2 contains the rest.
TakeDrop[list,seq] gives the pair {Take[list,seq],Drop[list,seq]}.
TakeLargest
TakeLargest[data,n] gives the n largest elements of data, sorted in descending order.
TakeLargest[data->prop,n] gives the property prop for the n largest elements in data.
TakeLargest[data,n,p] uses the ordering function p for sorting.
TakeLargest[n] represents an operator form of TakeLargest that can be applied to an expression.
TakeLargestBy
TakeLargestBy[data,f,n] gives the n elements ei in data for which f[ei] is largest, sorted in descending order.
TakeLargestBy[data->prop,f,n] gives the property prop for the n elements in data for which f[ei] is largest.
TakeLargestBy[data,f,n,p] uses the ordering function p for sorting.
TakeLargestBy[f,n] represents an operator form of TakeLargestBy that can be applied to an expression.
TakeList
TakeList[list,{n1,n2,…}] gives the list of results obtained by successively taking ni elements from list.
TakeList[list,{seq1,seq2,…}] successively uses the sequence specifications seqi.
TakeList[list,seqs1,seqs2,…] gives a nested list in which elements specified by the lists seqsi are taken at level i in list.
TakeSmallest
TakeSmallest[data,n] gives the n smallest elements of data, sorted in ascending order.
TakeSmallest[data->prop,n] gives the property prop for the n smallest elements in data.
TakeSmallest[data,n,p] uses the order function p for sorting.
TakeSmallest[n] represents an operator form of TakeSmallest that can be applied to an expression.
TakeSmallestBy
TakeSmallestBy[data,f,n] gives the n elements ei in data for which f[ei] is smallest, sorted in ascending order.
TakeSmallestBy[data->prop,f,n] gives the property prop for the n elements in data for which f[ei] is smallest.
TakeSmallestBy[data,f,n,p] uses the ordering function p for sorting.
TakeSmallestBy[f,n] represents an operator form of TakeSmallestBy that can be applied to an expression.
TakeWhile
TakeWhile[list,crit] gives elements ei from the beginning of list, continuing so long as crit[ei] is True.
Tally
Tally[list] tallies the elements in list, listing all distinct elements together with their multiplicities.
Tally[list,test] uses test to determine whether pairs of elements should be considered equivalent, and gives a list of the first representatives of each equivalence class, together with their multiplicities.
Tan
Tan[z] gives the tangent of z.
Tanh
Tanh[z] gives the hyperbolic tangent of z.
TargetDevice
TargetDevice is an option for certain functions that specifies on which device the computation should be attempted.
TargetFunctions
TargetFunctions is an option for functions such as ComplexExpand and FindDistribution that specifies what functions to attempt to generate in the output.
TargetUnits
TargetUnits is an option used to specify the desired output units for visualization functions operating on Quantity expressions.
TaskAbort
TaskAbort[task] generates an interrupt to abort the current execution of a task.
TaskExecute
TaskExecute[task] immediately executes an instance of the specified task, independently of any schedule given.
TaskObject
TaskObject[spec] is an object that represents a background task.
TaskRemove
TaskRemove[task] terminates and removes the specified task.
TaskResume
TaskResume[task] resumes execution of the specified task.
Tasks
Tasks[type] gives a list of TaskObject expressions representing currently submitted tasks of given type.
TaskSuspend
TaskSuspend[task] suspends the execution of the specified task.
TaskWait
TaskWait[task] waits for the specified task to be completely finished.
TautologyQ
TautologyQ[bf] gives True if all combinations of values of variables make the Boolean function bf yield True.
TautologyQ[expr,{a1,a2,…}] gives True if all combinations of values of the ai make the Boolean expression expr yield True.
TelegraphProcess
TelegraphProcess[μ] represents a telegraph process with rate μ.
TemplateApply
TemplateApply[template] applies a template, evaluating all template elements it contains.
TemplateApply[template,args] applies a template, using args to fill slots in the template.
TemplateExpression
TemplateExpression[expr] represents an expression held until a template is applied, and then evaluated.
TemplateIf
TemplateIf[condition,tclause] represents an element of a template object that inserts tclause if the condition evaluates to True.
TemplateIf[condition,tclause,fclause] inserts fclause if the condition does not evaluate to True.
TemplateObject
TemplateObject[expr] represents a template object to be applied using functions like TemplateApply.
TemplateObject[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.
TemplateSequence
TemplateSequence[body,list] represents an element of a template object that yields a sequence consisting of body applied to each element in list.
TemplateSlot
TemplateSlot[n] represents a template slot to be filled from the nth argument when the template is applied.
TemplateSlot[name] represents a template slot to be filled from an element with key name in an association appearing in the first argument.
TemplateWith
TemplateWith["name"->value,expr] represents an element of a template object that evaluates expr after replacing TemplateSlot["name"] with value.
TemplateWith[{name1->value1,name2->value2, …},expr] evaluates expr with a list of key-value pairs.
TemporalData
TemporalData[{v1,v2,…},tspec] represents temporal data with values vi at times specified by tspec.
TemporalData[{{v11,v12,…},{v21,v22,…},…},tspec] represents a temporal data collection with values vij at times specified by tspec.
TemporalData[{{t1,v1},{t2,v2}…}] represents temporal data specified by time-value pairs {ti,vi}.
TemporalData[{{{t11,v11},{t12,v12}…},{{t21,v21},{t22,v22},…},…}] represents a temporal data collection given as lists of time-value pairs {tij,vij}.
TemporalRegularity
TemporalRegularity is an option for TemporalData, TimeSeries, and EventSeries that controls whether the paths are assumed to be uniformly spaced in time.
Temporary
Temporary is an attribute assigned to symbols which are created as local variables by Module.
TensorContract
TensorContract[tensor,{{s11,s12},{s21,s22},…}] yields the contraction of tensor in the pairs {si1,si2} of slots.
TensorDimensions
TensorDimensions[tensor] gives the list of dimensions of tensor.
TensorExpand
TensorExpand[texpr] expands out tensor-related products in the symbolic tensor expression texpr.
TensorProduct
TensorProduct[tensor1,tensor2,…] represents the tensor product of the tensori.
TensorRank
TensorRank[tensor] gives the rank of tensor.
TensorReduce
TensorReduce[texpr] attempts to return a canonical form for the symbolic tensor expression texpr.
TensorSymmetry
TensorSymmetry[tensor] gives the symmetry of tensor under permutations of its slots.
TensorSymmetry[tensor,slots] gives the symmetry under permutation of the specified list of slots.
TensorTranspose
TensorTranspose[tensor,perm] represents the tensor obtained by transposing the slots of tensor as given by the permutation perm.
TensorWedge
TensorWedge[tensor1,tensor2,…] represents the antisymmetrized tensor product of the tensori.
TestID
TestID is an option to TestCreate, VerificationTest and IntermediateTest that specifies a string used as an identifier for the test.
TestReport
TestReport["file"] gives a report of the results of the tests from a file.
TestReport[{test1,test2,…}] gives a report of the results of the testi.
TestReport[{report1,report2,…}] gives a unified report by merging all test reports reporti.
TestReportObject
TestReportObject[…] gives an object that represents the results of TestReport.
TestResultObject
TestResultObject[…] gives an object that represents the results of a VerificationTest.
Tetrahedron
Tetrahedron[] represents a regular tetrahedron centered at the origin with unit edge length.
Tetrahedron[l] represents a tetrahedron with edge length l.
Tetrahedron[{θ,ϕ},…] represents a tetrahedron rotated by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
Tetrahedron[{x,y,z},…] represents a tetrahedron centered at {x,y,z}.
Tetrahedron[{p1,p2,p3,p4}] represents a general filled tetrahedron with corners p1, p2, p3 and p4.
Tetrahedron[{{p1,1,p1,2,p1,3,p1,4},{p2,1,…},…}] represents a collection of tetrahedra.
TeXForm
TeXForm[expr] prints as a TeX version of expr.
Text
Text[expr] displays with expr in plain text format.
Text[expr,coords] is a graphics primitive that displays the textual form of expr centered at the point specified by coords.
TextAlignment
TextAlignment is an option for Cell, Style and related constructs which specifies how successive lines of text should be aligned.
TextCases
TextCases[text,form] gives a list of all cases of text identified as being of type form that appear in text.
TextCases[text,{form1,form2,…}] gives an association of results for all the types formi.
TextCases[text,formspec->prop] gives the specified property for each result found.
TextCases[text,formspec->{prop1,prop2,…}] gives a list of properties for each result found.
TextCases[text,spec,n] gives the first n cases found.
TextContents
TextContents[text] gives a dataset of information about entities, dates, quantities and other content-related elements found in text.
TextContents[text,form] searches for cases of the type form.
TextContents[text,{form1,form2,…}] searches for cases of types form1, form2, …
TextContents[text,forms,props] includes the property props for each object in the dataset produced.
TextElement
TextElement[text,props] represents an element of text with the specified properties.
TextElement[{elem1,elem2,…},props] represents text formed from a sequence of elements.
TextElement[elems] represents text where no properties are specified.
TextGrid
TextGrid[{{expr11,expr12,…},{expr21,expr22,…},…}] is an object that formats exprij textually and arranged in a two-dimensional grid.
TextJustification
TextJustification is an option for Cell and Inset which specifies how much lines of text can be stretched in order to make them be the same length.
TextPosition
TextPosition[text,form] gives a list of the starting and ending positions at which instances of form occur in text.
TextPosition[text,{form1,form2,…}] gives an association of results for all the types formi.
TextPosition[text,formspec,n] gives the positions of the first n cases found.
TextRecognize
TextRecognize[image] recognizes text in image and returns it as a string.
TextRecognize[image,level] returns a list of strings at the specified structural level.
TextRecognize[image,level,prop] returns prop for text at the given level.
TextRecognize[video,…] recognizes text in frames of video.
TextSearch
TextSearch[source,form] searches for files referenced by source that contain text matching form.
TextSearch[source,form,"prop"] returns the property prop for each result.
TextSearchReport
TextSearchReport[source,form] gives a structured report of files referenced by source that contain text matching form.
TextSentences
TextSentences["string"] gives a list of the runs of characters identified as sentences in string.
TextSentences["string",n] gives the first n sentences in string.
TextString
TextString[expr] gives a human-readable string representation of expr.
TextStructure
TextStructure["text"] generates a nested collection of TextElement objects representing the grammatical structure of natural language text.
TextStructure["text",form] generates a representation of the type specified by form of the grammatical structure of text.
TextStyle
TextStyle is an option for graphics functions and for Text which specifies the default style and font options with which text should be rendered.
TextTranslation
TextTranslation["text"] translates text into the current default language.
TextTranslation["text",lang] translates text into the language specified by lang.
TextTranslation["text",lang1->lang2] translates text from language lang1 to lang2.
Texture
Texture[obj] is a graphics directive that specifies that obj should be used as a texture on faces of polygons and other filled graphics objects.
Texture[obj,map] specifies the projection mapping map to assign to vertices of 3D graphics objects.
TextureCoordinateFunction
TextureCoordinateFunction is an option to Plot3D and similar functions that specifies a function that computes texture coordinates.
TextureCoordinateScaling
TextureCoordinateScaling is an option to Plot3D and similar functions that specifies whether arguments supplied to a texture coordinate function should be scaled to lie between 0 and 1.
TextWords
TextWords["string"] gives a list of the runs of characters identified as words in string.
TextWords["string",n] gives the first n words in string.
Therefore
Therefore[x,y] displays as x∴y.
ThermodynamicData
ThermodynamicData["name","property"] gives the value of the specific property for the substance "name".
ThermodynamicData["name","property",{parameter1->quantity1,parameter2->quantity}] gives the value of the specific property for the substance "name" at the specified parameters.
Thick
Thick is a graphics directive that specifies that lines which follow should be drawn thick.
Thickness
Thickness[r] is a graphics directive which specifies that lines which follow are to be drawn with thickness r. The thickness r is given as a fraction of the horizontal plot range.
Thin
Thin is a graphics directive that specifies that lines which follow should be drawn thin.
Thinning
Thinning[image] finds the skeletons of foreground regions in image by applying morphological thinning until convergence.
Thinning[image,n] performs n iterations of morphological thinning.
Thinning[image,n,t] treats values above t as foreground.
ThisLink
ThisLink is used in patterns for external packages to distinguish between several instances of the same package.
ThompsonGroupTh
ThompsonGroupTh[] represents the sporadic simple Thompson group Th.
Thread
Thread[f[args]] "threads" f over any lists that appear in args.
Thread[f[args],h] threads f over any objects with head h that appear in args.
Thread[f[args],h,n] threads f over objects with head h that appear in the first n args.
ThreadingLayer
ThreadingLayer[f] represents a net layer that takes several input arrays and applies a function f to corresponding array elements.
ThreadingLayer[f,bspec] allows array shapes to be conformed according to broadcasting specification bspec.
ThreeJSymbol
ThreeJSymbol[{j1,m1},{j2,m2},{j3,m3}] gives the values of the Wigner 3‐j symbol.
Threshold
Threshold[data] thresholds data by replacing values close to zero by zero.
Threshold[data,tspec] thresholds data using threshold specification tspec.
Threshold[image,…] replaces small values of image by zero.
Threshold[sound,…] replaces small values of sound by zero.
Through
Through[p[f,g,…][x,y,…]] gives p[f[x,y,…],g[x,y,…],…].
Through[expr,h] performs the transformation wherever h occurs in the head of expr.
Throw
Throw[value] stops evaluation and returns value as the value of the nearest enclosing Catch.
Throw[value,tag] is caught only by Catch[expr,form], where tag matches form.
Throw[value,tag,f] returns f[value,tag] as the top-level value if no appropriate Catch is found.
ThueMorse
ThueMorse[n] gives the nth term in the Thue–Morse sequence.
Thumbnail
Thumbnail[image] gives a thumbnail version of an image.
Thumbnail[file] gives a thumbnail of an image stored in a file.
Thumbnail[url] gives a thumbnail of an image stored at a URL.
Thumbnail[spec,size] gives a thumbnail with the specified maximum pixel size.
Thursday
Thursday is a day of the week.
TickDirection
TickDirection is an option for AxisObject that specifies where the ticks are drawn relative to the axis.
TickLabelOrientation
TickLabelOrientation is an option for AxisObject that specifies how the tick labels should be oriented relative to the axis.
TickLabelPositioning
TickLabelPositioning is an option for AxisObject that specifies how the tick labels should be positioned relative to the ticks.
TickLabels
TickLabels is an option for AxisObject that specifies how the tick marks should be labeled.
TickLengths
TickLengths is an option for AxisObject that specifies the lengths of the tick marks.
TickPositions
TickPositions is an option for AxisObject that specifies where the tick marks should be positioned.
Ticks
Ticks is an option for graphics functions that specifies tick marks for axes.
TicksStyle
TicksStyle is an option for graphics functions which specifies how ticks should be rendered.
TideData
TideData[spec] returns the tidal properties for a location or a set of tidal parameters.
TideData[spec,prop] returns the specified property for the location or tidal parameters indicated.
TideData[spec,prop,datespec] returns the value of a specified property for a date or set of dates.
Tilde
Tilde[x,y,…] displays as x∼y∼….
TildeEqual
TildeEqual[x,y,…] displays as x≃y≃….
TildeFullEqual
TildeFullEqual[x,y,…] displays as x≅y≅….
TildeTilde
TildeTilde[x,y,…] displays as x≈y≈….
TimeConstrained
TimeConstrained[expr,t] evaluates expr, stopping after t seconds.
TimeConstrained[expr,t,failexpr] returns failexpr if the time constraint is not met.
TimeConstraint
TimeConstraint is an option for various functions that specifies the maximum time to spend doing a particular operation.
TimeDirection
TimeDirection is an option for Sunrise, Sunset, and related functions that specifies whether the next or last event should be returned.
TimeGoal
TimeGoal is an option for various functions that specifies how long to spend doing a particular operation.
TimelinePlot
TimelinePlot[{date1,date2,…}] makes a timeline plot with dates date1, date2, ….
TimelinePlot[{event1,event2,…}] makes a timeline plot with events event1, event2, ….
TimelinePlot[{data1,data2,…}] makes a timeline plot from multiple event datasets datai.
TimeObject
TimeObject[] represents the current time.
TimeObject[{h,m,s}] represents a time object of standard normalized form.
TimeObject[date] gives the time component of the specified date representation.
TimeObject[rtime,gran] gives the time object of granularity gran that includes the reference time rtime.
TimeObjectQ
TimeObjectQ[expr] gives True if expr is a TimeObject with valid arguments, and False otherwise.
TimeRemaining
TimeRemaining[] gives the number of seconds remaining until the earliest enclosing TimeConstrained will request the current computation to stop.
Times
x*y*z, x×y×z, or x y z represents a product of terms.
TimesBy
x*=c multiplies x by c and returns the new value of x.
TimeSeries
TimeSeries[{{t1,v1},{t2,v2}…}] represents a time series specified by time-value pairs {ti,vi}.
TimeSeries[{v1,v2,…},tspec] represents a time series with values vi at times specified by tspec.
TimeSeriesAggregate
TimeSeriesAggregate[tseries,dt] computes the mean value of tseries over non-overlapping windows of width dt.
TimeSeriesAggregate[tseries,dt,f] applies the function f to the values of tseries in non-overlapping windows of width dt.
TimeSeriesForecast
TimeSeriesForecast[tproc,data,k] gives the k-step-ahead forecast beyond data according to the time series process tproc.
TimeSeriesForecast[tsmod,k] gives the k-step-ahead forecast for TimeSeriesModel tsmod.
TimeSeriesInsert
TimeSeriesInsert[tseries,{t,v}] inserts a value v at time t in the time series tseries.
TimeSeriesInsert[tseries1,tseries2] inserts the time-value pairs from tseries2 into tseries1.
TimeSeriesInvertibility
TimeSeriesInvertibility[tproc] gives conditions for the time series process tproc to be invertible.
TimeSeriesMap
TimeSeriesMap[f,tseries] applies f to the values in tseries.
TimeSeriesMapThread
TimeSeriesMapThread[f,tseries] gives {{t1,f[t1,x1]},{t2,f[t2,x2]},…} for the time series tseries.
TimeSeriesMapThread[f,tseries,{{a1,a2,…},{b1,b2,…},…}] gives {{t1,f[t1,x1,a1,b1,…]},{t2,f[t2,x2,a2,b2,…]},…} for the time series tseries.
TimeSeriesModel
TimeSeriesModel[…] represents the symbolic time series model obtained from TimeSeriesModelFit.
TimeSeriesModelFit
TimeSeriesModelFit[data] constructs a time series model for data from an automatically selected model family.
TimeSeriesModelFit[data,mspec] constructs a time series model for data from a model family specified by mspec.
TimeSeriesResample
TimeSeriesResample[tseries] uniformly resamples tseries according to its minimum time increment.
TimeSeriesResample[tseries,rspec] resamples tseries according to rspec.
TimeSeriesRescale
TimeSeriesRescale[tseries,{tmin,tmax}] rescales the times in time series tseries to run from tmin to tmax.
TimeSeriesRescale[tseries,{tmin,tmax,tu}] rescales times in units of tu including "Month", "Quarter", or "Year".
TimeSeriesShift
TimeSeriesShift[tseries,shift] shifts the time series tseries to the left or right according to shift.
TimeSeriesThread
TimeSeriesThread[f,{tseries1,tseries2,…}] combines the tseriesi using the function f.
TimeSeriesWindow
TimeSeriesWindow[tseries,{tmin,tmax}] gives the elements of the time series tseries that fall between tmin and tmax.
TimeSeriesWindow[tseries,windowspec] gives the elements of the time series tseries that satisfy the window specification windowspec.
TimeValue
TimeValue[s,i,t] calculates the time value of a security s at time t for an interest specified by i.
TimeWarpingCorrespondence
TimeWarpingCorrespondence[s1,s2] gives the time warping (DTW) similarity path between sequences s1 and s2.
TimeWarpingCorrespondence[s1,s2,r] uses a window of radius r for local search.
TimeWarpingDistance
TimeWarpingDistance[s1,s2] gives the dynamic time warping (DTW) distance between sequences s1 and s2.
TimeWarpingDistance[s1,s2,r] uses a window of radius r for local search.
TimeZone
TimeZone is an option for DateObject, DateString, and related functions that specifies the time zone to use for dates and times.
TimeZoneConvert
TimeZoneConvert[time,timezone] converts the date or time object time to the specified time zone timezone.
TimeZoneConvert[time] converts to the current $TimeZone value.
TimeZoneConvert[{time1,…,timen},timezone] converts time1 through timen to the specified timezone.
TimeZoneOffset
TimeZoneOffset[tz] gives the numeric offset between the time zone tz and GMT on the current date.
TimeZoneOffset[loc] gives the numeric offset between the time zone for the location loc and GMT.
TimeZoneOffset[tz,base] gives the numeric offset between tz and the specified base time zone.
TimeZoneOffset[tz,date] gets a list of possible time zone offsets for tz at the given date list.
TimeZoneOffset[tz,base,date] gives the numeric offset between tz and base on the specified date.
Timing
Timing[expr] evaluates expr, and returns a list of the time in seconds used, together with the result obtained.
Tiny
Tiny is a style or option setting that specifies that objects should be tiny.
TitsGroupT
TitsGroupT[] represents the simple Tits group T.
ToCharacterCode
ToCharacterCode["string"] gives a list of the integer codes corresponding to the characters in a string.
ToCharacterCode["string","encoding"] gives integer codes according to the specified encoding.
ToColor
ToColor[color, form] converts color to form if form is GrayLevel, RGBColor or CMYKColor. Otherwise form[color] is evaluated and the result is expected to be a valid color directive.
ToContinuousTimeModel
ToContinuousTimeModel[lsys] gives the continuous-time approximation of the discrete-time systems models lsys.
ToContinuousTimeModel[tfm,s] specifies the transform variable s.
ToDate
ToDate[time] converts an absolute time in seconds since the beginning of January 1, 1900 to a date of the form {y,m,d,h,m,s}.
Today
Today gives a DateObject representing the current day.
ToDiscreteTimeModel
ToDiscreteTimeModel[lsys,τ] gives the discrete-time approximation, with sampling period τ, of the continuous-time systems models lsys.
ToDiscreteTimeModel[tfm,τ,z] specifies the transform variable z.
ToEntity
ToEntity[expr] returns an entity object corresponding to the given expression.
ToEntity[expr,type] returns an entity object of the specified type corresponding to expr.
ToeplitzMatrix
ToeplitzMatrix[n] gives the n×n Toeplitz matrix with first row and first column being successive integers.
ToeplitzMatrix[{c1,c2,…,cn}] gives the Toeplitz matrix whose first column consists of entries c1, c2, ….
ToeplitzMatrix[{c1,c2,…,cm},{r1,r2,…, rn}] gives the Toeplitz matrix with entries ci down the first column, and ri across the first row.
ToFileName
ToFileName["directory","name"] assembles a full file name from a directory name and a file name.
ToFileName[{dir1,dir2,…},name] assembles a full file name from a hierarchy of directory names.
ToFileName[{dir1,dir2,…}] assembles a single directory name from a hierarchy of directory names.
Together
Together[expr] puts terms in a sum over a common denominator, and cancels factors in the result.
ToInvertibleTimeSeries
ToInvertibleTimeSeries[tproc] returns an invertible version of a time series process tproc.
TokenWords
TokenWords is an option for Read and related functions which gives a list of token words to be used to delimit words.
Tolerance
Tolerance is an option for various numerical options which specifies the tolerance that should be allowed in computing results.
ToLowerCase
ToLowerCase[string] yields a string in which all letters have been converted to lowercase.
Tomorrow
Tomorrow gives a DateObject representing the following day.
ToNumberField
ToNumberField[a,θ] expresses the algebraic number a in the number field generated by θ.
ToNumberField[{a1,a2,…},θ] expresses the ai in the field generated by θ.
ToNumberField[{a1,a2,…}] expresses the ai in a common extension field generated by a single algebraic number.
TooBig
TooBig is an internal symbol.
ToonShading
ToonShading[] is a three-dimensional graphics directive specifying that surfaces that follow are to be drawn to emulate two-dimensional flat objects.
ToonShading[col] uses the color col as base color.
ToonShading[{dcol,bcol,hcol}] uses the dark color dcol, the base color bcol and highlight color hcol.
ToonShading[{w1,w2,w3}->{dcol,bcol,hcol}] uses the colors dcol, bcol and hcol weighted by the wi.
ToonShading["scheme"] uses the specified discrete color scheme in ColorData.
Top
Top is a symbol that represents the top for purposes of alignment and positioning.
TopHatTransform
TopHatTransform[image,ker] gives the morphological top-hat transform of image with respect to structuring element ker.
TopHatTransform[image,r] gives the top-hat transform with respect to a range-r square.
TopHatTransform[data,…] applies top-hat transform to an array of data.
ToPolarCoordinates
ToPolarCoordinates[{x,y}] gives the {r,θ} polar coordinates corresponding to the Cartesian coordinates {x,y}.
ToPolarCoordinates[{x1,x2,…,xn}] gives the hyperspherical coordinates corresponding to the Cartesian coordinates {x1,x2,…,xn}.
TopologicalSort
TopologicalSort[g] gives a list of vertices of g in topologically sorted order for a directed acyclic graph g.
TopologicalSort[{v->w,…}] uses rules v->w to specify the graph g.
ToRadicals
ToRadicals[expr] attempts to express all Root objects in expr in terms of radicals.
ToRules
ToRules[eqns] takes logical combinations of equations, in the form generated by Roots and Reduce, and converts them to lists of rules, of the form produced by Solve.
Torus
Torus[{x,y,z},{rinner,router}] represents a torus centered at {x,y,z} with inner radius rinner and outer radius router.
ToSphericalCoordinates
ToSphericalCoordinates[{x,y,z}] gives the {r,θ,ϕ} spherical coordinates corresponding to the Cartesian coordinates {x,y,z}.
ToString
ToString[expr] gives a string corresponding to the printed form of expr in OutputForm.
ToString[expr,form] gives the string corresponding to output in the specified form.
Total
Total[list] gives the total of the elements in list.
Total[list,n] totals all elements down to level n.
Total[list,{n}] totals elements at level n.
Total[list,{n1,n2}] totals elements at levels n1 through n2.
TotalLayer
TotalLayer[] represents a net layer taking a list of input arrays and performing elementwise addition on them.
TotalVariationFilter
TotalVariationFilter[data] iteratively reduces noise while preserving rapid transitions in data.
TotalVariationFilter[data,param] assumes a regularization parameter value param.
TotalWidth
TotalWidth is an option that can be set for output streams to specify the maximum total number of characters of text that should be printed for each output expression. Short forms of expressions are given if the number of characters needed to print the whole expression is too large.
TouchscreenAutoZoom
TouchscreenAutoZoom is an option for Manipulate and Graphics3D that determines whether the interface zooms to full-screen when it is activated by touching it on supported touch screen platforms.
TouchscreenControlPlacement
TouchscreenControlPlacement is an option for Manipulate that determines the placement of the slide-out control panel on supported touchscreen platforms.
ToUpperCase
ToUpperCase[string] yields a string in which all letters have been converted to uppercase.
TourVideo
TourVideo[input,{step1,step2,…}] generates a video by taking a tour at steps stepi around graphics.
TourVideo[input,{{t1,step1},{t2,step2},…}] takes a tour with steps stepi at times ti around graphics.
TourVideo[input,func] samples the function func to generate step specifications for each frame.
Tr
Tr[list] finds the trace of the matrix or tensor list.
Tr[list,f] finds a generalized trace, combining terms with f instead of Plus.
Tr[list,f,n] goes down to level n in list.
Trace
Trace[expr] generates a list of all expressions used in the evaluation of expr.
Trace[expr,form] includes only those expressions that match form.
Trace[expr,s] includes all evaluations that use transformation rules associated with the symbol s.
TraceAbove
TraceAbove is an option for Trace and related functions which specifies whether to include evaluation chains which contain the evaluation chain containing the pattern form sought.
TraceAction
TraceAction is an option for TracePrint and TraceDialog that specifies the function to be applied to each expression they trace.
TraceBackward
TraceBackward is an option for Trace and related functions that specifies whether to include preceding expressions on the evaluation chain that contains the pattern form sought.
TraceDepth
TraceDepth is an option for Trace and related functions which specifies the maximum nesting of evaluation chains that are to be included.
TraceDialog
TraceDialog[expr] initiates a dialog for every expression used in the evaluation of expr.
TraceDialog[expr,form] initiates a dialog only for expressions which match form.
TraceDialog[expr,s] initiates dialogs only for expressions whose evaluations use transformation rules associated with the symbol s.
TraceForward
TraceForward is an option for Trace and related functions which specifies whether to include later expressions on the evaluation chain that contains the pattern form sought.
TraceInternal
TraceInternal is an option for Trace and related functions which, if True or False, specifies whether to trace evaluations of expressions generated internally by Mathematica. The intermediate Automatic setting traces a selected set of internal evaluations including Messages and sets or unsets of visible symbols.
TraceLevel
TraceLevel[] returns the level currently being traced when it appears within Trace and related functions.
TraceOff
TraceOff is an option for Trace and related functions which specifies forms inside which tracing should be switched off.
TraceOn
TraceOn is an option for Trace and related functions which specifies when tracing should be switched on.
TraceOriginal
TraceOriginal is an option for Trace that specifies whether to test the form of each expression before its head and arguments are evaluated.
TracePrint
TracePrint[expr] prints all expressions used in the evaluation of expr.
TracePrint[expr,form] includes only those expressions which match form.
TracePrint[expr,s] includes all evaluations which use transformation rules associated with the symbol s.
TraceScan
TraceScan[f,expr] applies f to all expressions used in the evaluation of expr.
TraceScan[f,expr,form] includes only those expressions which match form.
TraceScan[f,expr,s] includes all evaluations which use transformation rules associated with the symbol s.
TraceScan[f,expr,form,fp] applies f before evaluation and fp after evaluation to expressions used in the evaluation of expr.
TrackedSymbols
TrackedSymbols is an option to Refresh, Manipulate, and related functions that specifies which symbols should trigger updates when their values are changed.
TrackingFunction
TrackingFunction is an option for Manipulate controls that specifies functions to use during interactive changing or editing.
TracyWidomDistribution
TracyWidomDistribution[β] represents a Tracy–Widom distribution with Dyson index β.
TradingChart
TradingChart[{{date1,{open1,high1,low1,close1,volume1}},…}] makes a chart showing prices and volume for each date.
TradingChart[{"name",daterange}] makes a financial chart for the financial entity "name" over the daterange.
TradingChart[{…},{ind1,ind2,…}] makes a financial chart with indicators ind1, ind2, ….
TraditionalForm
TraditionalForm[expr] prints as an approximation to the traditional mathematical notation for expr.
TraditionalFunctionNotation
TraditionalFunctionNotation is an option for selections that specifies whether input of the form f(x) is interpreted by the kernel as a function or as a product.
TrainingProgressCheckpointing
TrainingProgressCheckpointing is an option for NetTrain that specifies how to save copies of the net during training.
TrainingProgressFunction
TrainingProgressFunction is an option for NetTrain that specifies a function to run periodically during training.
TrainingProgressMeasurements
TrainingProgressMeasurements is an option for NetTrain that specifies measurements to make while training is in progress.
TrainingProgressReporting
TrainingProgressReporting is an option for NetTrain and related functions that specifies how to report the progress of training.
TrainingStoppingCriterion
TrainingStoppingCriterion is an option for NetTrain that specifies a criterion for stopping training early in order to prevent overfitting.
TrainingUpdateSchedule
TrainingUpdateSchedule is an option for NetTrain that specifies which arrays of the network can be updated at each step of the optimization process.
TrainTextContentDetector
TrainTextContentDetector[{text1->{span1->class1,…},…}] trains a ContentDetectorFunction[…] based on the examples given.
TransferFunctionCancel
TransferFunctionCancel[tfm] cancels common poles and zeros in the TransferFunctionModel tfm.
TransferFunctionCancel[tfm,crit] cancels only common pole-zero pairs ei for which crit[ei] is True.
TransferFunctionExpand
TransferFunctionExpand[tfm] expands polynomial terms in the numerators and denominators of the TransferFunctionModel tfm.
TransferFunctionFactor
TransferFunctionFactor[tfm] factors the polynomial terms in the numerators and denominators of the TransferFunctionModel tfm.
TransferFunctionModel
TransferFunctionModel[g[s],s] represents the model of the transfer-function matrix g[s] with complex variable s.
TransferFunctionModel[{n[s],d[s]},s] specifies the numerator n[s] and denominator d[s] of a transfer-function model.
TransferFunctionModel[{z,p,g},s] specifies the zeros z, poles p, and gain g of a transfer-function model.
TransferFunctionModel[sys] gives the transfer-function model of the systems model sys.
TransferFunctionPoles
TransferFunctionPoles[tfm] gives a matrix of roots of the denominators in the TransferFunctionModel tfm.
TransferFunctionPoles[tfm,reg] only gives the roots inside the region reg on the complex plane.
TransferFunctionTransform
TransferFunctionTransform[f,tf] transforms the TransferFunctionModel object tf using the transformation function f.
TransferFunctionZeros
TransferFunctionZeros[tfm] gives a matrix of roots of the numerators in the TransferFunctionModel tfm.
TransferFunctionZeros[tfm,reg] only gives the roots inside the region reg on the complex plane.
TransformationClass
TransformationClass is an option that specifies the class of geometric transformations to be used.
TransformationFunction
TransformationFunction[data] represents a transformation function that applies geometric and other transformations.
TransformationFunctions
TransformationFunctions is an option for Simplify and FullSimplify which gives the list of functions to apply to try to transform parts of an expression.
TransformationMatrix
TransformationMatrix[tfun] gives the homogeneous matrix associated with a TransformationFunction object.
TransformedDistribution
TransformedDistribution[expr,xdist] represents the transformed distribution of expr where the random variable x follows the distribution dist.
TransformedDistribution[expr,{x1,x2,…}dist] represents the transformed distribution of expr where {x1,x2,…} follows the multivariate distribution dist.
TransformedDistribution[expr,xproc] represents the transformed distribution where expr contains expressions of the form x[t], referring the value at time t from the random process proc.
TransformedDistribution[expr,{x1dist1,x2dist2 ,…}] represents a transformed distribution where x1, x2, … are independent and follow the distributions dist1, dist2, ….
TransformedField
TransformedField[t,f,{x1,x2,…,xn}->{y1,y2,…,yn}] uses the coordinate transformation t to transform the scalar, vector, or tensor field f from coordinates xi to yi.
TransformedProcess
TransformedProcess[expr,xproc,t] represents the transformed process of expr where the variable x follows the random process proc and t denotes the time.
TransformedProcess[expr,{x1proc1,x2proc2,…},t] represents a transformed process where x1, x2, … are independent and follow the processes proc1, proc2, ….
TransformedRegion
TransformedRegion[reg,f] represents the transformed region {f(p)|p∈reg}, where reg is a region and f is a function.
TransitionDirection
TransitionDirection is an option for PaneSelector that specifies the direction in which a transition moves.
TransitionDuration
TransitionDuration is an option for PaneSelector that specifies the duration in seconds that a transition effect should last.
TransitionEffect
TransitionEffect is an option for PaneSelector that specifies the visual effect used when transitioning between states.
TransitiveClosureGraph
TransitiveClosureGraph[g] gives the transitive closure of the graph g.
TransitiveClosureGraph[{v->w,…}] uses rules v->w to specify the graph g.
TransitiveReductionGraph
TransitiveReductionGraph[g] gives a transitive reduction of the graph g.
TransitiveReductionGraph[{v->w,…}] uses rules v->w to specify the graph g.
Translate
Translate[g,{x,y,…}] represents graphics primitives g translated by the vector {x,y,…}.
Translate[g,{{x1,y1,…},{x2,y2,…}, …}] represents multiple copies of g translated by a collection of vectors.
TranslationOptions
TranslationOptions->{opt1->val1,opt2->val2,…} is an option for Style and Cell that controls how code translations are displayed.
TranslationTransform
TranslationTransform[v] gives a TransformationFunction that represents translation of points by a vector v.
Transliterate
Transliterate["string"] attempts to transliterate string into plain ASCII.
Transliterate["string",script] attempts to transliterate string into the specified writing script script.
Transliterate["string",script1->script2] attempts to transliterate string from script1 to script2.
Transparent
Transparent represents perfect transparency in graphics or style specifications.
TravelDirections
TravelDirections[{loc1,loc2,…}] generates directions for travel from loc1 to loc2, ….
TravelDirections[{loc1,loc2,…},"prop"] gives the property prop of travel directions.
TravelDirectionsData
TravelDirectionsData[…] represents travel directions generated by TravelDirections.
TravelDistance
TravelDistance[{loc1,loc2,…}] gives the estimated distance for travel from loc1 to loc2, ….
TravelDistanceList
TravelDistanceList[{loc1,loc2,…,locn}] returns the list {TravelDistance[loc1,loc2],…,TravelDistance[locn-1,locn]}.
TravelMethod
TravelMethod is an option for TravelDirections and related functions that specifies the mode of transportation to assume.
TravelTime
TravelTime[{loc1,loc2,…}] gives the estimated time to travel from loc1 to loc2, ….
Tree
Tree[{subtree1,subtree2,…}] represents a tree with a list of child subtrees subtreei.
Tree[<|key1->subtree1,key2->subtree2,…|>] specifies the children as an association with keys keyi.
Tree[data,subtrees] represents a tree containing data in its root, with children given by subtrees.
TreeCases
TreeCases[tree,pattern] gives a list of subtrees of tree with data matching pattern.
TreeCases[tree,pattern,levelspec] gives a list of all subtrees of tree on levels specified by levelspec with data that matches the pattern.
TreeCases[tree,pattern,levelspec,n] gives the first n subtrees in tree with data that matches the pattern.
TreeCases[pattern] represents an operator form of TreeCases that can be applied to a tree.
TreeChildren
TreeChildren[tree] extracts the children of the root of the Tree object tree.
TreeCount
TreeCount[tree,pattern] gives the number of subtrees of tree whose data matches pattern.
TreeCount[tree,pattern,levelspec] gives the total number of subtrees with data matching pattern that appear at the levels in tree specified by levelspec.
TreeCount[pattern] represents an operator form of TreeCount that can be applied to a tree.
TreeData
TreeData[tree] extracts the data in the root of the Tree object tree.
TreeDelete
TreeDelete[tree,pos] deletes the subtree of tree at the position specified by pos.
TreeDelete[tree,{pos1,pos2,…}] deletes subtrees at several positions.
TreeDelete[pos] represents an operator form of TreeDelete that can be applied to a tree.
TreeDepth
TreeDepth[tree] gives the maximum level of tree.
TreeDepth[tree,pattern] gives the maximum level of the subtree with data matching pattern.
TreeElementLabel
TreeElementLabel is an option for Tree and related functions that specifies what labels should be used for subtree elements.
TreeElementStyle
TreeElementStyle is an option for Tree and related functions that specifies what styles should be used for subtree elements.
TreeExpression
TreeExpression[tree] gives an expression from the structure of the Tree object tree.
TreeExpression[tree,struct] gives an expression with data and subtrees of tree interpreted as specified by struct.
TreeExtract
TreeExtract[tree,pos] extracts the subtree of tree at the position specified by pos.
TreeExtract[tree,{pos1,pos2,…}] extracts a list of subtrees of tree.
TreeExtract[tree,pos,h] extracts subtrees of tree, applying h to each subtree.
TreeExtract[pos] represents an operator form of TreeExtract that can be applied to a tree.
TreeForm
TreeForm[expr] displays expr as a tree with different levels at different depths.
TreeForm[expr,n] displays expr as a tree only down to level n.
TreeGraph
TreeGraph[{v1,v2,…},{u1,u2,…}] yields a tree where ui is the predecessor of vi.
TreeGraph[{e1,e2,…}] yields a tree with edges ej.
TreeGraph[{v1,v2,…},{e1,e2,…}] yields a tree with vertices vi and edges ej.
TreeGraph[{…,wi[vi,…],…},{…,wj[ej,…],…}] yields a tree with vertex and edge properties defined by the symbolic wrappers wk.
TreeGraph[{vi->vj,…}] uses rules vi->vj to specify a tree.
TreeGraphQ
TreeGraphQ[g] yields True if the graph g is a tree and False otherwise.
TreeInsert
TreeInsert[tree,child,pos] inserts child at the position specified by pos in tree.
TreeInsert[tree,child,{pos1,pos2,…}] inserts child at several positions.
TreeInsert[child,pos] represents an operator form of TreeInsert that can be applied to a tree.
TreeLayout
TreeLayout is an option to Tree and related functions that specifies what layout to use.
TreeLeafQ
TreeLeafQ[tree] gives True if tree is a Tree object with no children, and gives False otherwise.
TreeLeaves
TreeLeaves[tree] returns the list of leaves of the tree tree.
TreeLevel
TreeLevel[tree,levelspec] gives a list of all subtrees of tree on levels specified by levelspec.
TreeLevel[tree,levelspec->elem] gives a list of the element elem of subtrees on levels specified by levelspec.
TreeLevel[levelspec] represents an operator form of TreeLevel that can be applied to a tree.
TreeMap
TreeMap[f,tree] applies f to the data of each subtree of tree.
TreeMap[f,tree,levelspec] applies f to the data of subtrees on levels of tree specified by levelspec.
TreeMap[f,tree,levelspec->elems] applies f to the elements elems of subtrees on levels specified by levelspec.
TreeMap[f] represents an operator form of TreeMap that can be applied to a tree.
TreeMapAt
TreeMapAt[f,tree,pos] applies f to the data at the position specified by pos in tree.
TreeMapAt[f,tree,{pos1,pos2,…}] applies f to the data at several positions.
TreeMapAt[f,pos] represents an operator form of TreeMapAt that can be applied to a tree.
TreeOutline
TreeOutline[tree] gives an outline of the data in tree as a nested OpenerView.
TreeOutline[tree,pos] gives an outline of the data in tree initially opened to the subtree at the position specified by pos.
TreeOutline[tree,{pos1,pos2,…}] opens the outline to several positions.
TreePlot
TreePlot[g] generates a tree plot of the graph g.
TreePlot[{e1,e2,…}] generates a tree plot of the graph with edges ej.
TreePlot[{…,w[ei],…}] plots ei with features defined by the symbolic wrapper w.
TreePlot[{vi1->vj1,…}] uses rules vi1->vj1 to specify the graph g.
TreePlot[m] generates a tree plot of the graph represented by the adjacency matrix m.
TreePlot[…,v->pos] places the root v in the plot at position pos.
TreePosition
TreePosition[tree,pattern] gives a list of the positions of subtrees of tree whose data matches pattern.
TreePosition[tree,pattern,levelspec] finds only matches that appear on levels of tree specified by levelspec.
TreePosition[tree,pattern,levelspec,n] gives the positions of the first n matches found.
TreePosition[pattern] represents an operator form of TreePosition that can be applied to a tree.
TreeQ
TreeQ[tree] yields True if tree is a valid Tree object and False otherwise.
TreeReplacePart
TreeReplacePart[tree,pos->new] gives a tree in which the subtree of tree at the position specified by pos is replaced with new.
TreeReplacePart[tree,{pos1->new1,pos2->new2,…}] replaces subtrees at positions specified by posi with newi.
TreeReplacePart[tree,{pos1,pos2,…}->new] replaces all subtrees at positions specified by posi with new.
TreeReplacePart[tree,{{pos1,1,pos1,2,…}->new1,…}] replaces subtrees at positions specified by {posi,1,posi,2,…} with newi.
TreeReplacePart[pos->new] represents an operator form of TreeReplacePart that can be applied to a tree.
TreeRules
TreeRules[tree] returns the rules associated with the Tree object tree.
TreeScan
TreeScan[f,tree] evaluates f applied to the data of each subtree of tree in turn.
TreeScan[f,tree,levelspec] applies f to the data of subtrees on levels of tree specified by levelspec.
TreeScan[f,tree,levelspec->elems] applies f to the elements elems of subtrees on levels specified by levelspec.
TreeScan[f] represents an operator form of TreeScan that can be applied to a tree.
TreeSelect
TreeSelect[tree,crit] picks out all subtrees treei of tree for which crit[treei] is True.
TreeSelect[tree,crit,n] picks out the first n subtrees for which crit[treei] is True.
TreeSelect[tree,crit,levelspec,n] picks out subtrees on levels specified by levelspec.
TreeSelect[crit] represents an operator form of TreeSelect that can be applied to a tree.
TreeSize
TreeSize[tree] gives the number of subtrees of tree.
TreeTraversalOrder
TreeTraversalOrder is an option for TreeMap and related functions that specifies the order to visit subtrees.
TrendStyle
TrendStyle is an option to CandlestickChart, RenkoChart, and other financial charting functions that specifies how to style price trends.
Triangle
Triangle[{p1,p2,p3}] represents a filled triangle with corner points p1, p2, and p3.
Triangle[{{p11,p12,p13},…}] represents a collection of triangles.
TriangleCenter
TriangleCenter[tri,type] gives the specified type of center for the triangle tri.
TriangleCenter[tri] gives the centroid of the triangle.
TriangleConstruct
TriangleConstruct[tri,type] gives the specified type of construct for the triangle tri.
TriangleMeasurement
TriangleMeasurement[tri,type] gives the specified type of measurement for the triangle tri.
TriangleWave
TriangleWave[x] gives a triangle wave that varies between -1 and +1 with unit period.
TriangleWave[{min,max},x] gives a triangle wave that varies between min and max with unit period.
TriangularDistribution
TriangularDistribution[{min,max}] represents a symmetric triangular statistical distribution giving values between min and max.
TriangularDistribution[] represents a symmetric triangular statistical distribution giving values between 0 and 1.
TriangularDistribution[{min,max},c] represents a triangular distribution with mode at c.
TriangulateMesh
TriangulateMesh[mr] generates a triangulation of the mesh region mr.
Trig
Trig is an option for various polynomial manipulation functions that specifies whether trigonometric functions should be treated like polynomial elements.
TrigExpand
TrigExpand[expr] expands out trigonometric functions in expr.
TrigFactor
TrigFactor[expr] factors trigonometric functions in expr.
TrigFactorList
TrigFactorList[expr] factors trigonometric functions in expr, yielding a list of lists containing trigonometric monomials and exponents.
TrigReduce
TrigReduce[expr] rewrites products and powers of trigonometric functions in expr in terms of trigonometric functions with combined arguments.
TrigToExp
TrigToExp[expr] converts trigonometric functions in expr to exponentials.
TrimmedMean
TrimmedMean[list,f] gives the mean of the elements in list after dropping a fraction f of the smallest and largest elements.
TrimmedMean[list,{f1,f2}] gives the mean when a fraction f1 of the smallest elements and a fraction f2 of the largest elements are removed.
TrimmedMean[list] gives the 5% trimmed mean TrimmedMean[list,0.05].
TrimmedMean[dist,…] gives the trimmed mean of a univariate distribution dist.
TrimmedVariance
TrimmedVariance[list,f] gives the variance of the elements in list after dropping a fraction f of the smallest and largest elements.
TrimmedVariance[list,{f1,f2}] gives the variance when a fraction f1 of the smallest elements and a fraction f2 of the largest elements are removed.
TrimmedVariance[list] gives the 5% trimmed variance TrimmedVariance[list,0.05].
TrimmedVariance[dist,…] gives the trimmed variance of a univariate distribution dist.
TropicalStormData
TropicalStormData[entity,property] gives the value of the specified property for the tropical storm entity.
TropicalStormData[{entity1,entity2,…},property] gives a list of property values for the specified tropical storm entities.
TropicalStormData[entity,property,annotation] gives the specified annotation associated with the given property.
True
True is the symbol for the Boolean value true.
TrueQ
TrueQ[expr] yields True if expr is True, and yields False otherwise.
TruncatedDistribution
TruncatedDistribution[{xmin,xmax},dist] represents the distribution obtained by truncating the values of dist to lie between xmin and xmax.
TruncatedDistribution[{{xmin,xmax},{ymin,ymax},…},dist] represents the distribution obtained by truncating the values of the multivariate distribution dist to lie between xmin and xmax, ymin and ymax, etc.
TruncatedPolyhedron
TruncatedPolyhedron[poly] gives the truncated polyhedron of poly by truncating all vertices.
TruncatedPolyhedron[poly,l] truncates the polyhedron poly by a length ratio l at its vertices.
TsallisQExponentialDistribution
TsallisQExponentialDistribution[λ,q] represents a Tsallis q-exponential distribution with scale inversely proportional to parameter λ.
TsallisQGaussianDistribution
TsallisQGaussianDistribution[μ,β,q] represents a Tsallis q-Gaussian distribution with mean μ, scale parameter β, and deformation parameter q.
TsallisQGaussianDistribution[q] represents a Tsallis q-Gaussian distribution with mean 0 and scale parameter 1.
TTest
TTest[data] tests whether the mean of data is zero.
TTest[{data1,data2}] tests whether the means of data1 and data2 are equal.
TTest[dspec,μ0] tests the mean against μ0.
TTest[dspec,μ0,"property"] returns the value of "property".
Tube
Tube[{{x1,y1,z1},{x2,y2,z2},…}] represents a 3D tube around the line joining a sequence of points.
Tube[{pt1,pt2,…},r] represents a tube of radius r.
Tube[{{pt11,pt12,…},{pt21,…},…},…] represents a collection of tubes.
Tube[curve,…] represents a tube around the specified 3D curve.
Tuesday
Tuesday is a day of the week.
TukeyLambdaDistribution
TukeyLambdaDistribution[λ] represents Tukey's lambda distribution with shape parameter λ.
TukeyLambdaDistribution[λ,μ,σ] represents Tukey's lambda distribution with location parameter μ and scale parameter σ.
TukeyLambdaDistribution[{λ1,λ2},μ,{σ1,σ2}] represents the generalized Tukey's lambda distribution with location parameter μ, scale parameters σ1 and σ2, and shape parameters λ1 and λ2.
TukeyWindow
TukeyWindow[x] represents a Tukey window function of x.
TukeyWindow[x,α] uses the parameter α.
TunnelData
TunnelData[entity,property] gives the value of the specified property for the tunnel entity.
TunnelData[{entity1,entity2,…},property] gives a list of property values for the specified tunnel entities.
TunnelData[entity,property,annotation] gives the specified annotation associated with the given property.
TuranGraph
TuranGraph[n,k] gives the k-partite Turán graph with n vertices Tn,k.
TuringMachine
TuringMachine[rule,init,t] generates a list representing the evolution of the Turing machine with the specified rule from initial condition init for t steps.
TuringMachine[rule,init] gives the result of evolving init for one step.
TuringMachine[rule] is an operator form of TuringMachine that corresponds to one step of evolution.
TuttePolynomial
TuttePolynomial[g,{x,y}] gives the Tutte polynomial of the graph g.
TuttePolynomial[{v->w,…},…] uses rules v->w to specify the graph g.
TwoWayRule
x<->y or xy represents a two-way rule expressing exchange or correspondence of x and y.
Typed
Typed[expr,type] represents an expression that should be assumed to be of a specified type for compilation and other purposes.
TypeSpecifier
TypeSpecifier[cons] represents a type.
TypeSpecifier[cons][type1,…] or cons::[type1,…] represents a compound type.
UnateQ
UnateQ[bexpr,{x1,x2,…}] tests whether the Boolean expression bexpr is positive unate in the variables x1, x2, … .
UnateQ[bexpr,{¬x1,¬x2,…}] tests whether the Boolean expression bexpr is negative unate in the variables x1, x2, … .
Uncompress
Uncompress["string"] recovers an expression from a compressed string representation generated by Compress.
Uncompress["string",h] wraps the head h around the expression produced before evaluating it.
UnconstrainedParameters
UnconstrainedParameters is an option to functions like GeometricScene that specifies what parameters should be treated as unconstrained, so that they can take on any possible value.
Undefined
Undefined is a symbol that represents a quantity with no defined value.
UnderBar
UnderBar[expr] displays with a bar under expr.
Underflow
Underflow[] represents a number too small to represent explicitly on your computer system.
Underlined
Underlined represents an underlined font.
Underoverscript
Underoverscript[x,y,z] is an object that formats as x+y%z.
Underscript
Underscript[x,y] is an object that formats as x+y.
UnderseaFeatureData
UnderseaFeatureData[entity,property] gives the value of the specified property for the undersea feature entity.
UnderseaFeatureData[{entity1,entity2,…},property] gives a list of property values for the specified undersea feature entities.
UnderseaFeatureData[entity,property,annotation] gives the specified annotation associated with the given property.
UndirectedGraph
UndirectedGraph[g] gives an undirected graph from the directed graph g.
UndirectedGraph[{v->w,…}] uses rules v->w to specify the graph g.
UndirectedGraphQ
UndirectedGraphQ[g] yields True if the graph g is an undirected graph and False otherwise.
Unequal
lhs!=rhs or lhs≠rhs returns False if lhs and rhs are identical.
UnequalTo
UnequalTo[y] is an operator form that yields x≠y when applied to an expression x.
Unevaluated
Unevaluated[expr] represents the unevaluated form of expr when it appears as the argument to a function.
UniformDistribution
UniformDistribution[{min,max}] represents a continuous uniform statistical distribution giving values between min and max.
UniformDistribution[] represents a uniform distribution giving values between 0 and 1.
UniformDistribution[{{xmin,xmax},{ymin,ymax},…}] represents a multivariate uniform distribution over the region {{xmin,xmax},{ymin,ymax},…}.
UniformDistribution[n] represents a multivariate uniform distribution over the standard n dimensional unit hypercube.
UniformGraphDistribution
UniformGraphDistribution[n,m] represents a uniform graph distribution on n-vertex, m-edge graphs.
UniformPolyhedron
UniformPolyhedron["name"] gives the uniform polyhedron with the given name.
UniformPolyhedron[{n,m}] gives the uniform polyhedron with n sides of each face and m faces meeting at each vertex point.
UniformPolyhedron[{r,θ,ϕ},…] rescales the uniform polyhedron by a factor r and rotates by an angle θ with respect to the z axis and angle ϕ with respect to the y axis.
UniformPolyhedron[{x,y,z},{r,θ,ϕ},…] centers the uniform polyhedron at {x,y,z}.
UniformSumDistribution
UniformSumDistribution[n] represents the distribution of a sum of n random variables uniformly distributed from 0 to 1.
UniformSumDistribution[n,{min,max}] represents the distribution of a sum of n random variables uniformly distributed from min to max.
Uninstall
Uninstall[link] terminates an external program started by Install, and removes Wolfram Language definitions set up by it.
Union
Union[list1,list2,…] gives a sorted list of all the distinct elements that appear in any of the listi.
Union[list] gives a sorted version of a list, in which all duplicated elements have been dropped.
UnionedEntityClass
UnionedEntityClass[class1,…] represents an entity class containing all the distinct entities in all the classi.
UnionPlus
UnionPlus[x,y,…] displays as x⊎y⊎….
Unique
Unique[] generates a new symbol, whose name is of the form $nnn.
Unique[x] generates a new symbol, with a name of the form x$nnn.
Unique[{x,y,…}] generates a list of new symbols.
Unique["xxx"] generates a new symbol, with a name of the form xxxnnn.
UnitaryMatrixQ
UnitaryMatrixQ[m] gives True if m is a unitary matrix, and False otherwise.
UnitConvert
UnitConvert[quantity,targetunit] attempts to convert the specified quantity to the specified targetunit.
UnitConvert[quantity] converts the specified quantity to SI base units.
UnitDimensions
UnitDimensions[unit] returns a list of base dimensions associated with the specified unit.
UnitDimensions[quantity] returns a list of base dimensions associated with the unit of the specified quantity.
Unitize
Unitize[x] gives 0 when x is zero, and 1 when x has any other numerical value.
UnitRootTest
UnitRootTest[data] tests whether data came from an autoregressive time series process with unit root.
UnitRootTest[data,model,"property"] returns the value of "property" for a given model.
UnitSimplify
UnitSimplify[quantity] attempts to simplify the units of the specified quantity.
UnitStep
UnitStep[x] represents the unit step function, equal to 0 for x<0 and 1 for x≥0.
UnitStep[x1,x2,…] represents the multidimensional unit step function which is 1 only if none of the xi are negative.
UnitTriangle
UnitTriangle[x] represents the unit triangle function on the interval x≤1 .
UnitTriangle[x1,x2,…] represents the multidimensional unit triangle function on the interval xi≤1.
UnitVector
UnitVector[k] gives the two-dimensional unit vector in the kth direction.
UnitVector[n,k] gives the n-dimensional unit vector in the kth direction.
UnitVectorLayer
UnitVectorLayer[n] represents a net layer that transforms integers between 1 and n into n-dimensional unit vectors.
UnitVectorLayer[] leaves the n to be inferred from context.
UnityDimensions
UnityDimensions is an option for UnitSimplify that specifies which UnitDimensions should be factored out.
UniverseModelData
UniverseModelData[spec] returns properties of the universe based on the default model at specification defined by the time after the Big Bang, the distance to the comoving object, or the redshift of such an object.
UniverseModelData[spec,model] returns properties of universe model at spec.
UniverseModelData[spec,property] returns the specified property at the time or distance spec.
UniverseModelData[spec,property,model] returns the specified property at the time or distance spec for the universe model.
UniversityData
UniversityData[entity,property] gives the value of the specified property for the university entity.
UniversityData[{entity1,entity2,…},property] gives a list of property values for the specified university entities.
UniversityData[entity,property,annotation] gives the specified annotation associated with the given property.
UnixTime
UnixTime[] gives the total number of seconds since the beginning of January 1, 1970, in the GMT time zone.
UnixTime[{y,m,d,h,m,s}] gives the Unix time specification corresponding to a date list.
UnixTime[date] gives the Unix time specification corresponding to a DateObject.
UnixTime["string"] gives the Unix time specification corresponding to a date string.
UnixTime[{"string",{e1,e2,…}}] takes the date string to contain the elements "ei".
Unprotect
Unprotect[s1,s2,…] removes the attribute Protected for the symbols si.
Unprotect[patt1,patt2,…] unprotects all symbols whose names textually match any of the arbitrary string patterns patti.
Unprotect[{spec1,spec2,…}] unprotects any symbols that are equal to or whose names match any of the speci.
UnregisterExternalEvaluator
UnregisterExternalEvaluator[sys,evaluator] unregisters the external evaluator referenced by evaluator for system sys so that it is not used by ExternalEvaluate and related functions.
UnsameQ
lhs=!=rhs yields True if the expression lhs is not identical to rhs, and yields False otherwise.
Unset
lhs=. removes any rules defined for lhs.
UnsetShared
UnsetShared[s1,s2,…] stops the sharing of the variables or functions si among parallel kernels.
UnsetShared[patt] stops the sharing of all variables and functions whose names match the string pattern patt.
UpArrow
UpArrow[x,y,…] displays as x↑y↑….
UpArrowBar
UpArrowBar[x,y,…] displays as x⤒y⤒….
UpArrowDownArrow
UpArrowDownArrow[x,y,…] displays as x⇅y⇅….
Update
Update[symbol] tells the Wolfram Language that hidden changes have been made that could affect values associated with a symbol.
Update[] specifies that the value of any symbol could be affected.
UpdatePacletSites
UpdatePacletSites is an option to PacletInstall and PacletInstallSubmit that specifies whether to first update the local cache of information about available paclets.
UpdateSearchIndex
UpdateSearchIndex[obj] updates the given search index object.
UpdateSearchIndex["name"] updates the search index with the specified name in the SearchIndices[] list.
UpDownArrow
UpDownArrow[x,y,…] displays as x↕y↕….
UpEquilibrium
UpEquilibrium[x,y,…] displays as x⥮y⥮….
UpperCaseQ
UpperCaseQ[string] yields True if all the characters in the string are uppercase letters, and yields False otherwise.
UpperLeftArrow
UpperLeftArrow[x,y,…] displays as x↖y↖….
UpperRightArrow
UpperRightArrow[x,y,…] displays as x↗y↗….
Upsample
Upsample[array,n] returns an upsampled version of the array by inserting n-1 zeros between array elements.
Upsample[array,n,offset] shifts array so that its first element moves to the position offset in the resulting array.
Upsample[array,n,offset,val] inserts n-1 elements of value val between array elements.
Upsample[image,…] upsamples an image.
UpSet
lhs^=rhs assigns rhs to be the value of lhs, and associates the assignment with symbols that occur at level one in lhs.
UpSetDelayed
lhs^:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with symbols that occur at level one in lhs.
UpTee
UpTee[x,y] displays as x⊥y.
UpTeeArrow
UpTeeArrow[x,y,…] displays as x↥y↥….
UpTo
UpTo[n] is a symbolic specification that represents up to n objects or positions. If n objects or positions are available, all are used. If fewer are available, only those available are used.
UpValues
UpValues[f] gives a list of transformation rules corresponding to all upvalues (values for g[…,f[…],…]) defined for the symbol f.
UpValues["symbol"] gives a list of transformation rules corresponding to all upvalues defined for the symbol named "symbol" if it exists.
URL
URL["url"] is a symbolic representation of a URL.
URLBuild
URLBuild["path",{param1->val1,param2->val2,…}] builds a URL with the specified path and query parameters and values parami and vali.
URLBuild[{path1,path2,…}] builds a URL from the path components pathi.
URLBuild[path,params] builds a URL from a specification of a path and query parameters.
URLBuild[assoc] builds a URL from an association of components.
URLBuild[assoc,params] builds a URL from an association of components, plus query parameters and values.
URLDecode
URLDecode["string"] decodes a URL-style percent-encoded string.
URLDispatcher
URLDispatcher[{patt1content1,patt2content2,…}] represents a dispatcher for deployed URLs that specifies that URLs with relative paths matching the string patterns patti should give content represented by contenti.
URLDownload
URLDownload[url] downloads the content of the specified URL to a local temporary file.
URLDownload[{url1,url2,…}] downloads the contents of the specified URLs to files in a local temporary directory.
URLDownload[url,file] downloads to a specified file.
URLDownload[{url1,url2,…},dir] downloads to a specified directory.
URLDownload[HTTPRequest[…],…] downloads the result of the specified HTTP request.
URLDownload[{req1,req2,…},…] downloads the results of the list of HTTP requests.
URLDownload[req,loc,"elem"] returns only the element elem from the response.
URLDownload[req,loc,"elem"] returns only the element elem from the response.
URLDownload[req,loc,{elem1,elem2,…}] returns an association of the values of the elements elemi.
URLDownloadSubmit
URLDownloadSubmit[url, file] submits the specified URL to be downloaded asynchronously to the file given.
URLDownloadSubmit[url,file,{param1->val1,param2->val2,…}] submits the specified URL, adding elements with names parami and values vali.
URLDownloadSubmit[obj,…] submits the cloud object obj.
URLDownloadSubmit[HTTPRequest[…],…] submits the specified HTTP request.
URLEncode
URLEncode["string"] converts "string" into a URL-style, percent-encoded ASCII string.
URLExecute
URLExecute[url] executes the specified URL, importing whatever result is generated.
URLExecute[url,{param1->val1,param2->val2,…}] executes the specified URL, adding elements with names parami and values vali.
URLExecute[url,params,format] imports the result using the specified format.
URLExecute[CloudObject[…],…] executes a cloud object with current authentication settings.
URLExecute[HTTPRequest[…],…] executes the specified HTTP request.
URLExpand
URLExpand["url"] expands a shortened "url".
URLFetch
URLFetch[url] returns the contents of a URL as a string.
URLFetch[url,elements] returns the specified elements from a URL.
URLFetchAsynchronous
URLFetchAsynchronous[url,func] performs a connection in the background, calling func when an event is raised.
URLParse
URLParse["url"] takes a well-formed URL and gives an association whose values correspond to the components of the URL.
URLParse["url","component"] returns only the specified component.
URLParse["url",{component1,component2,…}] returns only the specified component list.
URLQueryDecode
URLQueryDecode["string"] decodes a URL-style query string into a list of key-value rules.
URLQueryEncode
URLQueryEncode[<|key1->val1,key2->val2,…|>] creates a URL-style query string from an association of keys and values.
URLQueryEncode[{param1->val1,param2->val1,…}] creates a query string from a list of rules.
URLRead
URLRead[url] sends a request to a URL and reads back the response, returning it as a response object.
URLRead[assoc] sends a request to a URL built from an association of components and metadata elements.
URLRead[HTTPRequest[…]] sends a request specified by a symbolic HTTPRequest object.
URLRead[req,"elem"] returns only the element elem from the response.
URLRead[req,{elem1,elem2,…}] returns an association of the values of the elements elemi.
URLRead[{req1,req2,…},…] sends the requests reqi in parallel, giving a list of the results obtained.
URLResponseTime
URLResponseTime[url] gives the total number of seconds to request one byte from the specified URL.
URLResponseTime[url,prop] gives the specified timing.
URLSave
URLSave["url"] saves the content of the URL to a file in $TemporaryDirectory.
URLSave["url","file"] saves the content of the URL to a file.
URLSave["url","file",elements] returns the specified elements from a URL.
URLSaveAsynchronous
URLSaveAsynchronous["url","file",func] performs a download to "file" in the background, calling func when an event is raised.
URLShorten
URLShorten["url"] creates a shortened URL that redirects to "url".
URLShorten[CloudObject[…]] creates a shortened URL that redirects to the URL for the specified cloud object.
URLSubmit
URLSubmit[url] submits the specified URL to be executed asynchronously.
URLSubmit[url,{param1->val1,param2->val2,…}] submits the specified URL, adding elements with names parami and values vali.
URLSubmit[obj,…] submits the cloud object obj.
URLSubmit[HTTPRequest[…],…] submits the specified HTTP request.
UseEmbeddedLibrary
UseEmbeddedLibrary is an option of FunctionCompile that embeds a shared library in a CompiledCodeFunction.
Using
Using is an option to Roots that specifies any subsidiary equations that are to be used.
UtilityFunction
UtilityFunction is an option for Predict, Classify, and related functions that specifies the utility value to assign to each possible pairing of actual and predicted values.
V2Get
V2Get[name] reads in a file written by the V2.x versions.
ValenceFilling
ValenceFilling is an option for Molecule that specifies whether to fill open valences with hydrogen atoms.
ValidationLength
ValidationLength is an option to FindSequenceFunction and related functions that specifies the number of elements in the input sequence that should be used to validate a potential representation found.
ValidationSet
ValidationSet is an option for Predict, Classify, NetTrain, and related functions that specifies the validation set to be used during the training phase.
ValueDimensions
ValueDimensions is an option to TemporalData, TimeSeries, and EventSeries that specifies the dimension of the value space.
ValueForm
ValueForm is an internal symbol.
ValuePreprocessingFunction
ValuePreprocessingFunction is an option for functions such as PersistentSymbol and InitializationValue that specifies a function to apply to a new value that is being assigned.
ValueQ
ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise.
Values
Values[<|key1->val1,key2->val2,…|>] gives a list of the values vali in an association.
Values[{key1->val1,key2->val2,…}] gives a list of the vali in a list of rules.
Values[expr,h] gives a list of values in expr, wrapping each of them with head h before evaluation.
Variables
Variables[poly] gives a list of all independent variables in a polynomial.
Variance
Variance[data] gives the variance estimate of the elements in data.
Variance[dist] gives the variance of the distribution dist.
VarianceEquivalenceTest
VarianceEquivalenceTest[{data1,data2,…}] tests whether the variances of the datai are equal.
VarianceEquivalenceTest[{data1,…},"property"] returns the value of "property".
VarianceEstimatorFunction
VarianceEstimatorFunction is an option for LinearModelFit and NonlinearModelFit which specifies the variance estimator to use.
VarianceGammaDistribution
VarianceGammaDistribution[λ,α,β,μ] represents a variance‐gamma distribution with location parameter μ, skewness parameter β, and shape parameters λ and α.
VariogramFunction
VariogramFunction is an option to SpatialEstimate that specifies the local variation model to use.
VariogramModel
VariogramModel["model",{params}] represents the function for the variogram model specified by "model".
VectorAngle
VectorAngle[u,v] gives the angle between the vectors u and v.
VectorAround
VectorAround[{x1,x2,…},{δ1,δ2,…}] represents a vector of uncorrelated approximate numbers or quantities with values xi and uncertainties δi.
VectorAround[{x1,x2,…},{{Δ11,Δ12, …},{Δ12,Δ22,…},…}] represents a vector of approximate numbers or quantities with values xi and covariance matrix Δ.
VectorAround[{x1,x2},{{δ1,δ2},ρ}] represents a pair of approximate numbers or quantities with uncertainties δ1, δ2 and correlation factor ρ.
VectorAround[{x1,x2,…},{{δ1,δ2,…},{{1,R12,…},{R12,1,…},…}}] represents a vector of approximate numbers or quantities with uncertainties δi and correlation matrix R.
VectorAspectRatio
VectorAspectRatio is an option setting for VectorPlot and related functions that determines the relative width and length of the arrow markers in the plot.
VectorColorFunction
VectorColorFunction is an option for VectorPlot and related functions that specifies a function to apply to determine colors of field vectors drawn.
VectorColorFunctionScaling
VectorColorFunctionScaling is an option for graphics functions which specifies whether arguments supplied to a vector color function should be scaled to lie between 0 and 1.
VectorDensityPlot
VectorDensityPlot[{{vx,vy},r},{x,xmin,xmax},{y,ymin,ymax}] generates a vector plot of the vector field {vx,vy} as a function of x and y, superimposed on a density plot of the scalar field r.
VectorDensityPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] takes the scalar field to be the norm of the vector field.
VectorDensityPlot[{{vx,vy},{wx,wy},…,r},{x,xmin,xmax},{y,ymin,ymax}] plots several vector fields.
VectorDensityPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
VectorDisplacementPlot
VectorDisplacementPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a displacement plot for the vector field {vx,vy} as a function of x and y.
VectorDisplacementPlot[{vx,vy},{x,y}∈reg] plots the displacement over the geometric region reg.
VectorDisplacementPlot[{{vx,vy},s},…] uses the scalar field s to style the displacement.
VectorDisplacementPlot3D
VectorDisplacementPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a displacement plot of the vector field {vx,vy,vz} as a function of x, y and z.
VectorDisplacementPlot3D[{vx,vy,vz},{x,y,z}∈reg] plots the displacement over the geometric region reg.
VectorDisplacementPlot3D[{{vx,vy,vz},s},…] uses the scalar field s to style the displacement.
VectorGreater
xy or VectorGreater[{x,y}] yields True for vectors of length n if xi>yi for all components 1≤i≤n.
xκy or VectorGreater[{x,y},κ] yields True for x and y if x-y∈interior(κ), where κ is a proper convex cone.
VectorGreaterEqual
xy or VectorGreaterEqual[{x,y}] yields True for vectors of length n if xi≥yi for all components 1≤i≤n.
xκy or VectorGreaterEqual[{x,y},κ] yields True for x and y if x-y∈κ, where κ is a proper convex cone.
VectorLess
xy or VectorLess[{x,y}] yields True for vectors of length n if xi<yi for all components 1≤i≤n.
xκy or VectorLess[{x,y},κ] yields True for x and y if y-x∈interior(κ), where κ is a proper convex cone.
VectorLessEqual
xy or VectorLessEqual[{x,y}] yields True for vectors of length n if xi≤yi for all components 1≤i≤n.
xκy or VectorLessEqual[{x,y},κ] yields True for x and y if y-x∈κ, where κ is a proper convex cone.
VectorMarkers
VectorMarkers is an option for graphics functions like VectorPlot, ListVectorPlot and related functions that specifies what markers to draw at the field points plotted.
VectorPlot
VectorPlot[{vx,vy},{x,xmin,xmax},{y,ymin,ymax}] generates a vector plot of the vector field {vx,vy} as a function of x and y.
VectorPlot[{{vx,vy},{wx,wy},…},{x,xmin,xmax},{y,ymin,ymax}] plots several vector fields.
VectorPlot[…,{x,y}∈reg] takes the variables {x,y} to be in the geometric region reg.
VectorPlot3D
VectorPlot3D[{vx,vy,vz},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] generates a 3D vector plot of the vector field {vx,vy,vz} as a function of x, y, and z.
VectorPlot3D[{field1,field2,…},{x,xmin,xmax},{y,ymin,ymax},{z,zmin,zmax}] plots several vector fields.
VectorPlot3D[…,{x,y,z}∈reg] takes the variables {x,y,z} to be in the geometric region reg.
VectorPoints
VectorPoints is an option to VectorPlot, ListVectorPlot, and related functions that determines where to draw arrows.
VectorQ
VectorQ[expr] gives True if expr is a list or a one‐dimensional SparseArray object, none of whose elements are themselves lists, and gives False otherwise.
VectorQ[expr,test] gives True only if test yields True when applied to each of the elements in expr.
VectorRange
VectorRange is an option for VectorPlot and related functions that specifies the range of vector magnitudes to include in a plot.
Vectors
Vectors[d] represents the domain of vectors of dimension d.
Vectors[d,dom] represents the domain of vectors of dimension d, with components in the domain dom.
VectorScale
VectorScale is an option to VectorPlot, ListVectorPlot, and related functions that determines the length and arrowhead size of field vectors that are drawn.
VectorScaling
VectorScaling is an option for VectorPlot and related functions that determines how the magnitudes of vectors are scaled for visualization.
VectorSizes
VectorSizes is an option for VectorPlot and related functions that specifies the range of sizes used for arrows.
VectorStyle
VectorStyle is an option to VectorPlot, ListVectorPlot, and related functions that determines the style to use for drawing field vectors.
Vee
Vee[x,y,…] displays as x⋁y⋁….
Verbatim
Verbatim[expr] represents expr in pattern matching, requiring that expr be matched exactly as it appears, with no substitutions for blanks or other transformations.
VerificationTest
VerificationTest[input] runs a verification test to determine whether input evaluates to True.
VerificationTest[input,expected] tests whether input evaluates to expected, without issuing messages.
VerificationTest[input,expected,messages] tests whether input evaluates to expected, generating the list of message names messages.
VerifyConvergence
VerifyConvergence is an option to Sum, NSum, and similar functions that specifies whether convergence checking should be done.
VerifyDerivedKey
VerifyDerivedKey[key,password] verifies that password matches the password used to generate the derived key.
VerifyDigitalSignature
VerifyDigitalSignature[{expr,sig},key] verifies the digital signature sig for expr using the specified public key.
VerifyDigitalSignature[{{expr1,sig1},{expr2,sig2},…},key] verifies the digital signatures sigi for each of the expri, all using the specified public key.
VerifyDigitalSignature[key] is an operator form of VerifyDigitalSignature, suitable for application to {expr,sig} or a list of such pairs.
VerifyFileSignature
VerifyFileSignature[{"file",sig},key] verifies the digital signature sig for file using the specified public key.
VerifyFileSignature[{"file",range,sig},key] verifies the digital signature sig for the specified range of bytes in the file.
VerifyFileSignature[{{file1,range1,sig1},{file2,range2,sig2},…},key] verifies the digital signatures sigi for each of rangei of bytes in the filei, all using the specified public key.
VerifyFileSignature[key] represents an operator form of VerifyFileSignature that can be applied to files.
VerifyInterpretation
VerifyInterpretation is an option for TextCases, TextPosition and TextContents that verifies that results can be interpreted using Interpreter and related functions and drops those that cannot.
VerifySecurityCertificates
VerifySecurityCertificates is an option for URLRead and related functions that specifies whether to verify security certificates when making an HTTPS connection.
VerifySolutions
VerifySolutions is an option to Solve and related functions that controls whether to verify solutions.
VerifyTestAssumptions
VerifyTestAssumptions is an option to LocationTest and similar functions that controls which assumptions to verify through diagnostic tests.
VertexAdd
VertexAdd[g,v] makes a graph by adding the vertex v to the graph g.
VertexAdd[g,{v1,v2,…}] adds a collection of vertices to g.
VertexAdd[{v->w,…},…] uses rules v->w to specify the graph g.
VertexCapacity
VertexCapacity is an option and annotation for Graph and related functions that specifies a vertex capacity.
VertexChromaticNumber
VertexChromaticNumber[g] gives the chromatic number for the vertices of the graph g.
VertexColors
VertexColors is an option for graphics primitives which specifies the colors to assign to vertices.
VertexComponent
VertexComponent[g,{v1,v2,…}] gives the vertices in the graph g that have a path to at least one of v1, v2, … .
VertexComponent[g,{v1,v2,…},k] gives the vertices with a path to at least one of v1, v2, … of at most length k.
VertexComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.
VertexComponent[{v->w,…},…] uses rules v->w to specify the graph g.
VertexConnectivity
VertexConnectivity[g] gives the vertex connectivity of the graph g.
VertexConnectivity[g,s,t] gives the s-t vertex connectivity of the graph g.
VertexConnectivity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexContract
VertexContract[g,{v1,v2,…}] contracts a collection of vertices v1, v2, … into a single vertex of the graph g.
VertexContract[g,{{v1,v2,…},…}] contracts several collections of vertices.
VertexContract[{v->w,…},…] uses rules v->w to specify the graph g.
VertexCoordinateRules
VertexCoordinateRules is an option for GraphPlot and related functions which specifies rules for determining the coordinates at which vertices should be placed.
VertexCoordinates
VertexCoordinates is an option to Graph and related functions that specifies the coordinates to use to place the center of vertices.
VertexCorrelationSimilarity
VertexCorrelationSimilarity[g,u,v] gives the correlation similarity between vertices u and v of the graph g.
VertexCorrelationSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexCosineSimilarity
VertexCosineSimilarity[g,u,v] gives the cosine similarity between vertices u and v of the graph g.
VertexCosineSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexCount
VertexCount[g] gives a count of the number of vertices in the graph g.
VertexCount[g,patt] gives a count of the number of vertices that match the pattern patt.
VertexCount[{v->w,…},…] uses rules v->w to specify the graph g.
VertexCoverQ
VertexCoverQ[g,vlist] yields True if the vertex list vlist is a vertex cover of the graph g, and False otherwise.
VertexDataCoordinates
VertexDataCoordinates is an option to Raster3D that determines how to map data to the displayed range.
VertexDegree
VertexDegree[g] gives the list of vertex degrees for all vertices in the graph g.
VertexDegree[g,v] gives the vertex degree for the vertex v.
VertexDegree[{v->w,…},…] uses rules v->w to specify the graph g.
VertexDelete
VertexDelete[g,v] makes a graph by deleting the vertex ν and all edges connected to v from the graph g.
VertexDelete[g,{v1,v2,…}] deletes a collection of vertices from g.
VertexDelete[g,patt] deletes all vertices that match the pattern patt.
VertexDelete[{v->w,…},…] uses rules v->w to specify the graph g.
VertexDiceSimilarity
VertexDiceSimilarity[g,u,v] gives the Dice similarity between vertices u and v of the graph g.
VertexDiceSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexEccentricity
VertexEccentricity[g,s] gives the length of the longest shortest path from the source s to every other vertex in the graph g.
VertexEccentricity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexInComponent
VertexInComponent[g,{v1,v2,…},k] gives the vertices with a directed path to at least one of v1, v2, … of at most length k.
VertexInComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.
VertexInComponent[{v->w,…},…] uses rules v->w to specify the graph g.
VertexInComponentGraph
VertexInComponentGraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices that have a directed path to at least one of v1,v2,….
VertexInComponentGraph[g,{v1,v2,…},k] gives the subgraph of g generated by vertices with a directed path of at most length k to at least one of v1,v2,….
VertexInComponentGraph[g,{v1,v2,…},{k}] gives the subgraph of g generated by vertices of length exactly k.
VertexInComponentGraph[{v->w,…},…] uses rules v->w to specify the graph g.
VertexInDegree
VertexInDegree[g] gives the list of vertex in-degrees for all vertices in the graph g.
VertexInDegree[g,v] gives the vertex in-degree for the vertex v.
VertexInDegree[{v->w,…},…] uses rules v->w to specify the graph g.
VertexIndex
VertexIndex[g,v] gives the integer index for the vertex v in the graph g.
VertexIndex[{v->w,…},…] uses rules v->w to specify the graph g.
VertexJaccardSimilarity
VertexJaccardSimilarity[g,u,v] gives the Jaccard similarity between vertices u and v of the graph g.
VertexJaccardSimilarity[{v->w,…},…] uses rules v->w to specify the graph g.
VertexLabeling
VertexLabeling is an option for GraphPlot and related functions which specifies whether labeling should be included by default for vertices in graphs.
VertexLabels
VertexLabels is an option and annotation for Graph and related functions that specifies what labels and label positions should be used for vertices.
VertexLabelStyle
VertexLabelStyle is an option and property for Graph and related functions that specifies the style to use for vertex labels.
VertexList
VertexList[g] gives the list of vertices for the graph g.
VertexList[g,patt] gives a list of vertices that match the pattern patt.
VertexList[{v->w,…},…] uses rules v->w to specify the graph g.
VertexNormals
VertexNormals is an option for graphics primitives which specifies the normal directions to assign to 3D vertices.
VertexOutComponent
VertexOutComponent[g,{v1,v2,…}] gives the vertices in the graph g that have a directed path from at least one of v1, v2, ….
VertexOutComponent[g,{v1,v2,…},k] gives the vertices with a directed path from at least one of v1, v2, … of at most length k.
VertexOutComponent[g,{v1,v2,…},{k}] gives the vertices at length exactly k.
VertexOutComponent[{v->w,…},…] uses rules v->w to specify the graph g.
VertexOutComponentGraph
VertexOutComponentGraph[g,{v1,v2,…}] gives the subgraph of the graph g generated by the vertices that have a directed path from at least one of v1,v2,….
VertexOutComponentGraph[g,{v1,v2,…},k] gives the subgraph of g generated by vertices with a directed path of at most length k from at least one of v1,v2,….
VertexOutComponentGraph[g,{v1,v2,…},{k}] gives the subgraph of g generated by vertices of length exactly k.
VertexOutComponentGraph[{v->w,…},…] uses rules v->w to specify the graph g.
VertexOutDegree
VertexOutDegree[g] gives the list of vertex out-degrees for all vertices in the graph g.
VertexOutDegree[g,v] gives the vertex out-degree for the vertex v.
VertexOutDegree[{v->w,…},…] uses rules v->w to specify the graph g.
VertexQ
VertexQ[g,v] yields True if v is a vertex in the graph g and False otherwise.
VertexRenderingFunction
VertexRenderingFunction is an option for GraphPlot and related functions that gives a function to generate the graphics primitives to use in rendering each vertex.
VertexReplace
VertexReplace[g,{v1->w1,v2->w2,…}] replaces each vertex vi in the graph g by wi.
VertexReplace[{v->w,…},…] uses rules v->w to specify the graph g.
VertexShape
VertexShape is an option and property for Graph and related functions that specifies the graphics used for vertices.
VertexShapeFunction
VertexShapeFunction is an option and annotation for Graph and related functions that specifies a function to use to generate primitives for rendering each vertex.
VertexSize
VertexSize is an option and property for Graph and related functions that specifies the size used for vertices.
VertexStyle
VertexStyle is an option and annotation for Graph and related functions that specifies what style to use for vertices.
VertexTextureCoordinates
VertexTextureCoordinates is an option for graphics primitives that specifies the texture coordinates to assign to vertices.
VertexTransitiveGraphQ
VertexTransitiveGraphQ[g] yields True if the graph g is a vertex–transitive graph and False otherwise.
VertexWeight
VertexWeight is an option and annotation for Graph and related functions that specifies a vertex weight.
VertexWeightedGraphQ
VertexWeightedGraphQ[g] yields True if the graph g is a vertex-weighted graph, and False otherwise.
VerticalBar
VerticalBar[x,y,…] displays as xy….
VerticalTilde
VerticalTilde[x,y,…] displays as x≀y≀….
Video
Video[file] represents video stored in the given file.
Video[url] represents video stored in the given URL.
VideoCombine
VideoCombine[{obj1,obj2,…}] creates a multi-track video by combining all audio, video and subtitle tracks in all obji.
VideoDelete
VideoDelete[video,t] deletes the first t seconds of video.
VideoDelete[video,-t] deletes the last t seconds of video.
VideoDelete[video,{t1,t2}] deletes from time t1 to time t2, returning the remaining video as a single Video object.
VideoDelete[video,{{t11,t12},…}] deletes multiple time intervals.
VideoEncoding
VideoEncoding is an option for Export and other functions that specifies the video encoding to use when creating a video file.
VideoExtractFrames
VideoExtractFrames[video,t] extracts a frame at time t from video.
VideoExtractFrames[video,tspec] extracts video frames at time specification tspec.
VideoFrameList
VideoFrameList[video,n] gives a list of n images extracted from video.
VideoFrameList[video,spec] gives a list of frames extracted based on spec.
VideoFrameMap
VideoFrameMap[f,video] applies f to each frame of the Video object video, returning a new Video object.
VideoFrameMap[f,video,n] applies f to overlapping partitions of n video frames.
VideoFrameMap[f,video,n,d] applies f to partitions with offset d.
VideoFrameMap[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.
VideoGenerator
VideoGenerator[imagespec] generates a video with frames generated from imagespec.
VideoGenerator[<|"Image"->imagespec,"Audio"->audiospec|>] returns a video with audio data generated from audioexpr.
VideoGenerator[…,dur] generates a video of duration dur.
VideoInsert
VideoInsert[video,t->new] inserts the video new at time t.
VideoInsert[video,{t1,t2,…}->new] inserts the same video at multiple positions.
VideoInsert[video,{t1->new1,…}] inserts multiple videos at different positions.
VideoIntervals
VideoIntervals[video,crit] returns time intervals of video for which the criterion crit is satisfied.
VideoIntervals[video,crit,n] evaluates criterion crit on partitions of n video frames.
VideoIntervals[video,crit,n,d] evaluates crit on partitions with offset d.
VideoIntervals[{video1,video2,…},crit,…] applies crit to a list of inputs extracted from each videoi.
VideoJoin
VideoJoin[video1,video2,…] concatenates all videoi and returns a video object.
VideoMap
VideoMap[f,video] applies f to partial video and audio data corresponding to one frame of video, returning a new video.
VideoMap[f,video,n] applies f to data corresponding to overlapping partitions of n video frames.
VideoMap[f,video,n,d] applies f to partitions with offset d.
VideoMap[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.
VideoMapList
VideoMapList[f,video] applies f to a chunk of data corresponding to one frame from the Video object video, returning a list of results.
VideoMapList[f,video,n] applies f to overlapping partitions corresponding to n video frames.
VideoMapList[f,video,n,d] applies f to partitions with offset d.
VideoMapList[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.
VideoMapTimeSeries
VideoMapTimeSeries[f,video] applies f to each frame of the Video object video, returning a time series.
VideoMapTimeSeries[f,video,n] applies f to overlapping partitions of n video frames.
VideoMapTimeSeries[f,video,n,d] applies f to partitions with offset d.
VideoMapTimeSeries[f,{video1,video2,…},…] applies f to a list of inputs extracted from each videoi.
VideoPause
VideoPause[] pauses the playback of all VideoStream objects.
VideoPause[vstream] pauses the playback of the VideoStream object vstream.
VideoPlay
VideoPlay[video] returns a new VideoStream object from video and starts the playback.
VideoPlay[vstream] starts playing a VideoStream object vstream.
VideoQ
VideoQ[video] yields True if video has the form of a valid Video object, and False otherwise.
VideoRecord
VideoRecord[source] creates a VideoStream object and records from source.
VideoRecord[vstream] starts recording a VideoStream object vstream that is connected to an imaging device, a screen or a notebook.
VideoReplace
VideoReplace[video,{t1,t2}->new] replaces the video between t1 and t2 with the new video new.
VideoReplace[video,{{t11,t12},…}->new] replaces multiple intervals with the same video new.
VideoReplace[video,{{t11,t12}->new1,…}] replaces multiple intervals.
VideoReplace[video,…,durfitting] uses the specified durfitting method to replace an interval of a different duration.
VideoSplit
VideoSplit[video,t] splits video at time t.
VideoSplit[video,{t1,t2,…}] splits video at times ti.
VideoStop
VideoStop[] stops the playback of all VideoStream objects.
VideoStop[vstream] stops the playback of the VideoStream object vstream.
VideoStream
VideoStream[source] creates a new VideoStream object from source.
VideoStream[id] is an object that represents a unique video stream.
VideoStreams
VideoStreams[] returns all existing video streams.
VideoTimeStretch
VideoTimeStretch[video,spec] applies time stretching to video using the specified spec.
VideoTrackSelection
VideoTrackSelection is an option that specifies the video tracks of interest.
VideoTranscode
VideoTranscode[video,"format"] converts video to the specified format.
VideoTranscode[video,service] converts video to the specification recommended by the specified service.
VideoTranscode[{v1,v2,…},…] converts all vi videos to have conforming properties with respect to the given specification.
VideoTrim
VideoTrim[video,t] returns the first t seconds of video.
VideoTrim[video,-t] returns the last t seconds of video.
VideoTrim[video,{t1,t2}] returns video starting at time t1 and ending at time t2 of video.
VideoTrim[video,{{t11,t12},…}] returns a list of video objects for all given intervals {ti1,ti2}.
ViewAngle
ViewAngle is an option for Graphics3D and related functions that gives the opening angle for a simulated camera used to view the three-dimensional scene.
ViewCenter
ViewCenter is an option for Graphics3D and related functions which gives the scaled coordinates of the point which should appear at the center of the final image.
ViewMatrix
ViewMatrix is an option for Graphics3D and related functions that can be used to specify a pair of explicit homogeneous transformation and projection matrices for 3D coordinates.
ViewPoint
ViewPoint is an option for Graphics3D and related functions which gives the point in space from which three‐dimensional objects are to be viewed.
ViewProjection
ViewProjection is an option for three-dimensional graphics that specifies the projection to use for the graphic.
ViewRange
ViewRange is an option for Graphics3D and related functions which specifies the range of distances from the view point to be included in displaying a three-dimensional scene.
ViewVector
ViewVector is an option for Graphics3D and related functions which specifies the position and direction of a simulated camera used to view three-dimensional objects.
ViewVertical
ViewVertical is an option for Graphics3D and related functions which specifies what direction in scaled coordinates should be vertical in the final image.
VoiceStyleData
VoiceStyleData[] gives the list of available voices for speech synthesis.
VoiceStyleData[voice] returns all properties for the specified voice.
VoiceStyleData[voice,prop] returns the specified property prop for voice.
VoigtDistribution
VoigtDistribution[δ,σ] represents Voigt distribution with parameters δ and σ.
VolcanoData
VolcanoData[entity,property] gives the value of the specified property for the volcano entity.
VolcanoData[{entity1,entity2,…},property] gives a list of property values for the specified volcano entities.
VolcanoData[entity,property,annotation] gives the specified annotation associated with the given property.
Volume
Volume[reg] gives the volume of the three-dimensional region reg.
Volume[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},{u,umin,umax}] gives the volume of the parametrized region whose Cartesian coordinates xi are functions of s, t, u.
Volume[{x1,…,xn},{s,smin,smax},{t,tmin,tmax},{u,umin,umax},chart] interprets the xi as coordinates in the specified coordinate chart.
VonMisesDistribution
VonMisesDistribution[μ,κ] represents a von Mises distribution with mean μ and concentration κ.
VoronoiMesh
VoronoiMesh[{p1,…,pn}] gives a MeshRegion representing the Voronoi mesh from the points p1, p2, ….
VoronoiMesh[{p1,…,pn},{{xmin,xmax},…}] clips the mesh to the bounds [xmin,xmax]×⋯.
WaitAll
WaitAll[expr] waits for all concurrent evaluations represented by EvaluationObject expressions in expr to finish, then returns the resulting expression obtained.
WaitAsynchronousTask
WaitAsynchronousTask[task] waits for task to complete.
WaitNext
WaitNext[{eid1,eid2,…}] waits until the first evaluation represented by any of the eidi finishes, then returns its result, the corresponding eidi, and the list of remaining eidk.
WaitNext[{eid1,eid2,…},h] wraps the head h around the result before returning it.
WakebyDistribution
WakebyDistribution[α,β,γ,δ,μ] represents Wakeby distribution with shape parameters β and δ, scale parameters α and γ, and location parameter μ.
WalleniusHypergeometricDistribution
WalleniusHypergeometricDistribution[n,nsucc,ntot,w] represents a Wallenius noncentral hypergeometric distribution.
WaringYuleDistribution
WaringYuleDistribution[α] represents the Yule distribution with shape parameter α.
WaringYuleDistribution[α,β] represents the Waring distribution with shape parameters α and β.
WarpingCorrespondence
WarpingCorrespondence[s1,s2] gives the time warping (DTW) similarity path between sequences s1 and s2.
WarpingCorrespondence[s1,s2,win] uses a window specified by win for local search.
WarpingDistance
WarpingDistance[s1,s2] gives the dynamic time warping (DTW) distance between sequences s1 and s2.
WarpingDistance[s1,s2,win] uses a window specified by win for local search.
WatershedComponents
WatershedComponents[image] computes the watershed transform of image, returning the result as an array in which positive integers label the catchment basins.
WatershedComponents[image,marker] uses a binary image marker to indicate regions where basins may be created.
WatershedComponents[video,…] computes watershed segmentation on frames of video.
WatsonUSquareTest
WatsonUSquareTest[data] tests whether data is normally distributed using the Watson U2 test.
WatsonUSquareTest[data,dist] tests whether data is distributed according to dist using the Watson U2 test.
WatsonUSquareTest[data,dist,"property"] returns the value of "property".
WattsStrogatzGraphDistribution
WattsStrogatzGraphDistribution[n,p] represents the Watts–Strogatz graph distribution for n-vertex graphs with rewiring probability p.
WattsStrogatzGraphDistribution[n,p,k] represents the Watts–Strogatz graph distribution for n-vertex graphs with rewiring probability p starting from a 2k-regular graph.
WaveletBestBasis
WaveletBestBasis[dwd] computes a best basis representation in the DiscreteWaveletData object dwd.
WaveletBestBasis[dwd,cspec] computes a best basis representation using the cost specification cspec.
WaveletFilterCoefficients
WaveletFilterCoefficients[wave,filt] gives the filter coefficients for the symbolic wavelet wave of type filt.
WaveletImagePlot
WaveletImagePlot[dwd] plots the basis tree of wavelet image coefficients in the DiscreteWaveletData dwd.
WaveletImagePlot[dwd,r] plots coefficients up to refinement level r.
WaveletImagePlot[dwd,r,ifunc] applies the image function ifunc to coefficients and wavelet indexes before plotting.
WaveletListPlot
WaveletListPlot[dwd] plots wavelet transform coefficients in the DiscreteWaveletData dwd.
WaveletListPlot[dwd,wind] plots wavelet transform coefficients corresponding to the wavelet index specification wind.
WaveletListPlot[dwd,wind,func] applies func to coefficients before plotting.
WaveletListPlot[{dwd1,dwd2,…},…] plots wavelet transform coefficients from several DiscreteWaveletData objects dwd1, dwd2, ….
WaveletMapIndexed
WaveletMapIndexed[f,wd] applies the function f to the arrays of coefficients and indices of a ContinuousWaveletData or DiscreteWaveletData object.
WaveletMapIndexed[f,dwd,wind] applies f to the DiscreteWaveletData coefficients specified by wind.
WaveletMapIndexed[f,cwd,octvoc] applies f to the ContinuousWaveletData coefficients specified by octvoc.
WaveletMatrixPlot
WaveletMatrixPlot[dwd] plots the basis tree of wavelet matrix coefficients in the DiscreteWaveletData dwd.
WaveletMatrixPlot[dwd,r] plots coefficients up to refinement level r.
WaveletMatrixPlot[dwd,r,func] applies func to coefficients before plotting.
WaveletPhi
WaveletPhi[wave,x] gives the scaling function ϕ(x) for the symbolic wavelet wave evaluated at x.
WaveletPhi[wave] gives the scaling function as a pure function.
WaveletPsi
WaveletPsi[wave,x] gives the wavelet function ψ(x) for the symbolic wavelet wave evaluated at x.
WaveletPsi[wave] gives the wavelet function as a pure function.
WaveletScale
WaveletScale is an option for ContinuousWaveletTransform and related constructs used to specify the smallest resolvable scale.
WaveletScalogram
WaveletScalogram[wd] plots wavelet vector coefficients in a DiscreteWaveletData or ContinuousWaveletData object wd.
WaveletScalogram[wd,wind] plots wavelet coefficients corresponding to the wavelet index specification wind.
WaveletScalogram[wd,wind,func] applies func to coefficients before plotting.
WaveletThreshold
WaveletThreshold[dwd] thresholds the detail wavelet coefficients in the DiscreteWaveletData object dwd.
WaveletThreshold[dwd,tspec] thresholds the coefficients using the thresholding specification tspec.
WaveletThreshold[dwd,tspec,wind] thresholds the wavelet coefficients given by the wavelet indices wind.
WavePDEComponent
WavePDEComponent[vars,pars] yields a wave equation PDE term ∂u2/∂t2-c2∇2{x1,…,xn}u with model variables vars and model parameters pars.
WeaklyConnectedComponents
WeaklyConnectedComponents[g] gives the weakly connected components of the graph g.
WeaklyConnectedComponents[g,{v1,v2,…}] gives the weakly connected components that include at least one of the vertices v1, v2, ….
WeaklyConnectedComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.
WeaklyConnectedComponents[{v->w,…},…] uses rules v->w to specify the graph g.
WeaklyConnectedGraphComponents
WeaklyConnectedGraphComponents[g] gives the weakly connected components of the graph g.
WeaklyConnectedGraphComponents[g,{v1,v2,…}] gives the weakly connected components that include at least one of the vertices v1, v2, … .
WeaklyConnectedGraphComponents[g,patt] gives the connected components that include a vertex that matches the pattern patt.
WeaklyConnectedGraphComponents[{v->w,…},…] uses rules v->w to specify the graph g.
WeaklyConnectedGraphQ
WeaklyConnectedGraphQ[g] yields True if the graph g is weakly connected, and False otherwise.
WeakStationarity
WeakStationarity[proc] gives conditions for the process proc to be weakly stationary.
WeatherData
WeatherData[loc,"property"] gives the most recent measurement for the specified weather property at the location corresponding to loc.
WeatherData[loc,"property",date] gives all measurements during the specified date.
WeatherData[loc,"property",{start,end}] gives a list of dates and measurements for the time interval start to end.
WeatherData[loc,"property",{start,end,step}] gives measurements aggregated over the time period represented by step.
WeatherForecastData
WeatherForecastData[loc] gives the most recent forecast for all weather forecast properties for the specified location.
WeatherForecastData[prop] gives the forecast for the specified property for the current location.
WeatherForecastData[date] gives the forecast at the time or times specified by date for all properties at the current location.
WeatherForecastData[loc,prop] gives the forecast for the property at the specified location.
WeatherForecastData[loc,prop,datespec] gives the forecast at the time or times specified by datespec for the property at the location.
WebAudioSearch
WebAudioSearch["string"] gives a dataset of the top web audio search results for the specified literal string.
WebAudioSearch[query] performs a web audio search using the specified query.
WebAudioSearch[query,format] gives the elements of the web audio search specified by format.
WebAudioSearch[query,format,crit] returns only audio results that satisfy crit.
WebColumn
WebColumn[{expr1,expr2,…}] represents an HTML column containing the expri.
WebColumn[expr,options] displays with expr formatted using the specified option settings.
WebElementObject
WebElementObject[…] represents an element of an open webpage operated on by WebExecute.
WeberE
WeberE[ν,z] gives the Weber function Eν(z).
WeberE[ν,μ,z] gives the associated Weber function Eνμ(z).
WebExecute
WebExecute[cmd] executes the command cmd in a web browser.
WebExecute[{cmd1,cmd2,…}] executes a list of commands in sequence.
WebExecute[session,cmds] executes cmds in the specified web session.
WebImage
WebImage[url] gives an image of the webpage specified by url.
WebImage[list] gives images specified by URLs in list.
WebImageSearch
WebImageSearch["string"] gives a list of thumbnails of the top web image search results for the specified literal string.
WebImageSearch[form] gives the top results obtained by doing the web image search specified by form.
WebImageSearch[form, n] picks out the first n top results obtained by doing the web image search specified by form.
WebImageSearch[form,elems] gives the elements of the web image search specified by elems.
WebImageSearch[form, elems, n] picks out the first n elements of the web image search specified by elems.
WebItem
WebItem[expr] represents an HTML element containing expr.
WebItem[expr,options] represents an HTML element formatted using the specified option settings.
WebItem[XMLElement[expr,…],options] represents an XMLElement formatted using options.
WebRow
WebRow[{expr1, expr2, …}] represents an HTML row containing the expri.
WebRow[expr,options] displays with expr formatted using the specified option settings.
WebSearch
WebSearch["string"] gives a dataset of the top web search results for the specified literal string.
WebSearch[form] gives the top results obtained by doing the web search specified by form.
WebSearch[form,elems] gives the elements of the web search specified by elems.
WebSessionObject
WebSessionObject[…] represents a web browser session started by StartWebSession for use with WebExecute.
WebSessions
WebSessions[] gives the list of all active web sessions.
WebWindowObject
WebWindowObject[…] represents an open window or tab in a web browser.
Wedge
Wedge[x,y,…] displays as x⋀y⋀….
Wednesday
Wednesday is a day of the week.
WeibullDistribution
WeibullDistribution[α,β] represents a Weibull distribution with shape parameter α and scale parameter β.
WeibullDistribution[α,β,μ] represents a Weibull distribution with shape parameter α, scale parameter β, and location parameter μ.
WeierstrassE1
WeierstrassE1[{g2,g3}] gives the value e1 of the Weierstrass elliptic function ℘ at the half-period ω1(g2,g3).
WeierstrassE2
WeierstrassE2[{g2,g3}] gives the value e2 of the Weierstrass elliptic function ℘ at the half-period ω2(g2,g3).
WeierstrassE3
WeierstrassE3[{g2,g3}] gives the value e3 of the Weierstrass elliptic function ℘ at the half-period ω3(g2,g3).
WeierstrassEta1
WeierstrassEta1[{g2,g3}] gives the value η1 of the Weierstrass zeta function ζ at the half-period ω1(g2,g3).
WeierstrassEta2
WeierstrassEta2[{g2,g3}] gives the value η2 of the Weierstrass zeta function ζ at the half-period ω2(g2,g3).
WeierstrassEta3
WeierstrassEta3[{g2,g3}] gives the value η3 of the Weierstrass zeta function ζ at the half-period ω3(g2,g3).
WeierstrassHalfPeriods
WeierstrassHalfPeriods[{g2,g3}] gives the half‐periods {ω1,ω3} for Weierstrass elliptic functions corresponding to the invariants {g2,g3}.
WeierstrassHalfPeriodW1
WeierstrassHalfPeriodW1[{g2,g3}] gives the half-period ω1 for Weierstrass elliptic functions corresponding to the invariants {g2,g3}.
WeierstrassHalfPeriodW2
WeierstrassHalfPeriodW2[{g2,g3}] gives the half-period ω2 for the Weierstrass elliptic functions corresponding to the invariants {g2,g3}.
WeierstrassHalfPeriodW3
WeierstrassHalfPeriodW3[{g2,g3}] gives the half-period ω3 for the Weierstrass elliptic functions corresponding to the invariants {g2,g3}.
WeierstrassInvariantG2
WeierstrassInvariantG2[{ω,ω′}] gives the invariant g2 for the Weierstrass elliptic functions corresponding to the half‐periods {ω,ω′}.
WeierstrassInvariantG3
WeierstrassInvariantG3[{ω,ω′}] gives the invariant g3 for the Weierstrass elliptic functions corresponding to the half‐periods {ω,ω′}.
WeierstrassInvariants
WeierstrassInvariants[{ω1,ω3}] gives the invariants {g2,g3} for Weierstrass elliptic functions corresponding to the half‐periods {ω1,ω3}.
WeierstrassP
WeierstrassP[u,{g2,g3}] gives the Weierstrass elliptic function ℘(u;g2,g3).
WeierstrassPPrime
WeierstrassPPrime[u,{g2,g3}] gives the derivative of the Weierstrass elliptic function ℘(u;g2,g3).
WeierstrassSigma
WeierstrassSigma[u,{g2,g3}] gives the Weierstrass sigma function σ(u;g2,g3).
WeierstrassZeta
WeierstrassZeta[u,{g2,g3}] gives the Weierstrass zeta function ζ(u;g2,g3).
WeightedAdjacencyGraph
WeightedAdjacencyGraph[wmat] gives the graph with weighted adjacency matrix wmat.
WeightedAdjacencyGraph[{v1,v2,…},wmat] gives the graph with vertices vi and weighted adjacency matrix wmat.
WeightedAdjacencyMatrix
WeightedAdjacencyMatrix[g] gives the adjacency matrix of edge weights of the graph g.
WeightedAdjacencyMatrix[{v->w,…}] uses rules v->w to specify the graph g.
WeightedData
WeightedData[{x1,x2,…},{w1,w2,…}] represents observations xi with weights wi.
WeightedData[{x1,x2,…},fn] represents observations xi with weighting function fn.
WeightedGraphQ
WeightedGraphQ[g] yields True if the graph g is a weighted graph and False otherwise.
Weights
Weights is an option for various fitting and other functions which specifies weights to associate with data elements.
WelchWindow
WelchWindow[x] represents a Welch window function of x.
WelchWindow[x,α] uses the parameter α.
WheelGraph
WheelGraph[n] gives the wheel graph with n vertices Wn.
WhenEvent
WhenEvent[event,action] specifies an action that occurs when the event triggers it for equations in NDSolve and related functions.
Which
Which[test1,value1,test2,value2,…] evaluates each of the testi in turn, returning the value of the valuei corresponding to the first one that yields True.
While
While[test,body] evaluates test, then body, repetitively, until test first fails to give True.
White
White represents the color white in graphics or style specifications.
WhiteNoiseProcess
WhiteNoiseProcess[] represents a Gaussian white noise process with mean 0 and standard deviation 1.
WhiteNoiseProcess[σ] represents a Gaussian white noise process with mean 0 and standard deviation σ.
WhiteNoiseProcess[dist] represents a white noise process based on the distribution dist.
WhitePoint
WhitePoint is an option for ColorConvert, ChromaticityPlot and other functions to specify the white point.
Whitespace
Whitespace represents a sequence of whitespace characters in StringExpression.
WhitespaceCharacter
WhitespaceCharacter represents a single whitespace character in StringExpression.
WhittakerM
WhittakerM[k,m,z] gives the Whittaker function Mk,m(z).
WhittakerW
WhittakerW[k,m,z] gives the Whittaker function Wk,m(z).
WienerFilter
WienerFilter[data,r] removes noise from data by applying a range-r Wiener filter.
WienerFilter[data,r,ns] assumes an additive noise power value ns.
WienerFilter[data,{r1,r2,…},…] uses radius ri at level i in data.
WienerProcess
WienerProcess[μ,σ] represents a Wiener process with a drift μ and volatility σ.
WienerProcess[] represents a standard Wiener process with drift 0 and volatility 1.
WignerD
WignerD[{j,m1,m2},ψ,θ,ϕ] gives the Wigner D-function Dm1,m2j(ψ,θ,ϕ).
WignerD[{j,m1,m2},θ,ϕ] gives the Wigner D-function Dm1,m2j(0,θ,ϕ).
WignerD[{j,m1,m2},θ] gives the Wigner D-function Dm1,m2j(0,θ,0).
WignerSemicircleDistribution
WignerSemicircleDistribution[r] represents a Wigner semicircle distribution with radius r centered at the origin.
WignerSemicircleDistribution[a,r] represents a Wigner semicircle distribution with radius r centered at a.
WikidataData
WikidataData[item,property] gives the values of the specified property for the given item.
WikidataData[{item1,item2,…},property] gives values for each of the itemi.
WikidataData[item,{property1,property2,…}] gives values for each of the propertyi.
WikidataData[items,properties] gives values for each of the properties for each of the items.
WikidataSearch
WikidataSearch["keywords"] returns a list of Wikidata items whose labels include the given keywords.
WikidataSearch["type"->"keywords"] returns a list of Wikidata identifiers of the specified type.
WikipediaData
WikipediaData[article] gives the plain text of the specified Wikipedia article.
WikipediaData[{article1,article2,...}] gives the texts for each of the articles.
WikipediaData[article,property,options] gives the value of the specified property, modified by optional parameters, for the given Wikipedia article.
WikipediaData["Category"->category,property,options] gives the value of the specified property, modified by optional parameters, for the given Wikipedia category.
WikipediaData["PageID"->pageid,property,options] gives the value of the specified property, modified by optional parameters, for the article corresponding to the given numerical Wikipedia page ID.
WikipediaSearch
WikipediaSearch[keywords] returns a list of Wikipedia articles whose titles include the given keywords.
WikipediaSearch["Title"->keywords,options] returns a list of Wikipedia articles whose titles include the given keywords.
WikipediaSearch["Category"->keywords,options] returns a list of Wikipedia categories whose titles include the given keywords.
WikipediaSearch["Content"->keywords] returns a list of Wikipedia articles whose content includes the given keywords.
WikipediaSearch[loc] returns a list of Wikipedia articles whose associated coordinates are near the given location.
WilksW
WilksW[m1,m2] gives Wilks's for the matrices m1 and m2.
WilksWTest
WilksWTest[m1,m2] tests whether the matrices m1 and m2 are independent.
WilksWTest[…,"property"] returns the value of "property".
WindDirectionData
WindDirectionData[] gives the most recent measurement for wind direction near the current location.
WindDirectionData[datespec] gives the wind direction value for the specified time near the current location.
WindDirectionData[locationspec] gives the most recent measurement for wind direction near the specified location.
WindDirectionData[locationspec,datespec] gives the value or values for the specified date and location.
WindDirectionData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.
WindingCount
WindingCount[contour,p] gives the count of the number of times a closed curve winds around a point p.
WindingPolygon
WindingPolygon[{p1,p2,…,pn}] gives a polygon representing all points for which the closed contour p1,p2,…,pn,p1 winds around at least once.
WindingPolygon[{{p11,p12,…},{p21,p22,…},…}] gives a polygon from the closed contours p11,p12,… and p21,p22,….
WindingPolygon[…,"wrule"] uses the specified winding rule "wrule" to define the polygon.
WindowTitle
WindowTitle is an option that specifies the title to give for a window.
WindSpeedData
WindSpeedData[] gives the most recent measurement for wind speed near the current location.
WindSpeedData[datespec] gives the wind speed value for the specified time near the current location.
WindSpeedData[locationspec] gives the most recent measurement for wind speed near the specified location.
WindSpeedData[locationspec,datespec] gives the value or values for the specified date and location.
WindSpeedData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.
WindVectorData
WindVectorData[] gives the most recent weather station measurement for wind vector near the current location.
WindVectorData[datespec] gives the wind vector value for the specified time near the current location.
WindVectorData[locationspec] gives the most recent measurement for wind vector near the specified location.
WindVectorData[locationspec,datespec] gives the value or values for the specified date and location.
WindVectorData[{{location1,date1},{location2,date2},…}] gives values for all specified locations on the specified dates.
WinsorizedMean
WinsorizedMean[list,f] gives the mean of the elements in list after replacing the fraction f of the smallest and largest elements by the remaining extreme values.
WinsorizedMean[list,{f1,f2}] gives the mean when the fraction f1 of the smallest elements and the fraction f2 of the largest elements are replaced by the remaining extreme values.
WinsorizedMean[list] gives the 5% winsorized mean WinsorizedMean[list,0.05].
WinsorizedMean[dist,…] gives the winsorized mean of a univariate distribution dist.
WinsorizedVariance
WinsorizedVariance[list,f] gives the variance of the elements in list after replacing the fraction f of the smallest and largest elements by the remaining extreme values.
WinsorizedVariance[list,{f1,f2}] gives the variance when the fraction f1 of the smallest elements and the fraction f2 of the largest elements are replaced by the remaining extreme values.
WinsorizedVariance[list] gives the 5% winsorized variance WinsorizedVariance[list,0.05].
WinsorizedVariance[dist,…] gives the winsorized variance of a univariate distribution dist.
WishartMatrixDistribution
WishartMatrixDistribution[ν,Σ] represents a Wishart matrix distribution with ν degrees of freedom and covariance matrix Σ.
With
With[{x=x0,y=y0,…},expr] specifies that all occurrences of the symbols x, y, … in expr should be replaced by x0, y0, ….
WithCleanup
WithCleanup[expr,cleanup] evaluates expr, running cleanup before returning the result, even if an abort, throw, etc. was generated during the evaluation of expr.
WithCleanup[init,expr,cleanup] evaluates init before evaluating expr, blocking aborts, throws, etc. in both init and cleanup.
WithLock
WithLock[File["path"],expr] locks the file path, evaluates expr, then releases the file.
WithLock[LocalSymbol["name"],expr] locks the local symbol name, evaluates expr, then releases the local symbol.
WithLock[var,expr] locks the shared variable var, evaluates expr, then releases the shared variable.
WolframAlpha
WolframAlpha["query"] sends query to Wolfram|Alpha and imports the output.
WolframAlpha["query",format] imports the output according to the specified format.
WolframLanguageData
WolframLanguageData[entity,property] gives the value of the specified property for the Wolfram Language symbol entity.
WolframLanguageData[{entity1,entity2,…},property] gives a list of property values for the specified Wolfram Language symbol entities.
WolframLanguageData[entity,property,annotation] gives the specified annotation associated with the given property.
Word
Word represents a word in Read, Find, and related functions.
WordBoundary
WordBoundary represents a boundary between words for purposes of matching in StringExpression.
WordCharacter
WordCharacter represents a letter or digit character in StringExpression.
WordCount
WordCount["string"] gives the total number of words in string.
WordCounts
WordCounts["string"] gives an association whose keys are the distinct words identified in string, and whose values give the number of times those words appear in string.
WordCounts["string",n] gives counts of the distinct n-grams consisting of runs of n words in string.
WordCounts[{string1,string2,…},…] gives the counts for each of the stringi.
WordData
WordData["word","property"] gives the specified property for the English word "word".
WordData["word"] gives a list of full word specifications representing possible uses and senses of "word".
WordData[wordspec,"property"] gives a property for a particular word specification.
WordDefinition
WordDefinition["word"] gives the dictionary definitions available for "word".
WordFrequency
WordFrequency[text,word] gives the frequency of word in text.
WordFrequency[text,{word1,word2,…}] gives an association of the frequencies of each of the wordi.
WordFrequencyData
WordFrequencyData[word] gives the frequency of word in typical published English text.
WordFrequencyData[{word1,word2,…}] gives an association of frequencies of the wordi.
WordFrequencyData[word,"TimeSeries"] gives a time series for the frequency of word in typical published English text.
WordFrequencyData[word,"TimeSeries",datespec] gives a time series for dates specified by datespec.
WordFrequencyData[word,"prop"] gives property prop of the word frequency.
WordList
WordList[] gives a list of common words.
WordList[type] gives a list of words of the specified type.
WordOrientation
WordOrientation is an option for WordCloud that specifies the orientations in which words appear.
WordSearch
WordSearch is an option for Find and FindList that specifies whether the text searched for must appear as a word.
WordSelectionFunction
WordSelectionFunction is an option for WordCloud and other functions that specifies which words to use.
WordSeparators
WordSeparators is an option for Read, Find, and related functions that specifies the list of strings to be taken as delimiters for words.
WordSpacings
WordSpacings is an option for WordCloud that specifies the empty space to be added around each word.
WordStem
WordStem["word"] gives a stemmed form of word, removing plurals, inflections, etc.
WordTranslation
WordTranslation["word",lang] gives translations for word into the language lang.
WordTranslation["word",lang1->lang2] gives translations for word from lang1 to lang2.
WorkingPrecision
WorkingPrecision is an option for various numerical operations that specifies how many digits of precision should be maintained in internal computations.
Write
Write[channel,expr1,expr2,…] writes the expressions expri in sequence, followed by a newline, to the specified output channel.
WriteLine
WriteLine[stream, "string"] writes "string", followed by a newline, to the specified output stream.
WriteLine[proc, "string"] writes "string" to an external process proc.
WriteString
WriteString["file","string"] writes "string" to a file.
WriteString[channel,"string"] writes "string" to a stream or process.
WriteString[channel,expr1,expr2,…] converts the expri to strings, and then writes them in sequence to the specified output channel.
Wronskian
Wronskian[{y1,y2,…},x] gives the Wronskian determinant for the functions y1,y2,… depending on x.
Wronskian[eqn,y,x] gives the Wronskian determinant for the basis of the solutions of the linear differential equation eqn with dependent variable y and independent variable x.
Wronskian[eqns,{y1,y2,…},x] gives the Wronskian determinant for the system of linear differential equations eqns.
XMLElement
XMLElement[tag,{attr1->val1,…},{data1,…}] represents an element in symbolic XML.
XMLObject
XMLObject["type"] represents the head of an XML object in symbolic XML.
XMLTemplate
XMLTemplate["string"] yields a TemplateObject that represents an XML template to be applied using functions like TemplateApply.
XMLTemplate[src] uses File[…], URL[…], or CloudObject[…] as the source for the string template.
XMLTemplate[form,args] yields a TemplateObject with arguments, suitable for cloud deployment or other evaluation.
Xnor
Xnor[e1,e2,…] is the logical XNOR (not XOR) function. It gives True if an even number of the ei are True, and the rest are False. It gives False if an odd number of the ei are True, and the rest are False.
Xor
Xor[e1,e2,…] is the logical XOR (exclusive OR) function. It gives True if an odd number of the ei are True, and the rest are False. It gives False if an even number of the ei are True, and the rest are False.
XYZColor
XYZColor[x,y,z] represents a color in the XYZ color space with tristimulus values x, y and z.
XYZColor[x,y,z,a] specifies opacity a.
XYZColor["string"] returns a color from an HTML color name etc.
XYZColor[color] returns the XYZ representation of color.
Yellow
Yellow represents the color yellow in graphics or style specifications.
Yesterday
Yesterday gives a DateObject representing the previous day.
YuleDissimilarity
YuleDissimilarity[u,v] gives the Yule dissimilarity between Boolean vectors u and v.
ZernikeR
ZernikeR[n,m,r] gives the radial Zernike polynomial Rnm(r).
ZeroSymmetric
ZeroSymmetric[{s1,…,sn}] represents the symmetry of a zero tensor in the slots si.
ZeroTest
ZeroTest is an option to various linear algebra functions that gives a function to use in testing whether symbolic expressions should be treated as zero.
ZeroWidthTimes
ZeroWidthTimes is an option for selections that specifies whether blank spaces representing multiplication are explicitly shown.
Zeta
Zeta[s] gives the Riemann zeta function ζ(s).
Zeta[s,a] gives the generalized Riemann zeta function ζ(s,a).
ZetaZero
ZetaZero[k] represents the kth zero of the Riemann zeta function on the critical line.
ZetaZero[k,t] represents the kth zero with imaginary part greater than t.
ZIPCodeData
ZIPCodeData[entity,property] gives the value of the specified property for the ZIP code entity.
ZIPCodeData[{entity1,entity2,…},property] gives a list of property values for the specified ZIP code entities.
ZIPCodeData[entity,property,annotation] gives the specified annotation associated with the given property.
ZipfDistribution
ZipfDistribution[ρ] represents a zeta distribution with parameter ρ.
ZipfDistribution[n,ρ] represents a Zipf distribution with range n.
ZTransform
ZTransform[expr,n,z] gives the Z transform of expr.
ZTransform[expr,{n1,…,nm},{z1,…,zm}] gives the multidimensional Z transform of expr.
AcyclicGraphQ
AcyclicGraphQ[g] yields True if the graph g is an acyclic graph and False otherwise.
AllMatch
AllMatch[{e1,e2,…},form] yields True if ei matches the pattern form for all of the ei.
AllMatch[expr,form,level] tests parts of expr at level level.
AllMatch[form] represents an operator form of AllMatch that can be applied to an expression.
AllSameBy
AllSameBy[{e1,e2,…},f] tests whether all the f[ei] are the same.
AllSameBy[f] represents an operator form of AllSameBy that can be applied to an expression.
AnyMatch
AnyMatch[{e1,e2,…},form] yields True if ei matches the pattern form for any of the ei.
AnyMatch[expr,form,level] tests parts of expr at level level.
AnyMatch[form] represents an operator form of AnyMatch that can be applied to an expression.
AppellF2
AppellF2[a,b1,b2,c1,c2,x,y] is the Appell hypergeometric function of two variables F2(a;b1,b2;c1,c2;x,y).
AppellF3
AppellF3[a1,a2,b1,b2,c,x,y] is the Appell hypergeometric function of two variables F3(a;b1,b2;c1,c2;x,y).
AppellF4
AppellF4[a,b,c1,c2,x,y] is the Appell hypergeometric function of two variables F4(a;b;c1,c2;x,y).
ArcCosDegrees
ArcCosDegrees[z] gives the arc cosine in degrees of the complex number z.
ArcCotDegrees
ArcCotDegrees[z] gives the arc cotangent in degrees of the complex number z.
ArcCscDegrees
ArcCscDegrees[z] gives the arc cosecant in degrees of the complex number z.
ArcSecDegrees
ArcSecDegrees[z] gives the arc secant in degrees of the complex number z.
ArcSinDegrees
ArcSinDegrees[z] gives the arc sine in degrees of the complex number z.
ArcTanDegrees
ArcTanDegrees[z] gives the arc tangent in degrees of the complex number z.
ArrayDot
ArrayDot[a,b,k] computes the product of arrays a and b obtained by summing up products of terms over the last k dimensions of a and the first k dimensions of b.
ArrayDot[a,b,{{s1,t1},{s2,t2},…}] computes the product of arrays a and b obtained by summing up products of terms over the pairs {si,ti} of dimensions.
ArraySymbol
ArraySymbol[a] represents an array with name a.
ArraySymbol[a,{n1,n2,…}] represents an n1×n2×… array.
ArraySymbol[a,{n1,n2,…},dom] represents an array with elements in the domain dom.
ArraySymbol[a,{n1,n2,…},dom, sym] represents an array with the symmetry sym.
BitFlip
BitFlip[n,k] flips the bit corresponding to the coefficient of 2k in the integer n.
BlockDiagonalMatrix
BlockDiagonalMatrix[{d1,d2, …}] represents the block diagonal matrix with diagonal blocks di as a structured array.
BlockDiagonalMatrix[mat] converts the block diagonal matrix mat to a structured array.
BlockLowerTriangularMatrix
BlockLowerTriangularMatrix[lmat] represents the block lower triangular matrix lmat as a structured array.
BlockUpperTriangularMatrix
BlockUpperTriangularMatrix[umat] represents the block upper triangular matrix umat as a structured array.
BuckyballGraph
BuckyballGraph[] gives the buckyball graph.
BuckyballGraph[n] gives the order‐n buckyball graph.
BuckyballGraph[n,"class"] gives the order‐n buckyball graph of class "class".
BuildCompiledComponent
BuildCompiledComponent[comp] builds the compiled component comp.
BuildCompiledComponent[comp,dest] builds the compiled component comp, placing the result in dest.
CaputoD
CaputoD[f,{x,α}] gives the Caputo fractional differintegral C0Dxαf(x) of the function f(x).
Cast
Cast[val,type] converts val to the type type, for use in compiled code.
Cast[val,type,method] uses the specified casting method.
CauchyMatrix
CauchyMatrix[x,y] represents the Cauchy matrix given by the generating vectors x and y as a structured array.
CauchyMatrix[x] is equivalent to CauchyMatrix[x,x].
CauchyMatrix[cmat] converts a Cauchy matrix cmat to a structured array.
CircularArcThrough
CircularArcThrough[{p1,p2,…}] represents a circular arc passing through the points pi.
CircularArcThrough[{p1,p2,…},q] represents a circular arc with center q.
CircularArcThrough[{p1,p2,…},q,r] represents a circular arc with radius r.
CircumscribedBall
CircumscribedBall[{p1,p2,…}] gives a ball with minimal radius that encloses the points p1, p2, ….
Comap
Comap[{f1,f2,…},x] gives {f1[x],f2[x],…}.
Comap[fs,x,levelspec] applies parts of fs specified by levelspec to x.
Comap[fs] represents an operator form of Comap that can be applied to an expression.
ComapApply
ComapApply[{f1,f2,…},expr] gives {Apply[f1,expr],Apply[f2,expr],…}.
ComapApply[fs] represents an operator form of ComapApply that can be applied to an expression.
ConformDates
ConformDates[dates] returns a list of dates where all dates are made to have conforming properties, including calendar, time zone and granularity.
ConformDates[dates,rdate] returns all dates in a form consistent with the reference date rdate.
ContourIntegrate
ContourIntegrate[f,z∈cont] gives the integral of f along the contour defined by cont in the complex plane.
CosDegrees
CosDegrees[θ] gives the cosine of θ degrees.
CotDegrees
CotDegrees[θ] gives the cotangent of θ degrees.
CreateSemanticSearchIndex
CreateSemanticSearchIndex[source] creates a search index from the data in source.
CreateSemanticSearchIndex[{source1,…}] creates a search index with a collection of sources sourcei.
CreateSemanticSearchIndex[{source1->val1,…}] associates the source sourcei to the value vali.
CreateSemanticSearchIndex[data,"name"] gives the search index the specified name.
CreateTypeInstance
CreateTypeInstance[type,arg1,arg2,…] creates an instance of a type in compiled code.
CreateTypeInstance[productType,<|field1->x1,field2->x2,…|>] creates an instance of a product type and initializes its fields.
CscDegrees
CscDegrees[θ] gives the cosecant of θ degrees.
CumulativeFeatureImpactPlot
CumulativeFeatureImpactPlot[model,data] plots the cumulative impact of the value of each feature in data on the result of model.
CumulativeFeatureImpactPlot[model] estimates the feature impacts using synthetic data.
CumulativeFeatureImpactPlot[model->fname,…] plots only the impact of the specified feature fname.
CumulativeFeatureImpactPlot[model->fname->class,…] plots only the impact on the classification class.
DateDistribution
DateDistribution[dist,dunit,dorig] represents a distribution dist of dates with date scale unit dunit and date origin dorig.
DateGranularity
DateGranularity is an option that determines the calendar granularity of generated dates.
Decimal
Decimal is a setting for the ColumnAlignments option of GridBox which states that numbers should align along the decimal place.
DeclareCompiledComponent
DeclareCompiledComponent["name",decls] adds declarations decls to compiled component "name".
DeclareCompiledComponent["name",field->spec] adds the specification spec to the specified field in the compiled component "name".
DeleteAdjacentDuplicates
DeleteAdjacentDuplicates[list] deletes all duplicates in runs of identical elements in list.
DeleteAdjacentDuplicates[list,test] applies test to pairs of consecutive elements to determine whether they should be considered duplicates.
DeleteElements
DeleteElements[list,{e1,e2,…}] removes all instances of elements ei from list.
DeleteElements[list,n->{e1,e2,…}] removes up to n instances of each ei from list.
DeleteElements[list,{n1,n2,…}->{e1,e2,…}] removes up to ni instances of ei from list.
DFixedPoints
DFixedPoints[eqn,x[t],t] gives the fixed points for a differential equation.
DFixedPoints[{eqn1,eqn2,…},{x1[t],x2[t],…},t] gives the fixed points for a system of differential equations.
Diff
Diff[first,second] returns a representation of the diffs between first and second.
Diff[first,second,format] represents the diffs in the indicated format.
Diff3
Diff3[ancestor,first,second] returns a representation of the three-way diff between ancestor and two independently changed versions of ancestor.
Diff3[ancestor,first,second,format] represents the diffs in the indicated format.
DiffApply
DiffApply[diffobj,expr] returns the result of applying the given DiffObject to the expression expr.
DiffApply[diffobj,expr,File["file"]] writes the result of changing expr to file.
DiffGranularity
DiffGranularity is an option to Diff and related functions that indicates with what granularity to compare the given expressions.
DiffIgnore
DiffIgnore is an option to Diff and related functions that specifies what elements to ignore when computing diffs.
DiffIncludeMatches
DiffIncludeMatches is an option for Diff and related functions that specifies whether to include matching data in the resulting DiffObject.
DiffInputFunction
DiffInputFunction is an option for Diff and related functions that specifies how the input expressions should be preprocessed.
DiffObject
DiffObject[v, type, data] represents a sequence of diffs for transforming objects of the indicated type.
DigitSum
DigitSum[n] gives the sum of the decimal digits in the integer n.
DigitSum[n,b] gives the sum of the base b digits in the integer n.
DigitSum[n,b,k] gives the sum of the first k base b digits in the integer n.
DigitSum[n,b,-k] gives the sum of the last k base b digits in the integer n.
DigitSum[n,MixedRadix[blist]] uses the mixed radix with list of bases blist.
DiscreteInputOutputModel
DiscreteInputOutputModel[{g0,g1,…,gn-1},u] represents a discrete-time model with input u and output y=gi(u) at sampling instant i.
DiscreteInputOutputModel[{g0,g1,…,gn-1},u,y] can be used to specify outputs gi(u,y) that also depend on the output variables y.
DiscreteInputOutputModel[…,{{u1,{…,u10}},…},{{y1,{…,y10}},…}] specifies input and output values for each signal for instants k<=0.
DownValuesFunction
DownValuesFunction[sym] represents a function that uses definitions attached to sym when compiling.
DSolveChangeVariables
DSolveChangeVariables[dsolve,u,t,trans] changes the solution function in dsolve to u(t) using the transformation trans.
DSolveChangeVariables[dsolve,{u1,u2,…},t,trans] changes the solution functions in the system to {u1(t),…,un(t)}.
DSolveChangeVariables[dsolve,u,{t1,…,tn},trans] changes the solution function in the partial differential equation to u(t1,…,tn).
DStabilityConditions
DStabilityConditions[eqn,x[t],t] gives the fixed points and stability conditions for a differential equation.
DStabilityConditions[{eqn1,eqn2,…},{x1[t],x2[t],…},t] gives the fixed points and stability conditions for a system of differential equations.
DStabilityConditions[{eqn1,eqn2,…},{x1[t],x2[t],…},t,{pnt1,pnt2,…}] gives the stability conditions for the given fixed points.
ElectricCurrentDensityValue
ElectricCurrentDensityValue[pred,vars,pars] represents a current density boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
ElectricCurrentDensityValue[pred,vars,pars,lkey] represents a current density boundary condition with local parameters specified in pars[lkey].
ElectricCurrentPDEComponent
ElectricCurrentPDEComponent[vars,pars] yields an electric current PDE term with variables vars and parameters pars.
ElectricFluxDensityValue
ElectricFluxDensityValue[pred,vars,pars] represents an electric flux density boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
ElectricFluxDensityValue[pred,vars,pars,lkey] represents an electric flux density boundary condition with local parameters specified in pars[lkey].
ElectricPotentialCondition
ElectricPotentialCondition[pred,vars,pars] represents an electric potential surface boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
ElectricPotentialCondition[pred,vars,pars,lkey] represents an electric potential surface boundary condition with local parameters specified in pars[lkey].
ElectricSymmetryValue
ElectricSymmetryValue[pred,vars,pars] represents an electric symmetry boundary condition for PDEs with predicate pred indicating where it applies, with model variables vars and global parameters pars.
ElectricSymmetryValue[pred,vars,pars,lkey] represents an electric symmetry boundary condition with local parameters specified in pars[lkey].
ElectrostaticPDEComponent
ElectrostaticPDEComponent[vars,pars] yields an electrostatic PDE term with variables vars and parameters pars.
EntityType
EntityType["type"] represents an entity type with the specified name.
EntityType["type"->child1->child2->…] represents a child entity type of "type".
EstimatedPointNormals
EstimatedPointNormals[{p1,p2,…}] estimates normal vectors for the points p1,p2,….
EstimatedPointNormals[mreg] estimates normals vectors for the vertices of the mesh region mreg.
ExternalOperation
ExternalOperation["Eval","code"] represents an external evaluation of "code".
ExternalOperation["Eval","code",assoc] represents an external evaluation of "code" with parameters given by assoc.
ExternalOperation["Call",func,arg1,arg2,…] calls the function func with the given arguments arg1, arg2, ….
ExternalOperation["GetAttribute",obj,"attr"] gets the attribute "attr" of obj.
ExternalOperation["SetAttribute",obj,"attr",val] sets the attribute "attr" of obj to the given value val.
ExternalOperation["Cast",obj,"type"] casts obj to the given "type".
ExternalOperation["op", arg1,arg2,…] represents the external operation named "op" using arguments arg1, arg2, ….
FeatureValueDependencyPlot
FeatureValueDependencyPlot[model,data] plots the dependency of the result of model on the value of a particular feature in data.
FeatureValueDependencyPlot[model] estimates the feature value dependency using synthetic data.
FeatureValueDependencyPlot[model->fname,…] plots only the dependency on the specified feature fname.
FeatureValueDependencyPlot[model->fname->class,…] plots only the dependency on the classification class.
FeatureValueImpactPlot
FeatureValueImpactPlot[model,data] plots the impact of the value of a given feature in data on the result of model.
FeatureValueImpactPlot[model] estimates the feature value impact using synthetic data.
FeatureValueImpactPlot[model->fname,…] plots only the impact of the specified feature fname.
FeatureValueImpactPlot[model->fname->class,…] plots only the impact on the classification class.
FiniteField
FiniteField[p,d] gives a finite field with pd elements.
FiniteField[p,f] gives the finite field p[α]/〈f(α)〉, where f(α) is an irreducible polynomial in p[α].
FiniteField[p,…,rep] uses field element representation rep, either "Polynomial" or "Exponential".
FiniteFieldElementPrimitiveQ
FiniteFieldElementPrimitiveQ[a] tests whether a is a primitive element of its ambient field.
FiniteFieldEmbedding
FiniteFieldEmbedding[ff1,ff2] gives an embedding of the finite field ff1 in the finite field ff2.
FiniteFieldEmbedding[e1->e2] represents the embedding of the ambient field of e1 in the ambient field of e2, which maps e1 to e2.
FiniteFieldIndex
FiniteFieldIndex[u] gives the index of the FiniteFieldElement object u.
FluidFlowPDEComponent
FluidFlowPDEComponent[vars,pars] yields a flow PDE term with variables vars and parameters pars.
ForAllType
ForAllType[x,type] represents a type parameterized by x.
ForAllType[x,cond,type] represents a type satisfying cond.
ForAllType[{x1,x1,…},cond,type] represents a type with multiple parameters.
ForeignCallback
ForeignCallback[…] represents a foreign callback that can be called from external libraries.
ForeignFunction
ForeignFunction[args] represents a function that has been loaded from a library.
ForeignFunctionLoad
ForeignFunctionLoad[lib,fun,{argtype1,argtype2,…}->rettype] loads the function fun with the specified argument and output types from the library lib.
ForeignFunctionLoad[ptr,{argtype1,argtype2,…}->rettype] creates a foreign function from the function pointer ptr.
ForeignPointerLookup
ForeignPointerLookup[lib,fun] returns the pointer to the function fun in the library lib.
FromFiniteField
FromFiniteField[a,ff] converts the element a of the prime subfield of the finite field ff to an integer.
FromFiniteField[expr,ff,t] converts the elements of the finite field ff in the coefficients of the rational expression expr to polynomials in t, where t represents the field generator.
FromFiniteFieldIndex
FromFiniteFieldIndex[ind,ff] gives the element of the finite field ff with index ind.
FromLunationNumber
FromLunationNumber[ln] returns the date corresponding to the lunation number ln.
FromLunationNumber[scheme,ln] returns the date corresponding to the lunation number in the given counting scheme.
FromRawPointer
FromRawPointer[p] returns the value referred to by the pointer p for use in compiled code.
FromRawPointer[array,offset] returns the value of a C array at an offset.
FullMoon
FullMoon[] gives the date of the next full moon.
FullMoon[date] gives the date of the first full moon after the given date.
GraphJoin
GraphJoin[g1,g2] gives the graph join of the graphs g1 and g2.
GraphProduct
GraphProduct[g1,g2] gives the Cartesian product of the graphs g1 and g2.
GraphProduct[g1,g2,"op"] gives the product of type "op" for the graphs g1 and g2
GraphSum
GraphSum[g1,g2] gives the graph sum of the graphs g1 and g2.
GraphTriangleCount
GraphTriangleCount[g] gives the number of triangles in the graph g.
Haloing
Haloing[] is a two‐dimensional directive specifying that graphics objects are to be drawn with a halo.
Haloing[col] uses the specified color col for the halo.
Haloing[col,w] uses the specified width w for the halo.
Haloing[col,w,r] applies a blur effect with radius r to the halo.
HermitianMatrix
HermitianMatrix[hmat] converts the Hermitian matrix hmat to a structured array.
InertEvaluate
InertEvaluate[inertExpr] evaluates an "InertExpression", returning a new "InertExpression" in compiled code.
InertExpression
InertExpression[expr] creates an inert expression in compiled code.
InscribedBall
InscribedBall[{p1,p2,…}] gives the largest ball that lies inside the convex hull of the points p1,p2,….
IntegrateChangeVariables
IntegrateChangeVariables[integral,u,trans] changes the variable in integral to the new variable u using the transformation trans.
IntegrateChangeVariables[integral,{u,v,…},trans] changes the variables to the new variables u, v, ….
IntermediateTest
IntermediateTest[input] creates an intermediate test to determine whether input evaluates to True.
IntermediateTest[input,expected] creates an intermediate test to determine whether input evaluates to expected.
IntermediateTest[input,expected,messages] creates an intermediate test that is expected to generate the list of message names messages.
LayeredGraph
LayeredGraph[g] creates a graph with vertices and edges from the graph g represented as a layered plot.
LayeredGraph[{e1,e2,…}] creates a graph with edges ej represented as a layered plot.
LayeredGraph[{…,w[ei],…}] creates a graph with edges ei with features defined by the symbolic wrapper w.
LayeredGraph[…,v->pos] places the dominant vertex v in the plot at position pos.
LayeredGraph3D
LayeredGraph3D[g] creates a graph with vertices and edges from the graph g represented as a 3D layered plot.
LayeredGraph3D[{e1,e2,…}] creates a graph with edges ej represented as a 3D layered plot.
LayeredGraph3D[{…,w[ei],…}] creates a graph with edges ei with features defined by the symbolic wrapper w.
LayeredGraph3D[…,v->pos] places the dominant vertex v in the plot at position pos.
LibraryFunctionDeclaration
LibraryFunctionDeclaration["extName",lib,type] represents a function declaration that exposes the library function extName with the type type from the library lib, for use in compiled code.
LibraryFunctionDeclaration[name->"extName",lib,type] aliases the function with name in compiled code.
LibraryFunctionDeclaration[nameSpec,type] assumes that the library will be loaded by the time the function is compiled.
LineIntegrate
LineIntegrate[f,{x,y,…}∈curve] computes the scalar line integral of the function f[x,y,…] over the curve.
LineIntegrate[{p,q,…},{x,y,…}∈curve] computes the vector line integral of the vector function {p[x,y,…],q[x,y,…],…}.
LiteralType
LiteralType[x] represents a literal value x for use as a type.
LLMConfiguration
LLMConfiguration[…] represents a configuration for an LLM.
LLMConfiguration[prop->val] creates a configuration based on $LLMEvaluator with the specified property set to val.
LLMConfiguration[<|prop1->val1,prop2->val2,...|>] specifies several properties and values.
LLMConfiguration[LLMConfiguration[…],propspec] creates a configuration based on an existing configuration.
LLMEvaluator
LLMEvaluator is an option for functions such as LLMSynthesize that specifies the LLM configuration.
LLMExampleFunction
LLMExampleFunction[{in1->out1,in2->out2,…}] creates an LLMFunction from few-shot examples.
LLMExampleFunction[{in1,in2,…}->{out1,out2,…}] generates the same result.
LLMExampleFunction[{header,training}] prefaces the prompt with header.
LLMExampleFunction[prompting,form] includes the interpreter form to apply to the response.
LLMFunction
LLMFunction[prompt] represents a template for a large language model (LLM) prompt.
LLMFunction[{prompt1,prompt2,…}] represents a combination of multiple prompts.
LLMFunction[prompt,form] includes the interpreter form to apply to the response.
LLMFunction[…][params] give the LLM service response for prompt applied to parameters params.
LLMPrompt
LLMPrompt["name"] gives the TemplateObject for the specified large language model prompt.
LLMPrompt[resource] retrieves the TemplateObject for the specified resource.
LLMPrompt[…,params] gives the TemplateObject with slots filled in by params.
LLMPrompt[…][p1,p2,…] applies a template with numbered slots to parameter values pi.
LLMPrompt[…][<|key1->p1,key2->p2|>] applies a template with named slots to parameter data.
LLMPromptGenerator
LLMPromptGenerator[f] represents a prompt generator that uses the function f.
LLMPromptGenerator[f,inputspec] provides the specified inputspec to f.
LLMResourceFunction
LLMResourceFunction["name"] retrieves an LLMFunction with the specified name.
LLMResourceFunction[loc] imports an LLMFunction from the specified location.
LLMResourceFunction[…][params] applies the specified LLMFunction to the parameters params.
LLMSynthesize
LLMSynthesize[prompt] generates text according to the input prompt.
LLMSynthesize[{prompt1,…}] combines multiple prompti together.
LLMSynthesize[…,prop] returns the specified property of the generated text.
LoadCompiledComponent
LoadCompiledComponent[comp] loads a compiled component comp.
LoadCompiledComponent[comp,target] loads a compiled component comp from the target location.
LocalEvaluate
LocalEvaluate[expr] gives the result of evaluating expr using your current default local Wolfram Language kernel.
LocalEvaluate[ker, expr] gives the result of evaluating expr using the kernel specified by ker.
LocalEvaluate[{ker1,ker2,…},expr] gives a list of the results of evaluating expr using each of the kernels keri.
LocalEvaluate[ker,expr,h] wraps the head h around the result produced before returning it.
LowerTriangularMatrix
LowerTriangularMatrix[lmat] converts the lower triangular matrix lmat to a structured array.
LunationNumber
LunationNumber[] returns the number of new moons since the first new moon of the year 2000.
LunationNumber[date] returns the number of new moons since the given date.
LunationNumber[scheme,date] returns the number of new moons since the zeroth new moon of the given counting scheme.
MapApply
f@@@expr or MapApply[f,expr] replaces heads at level 1 of expr by f.
MapApply[f] represents an operator form of MapApply that can be applied to an expression.
MatrixSymbol
MatrixSymbol[a] represents a matrix with name a.
MatrixSymbol[a,{m,n}] represents an mn matrix.
MatrixSymbol[a,{m,n},dom] represents a matrix with elements in the domain dom.
MatrixSymbol[a,{m,n},dom, sym] represents a matrix with the symmetry sym.
MaxRoots
MaxRoots is an option for NSolve and related functions that specifies the maximum number of roots that should be returned in the solution for a system of algebraic or transcendental equations.
MinSize
MinSize is an option of certain BoxForm primitives.
ModelPredictiveController
ModelPredictiveController[sspec,cost,cons] computes the model predictive controller for the system specification sspec that minimizes the cost function cost and satisfies the constraints cons.
ModelPredictiveController[…,"prop"] returns the value of the property "prop".
MoonPhaseDate
MoonPhaseDate[] returns the date of the next new moon.
MoonPhaseDate[phase] returns the date of the next instance of the given phase of the Moon.
MoonPhaseDate[date,phase] returns the date for the first instance of the given phase after date.
NCaputoD
NCaputoD[f,{x,α},x0] gives a numerical approximation to the Caputo fractional derivative C0Dxαf(x) of order α of the function f at the point x0.
NContourIntegrate
NContourIntegrate[f,z∈cont] gives the numerical integral of f along the contour defined by cont in the complex plane.
NetExternalObject
NetExternalObject[…] represents a net model in an external framework format.
NewMoon
NewMoon[] gives the date of the next new moon.
NewMoon[date] gives the date of the first new moon after the given date.
NLineIntegrate
NLineIntegrate[f,{x,y,…}∈curve] computes the numerical scalar line integral of the function f[x,y,…] over the curve.
NLineIntegrate[{p,q,…},{x,y,…}∈curve] computes the numerical vector line integral of the vector function {p[x,y,…],q[x,y,…],…}.
NominalScale
NominalScale[{cat1,cat2,…,catn}] represents a set of unordered categories cati.
NominalScale[<|cat1->lab1,…,catn->labn|>] also associates the category cati with the labels labi.
NominalScale[…,<|cati->labi,…|>] uses labi to represent cati in plots.
NominalScale[Automatic] automatically determines the categories.
NoneMatch
NoneMatch[{e1,e2,…},form] yields True if ei does not match the pattern form for any of the ei.
NoneMatch[expr,form,level] tests parts of expr at level level.
NoneMatch[form] represents an operator form of NoneMatch that can be applied to an expression.
NonThreadable
NonThreadable is an attribute that can be assigned to a symbol f to indicate that f and f[arg1,arg2,…] should not combine with other list arguments in arithmetic and many other functions that work with lists.
NSurfaceIntegrate
NSurfaceIntegrate[f,{x,y,…}∈surface] computes the numerical scalar surface integral of the function f[x,y,…] over the surface.
NSurfaceIntegrate[{p,q,…},{x,y,…}∈surface] computes the numerical vector surface integral of the vector field {p[x,y,…],q[x,y,…],…}.
NullRawPointerQ
NullRawPointerQ[ptr] gives True if ptr is a null pointer, and False otherwise.
OpaqueRawPointer
OpaqueRawPointer[addr] represents an untyped pointer to the memory address addr.
OperationDeclaration
OperationDeclaration[type,op,typedfun] declares a typed function to be used for the operation op of type.
OrdinalScale
OrdinalScale[{cat1,cat2,…,catn}] represents a set of ordered categories cati with order cat1<cat2<…<catn.
OrdinalScale[{cat1,…,catn},{val1,…,valn}] associates the category cati with the numeric value vali.
OrdinalScale[<|cat1->val1,…,catn->valn|>] also associates the category cati with the numeric value vali.
OrdinalScale[{cat1,…,catn},vals,{lab1,…,labn}] displays the category cati as the corresponding labi when used as a label in plots etc.
OrdinalScale[…,<|cati->labi,…|>] uses labi to represent cati in plots.
OrthogonalMatrix
OrthogonalMatrix[omat] converts the orthogonal matrix omat to a structured array.
PairwiseDensityHistogram
PairwiseDensityHistogram[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of density histograms by plotting the data columns against each other in pairs.
PairwiseDensityHistogram[data,bpsec] plots density histograms with bins specified by bspec.
PairwiseListPlot
PairwiseListPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of scatter plots by plotting the data columns against each other in pairs.
PairwiseListPlot[{data1,data2,…}] plots multiple sets of data in each plot panel.
PairwiseProbabilityPlot
PairwiseProbabilityPlot[{{y11,…,y1n},…,{ym1,…,ymn}}] plots a CDF of columns in the data against each other.
PairwiseQuantilePlot
PairwiseQuantilePlot[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of quantile plots by plotting the quantiles of the columns against each other.
PairwiseSmoothDensityHistogram
PairwiseSmoothDensityHistogram[{{y11,…,y1n},…,{ym1,…,ymn}}] creates an array of smooth density histograms by plotting the data columns against each other in pairs.
ParentEdgeLabel
ParentEdgeLabel is an option for Tree and related functions that specifies what labels should be used for edges.
ParentEdgeLabelFunction
ParentEdgeLabelFunction is an option for Tree and related functions that specifies functions to use to generate edge labels.
ParentEdgeShapeFunction
ParentEdgeShapeFunction is an option for Tree and related functions that specifies a function to use to generate primitives for rendering edges.
PascalBinomial
PascalBinomial[n,m] gives the binomial coefficient (�) that preserves Pascal's identity.
PermutationMatrix
PermutationMatrix[permv] represents the permutation matrix given by permutation vector permv as a structured array.
PermutationMatrix[pmat] converts a permutation matrix pmat to a structured array.
PhongShading
PhongShading[] is a three‐dimensional graphics directive that specifies that faces of polygons and other filled graphics objects are to be drawn to reflect as a smooth surface using a normal‐vector interpolation shading.
PhongShading[d] uses the attenuation factor d for the diffuse light.
PhongShading[d,s] uses the attenuation factor s for the specular light.
PhongShading[d,s,a] uses the attenuation factor a for the ambient light.
PlotHighlighting
PlotHighlighting is an option to Plot, ListPlot and related visualization functions that specifies how points and curves should be highlighted.
PolarCurve
PolarCurve[r,{θ,θmin,θmax}] gives a polar curve with radius r as a function of angle θ.
PositionLargest
PositionLargest[list] gives the positions of the numerically largest value in list.
PositionLargest[list,n] gives the positions of the first n largest values.
PositionLargest[list,n,orderfun] gives the positions of the n largest values in list as determined by orderfun.
PositionSmallest
PositionSmallest[list] gives the positions of the numerically smallest value in list.
PositionSmallest[list,n] gives the positions of the first n smallest values.
PositionSmallest[list,n,orderfun] gives the positions of the n smallest values in list as determined by orderfun.
PropagateAborts
PropagateAborts is an option to CheckAbort to control whether a handled abort propagates to the enclosing function.
QuestionGenerator
QuestionGenerator[<|name1:>val1,name2:>val2,…|>, genfunc] represents a QuestionObject generated by applying genfunc to <|name1:>val1,name1:>val2,…|>.
QuestionGenerator[CloudObject[…]] represents a cloud-deployed question generator.
QuestionSelector
QuestionSelector[{qo1,qo2,…}] represents a list of questions from which one of the question objects qoi can be randomly selected.
QuestionSelector[CloudObject[…]] represents a cloud-deployed question selector.
RandomDate
RandomDate[] gives a pseudorandom date in the current calendar year.
RandomDate[{datemin,datemax}] gives a pseudorandom date between the dates datemin and datemax.
RandomDate[date] gives a pseudorandom date between the start and end of the calendar period date.
RandomDate[quantity] gives a pseudorandom date between now and the time quantity duration from now.
RandomDate[range,n] gives a list of n pseudorandom dates.
RandomTime
RandomTime[] gives a pseudorandom time of day.
RandomTime[{timemin,timemax}] gives a pseudorandom time between the times timemin and timemax.
RandomTime[time] gives a pseudorandom times between the start and end of the time period time.
RandomTime[quantity] gives a pseudorandom time between now and the time quantity duration from now.
RandomTime[range,n] gives a list of n pseudorandom times.
RawMemoryAllocate
RawMemoryAllocate[type] allocates enough raw memory to store a binary representation of the specified type.
RawMemoryAllocate[type,len] allocates memory for len objects.
RawMemoryExport
RawMemoryExport[expr] exports a raw memory representation of expr.
RawMemoryExport[expr,type] uses the specified element type when returning an array.
RawMemoryFree
RawMemoryFree[ptr] frees the raw memory at a pointer ptr.
RawMemoryImport
RawMemoryImport[ptr,format] imports raw memory from the pointer ptr with the specified format.
RawMemoryImport[format] represents an operator form of RawMemoryImport that can be applied to an expression.
RawMemoryRead
RawMemoryRead[ptr] reads raw memory from the pointer ptr.
RawMemoryRead[ptr,offset] reads from an offset pointer.
RawMemoryWrite
RawMemoryWrite[ptr,val] writes a binary representation of val to the raw memory at the pointer ptr.
RawMemoryWrite[ptr,val,offset] writes to an offset pointer.
RawPointer
RawPointer[addr,type] represents a raw pointer to the specified type at the memory address addr.
RealValuedNumberQ
RealValuedNumberQ[expr] returns True if expr is a number with a real value and False otherwise.
RealValuedNumericQ
RealValuedNumericQ[expr] gives True if expr is a real-valued numeric quantity, and False otherwise.
ReapVideo
ReapVideo[expr] gives a video whose frames are the expressions to which SowVideo has been applied during its evaluation.
ReconstructionMesh
ReconstructionMesh[{pt1,pt2,…}] reconstructs a mesh from a set of points pt1,pt2,….
RegionFarthestDistance
RegionFarthestDistance[reg1,reg2] gives the farthest distance between points in the regions reg1 and reg2.
RegionHausdorffDistance
RegionHausdorffDistance[reg1,reg2] gives the Hausdorff distance between the regions reg1 and reg2.
ReplaceAt
ReplaceAt[expr,rules,n] transforms expr by replacing the nth element using rules.
ReplaceAt[expr,rules,{i,j,…}] replaces the part of expr at position {i,j,…}.
ReplaceAt[expr,rules,{{i1,j1,…},{i2,j2,…},…}] replaces parts at several positions.
ReplaceAt[rules,pos] represents an operator form of ReplaceAt that can be applied to an expression.
ResidueSum
ResidueSum[f,z] finds the sum of residues of the meromorphic function f with the variable z.
ResidueSum[{f,cons},z] finds the sum of residues of f within the solution set of the constraints cons.
RFixedPoints
RFixedPoints[eqn,a[n],n] gives the fixed points for a recurrence equation.
RFixedPoints[{eqn1,eqn2,…},{a1[n],a2[n],…},n] gives the fixed points for a system of recurrence equations.
RootTree
RootTree[tree] returns the root node of tree as a Tree object.
RootTree[tree,n] returns a Tree object containing the nodes of tree down to level n.
RStabilityConditions
RStabilityConditions[eqn,a[n],n] gives the fixed points and stability conditions for a recurrence equation.
RStabilityConditions[{eqn1,eqn2,…},{a1[n],a2[n],…},n] gives the fixed points and stability conditions for a system of recurrence equations.
RStabilityConditions[{eqn1,eqn2,…},{a1[n],a2[n],…},n,{pnt1,pnt2,…}] gives stability conditions only for the given fixed points.
SameAs
SameAs[y] is an operator form that yields x===y when applied to an expression x.
SamplerModel
SamplerModel[] represents the single-input, single-output model of a sampler.
SamplerModel[specs] represents a sampler with specification specs.
SchrodingerPDEComponent
SchrodingerPDEComponent[vars,pars] yields a Schrödinger PDE term with model variables vars and model parameters pars.
SecDegrees
SecDegrees[θ] gives the secant of θ degrees.
SemanticSearch
SemanticSearch[index,query] finds the items similar to query inside index.
SemanticSearch[index,query->f] filters the results using the function f.
SemanticSearch[index,query,prop] returns the specified property prop.
SemanticSearchIndex
SemanticSearchIndex[…] represents a semantic search index object.
SemanticSearchIndex[source] attempts to recreate a SemanticSearchIndex from source.
SemanticSearchIndices
SemanticSearchIndices[] returns a list with all the known instances of SemanticSearchIndex.
SemanticSearchIndices[patt] returns a list of indices with the name matching the pattern patt.
SequenceType
SequenceType[var] represents a type parameterized by var that refers to a sequence of zero or more types.
ShowContents
ShowContents is an option for selections that specifies whether an object represented by a StyleBox should be displayed on the screen or replaced by blank space.
SinDegrees
SinDegrees[θ] gives the sine of θ degrees.
SowVideo
SowVideo[frame] specifies that frame should be collected by the nearest enclosing ReapVideo.
SowVideo[frame,n] repeats frame n times when reaped.
SpellingOptions
SpellingOptions is an option for notebooks that specifies settings for spellchecking.
SphericalAngle
SphericalAngle[{θ0,ϕ0}->{{θ1,ϕ1},{θ2,ϕ2}}] gives the signed angle in radians between the great circles through point {θ0,ϕ0} and points {θ1,ϕ1} and {θ2,ϕ2}.
SphericalAngle[p->{q,r}] gives the unsigned angle for points p, q, r of the form {θ1,θ2,…,θn-1,ϕ} on an n-dimensional hypersphere.
SphericalAngle[p->{{q1,r1},…,{qn,rn}}] gives a list of angles between the great circles from point p through points qi and ri.
SphericalAngle[{p1,…,pn}->{{q1,r1},…,{qn,rn}}] gives a list of angles between the great circles from point pi through points qi and ri.
SphericalDistance
SphericalDistance[{θ1,ϕ1},{θ2,ϕ2}] returns the great-circle distance between points {θ1,ϕ1} and {θ2,ϕ2} on the surface of a unit sphere.
SphericalDistance[{θ1,1,θ1,2,…,ϕ1},{θ2,1,θ2,2,…,ϕ2}] returns the geodesic distance between arbitrary-dimensional points on the surface of a unit hypersphere.
Squiggled
Squiggled[expr] displays expr with text underlined with a squiggly red underline.
Squiggled[expr,color] displays squiggly using the specified color.
StatusArea
StatusArea[expr,string] displays string in the status area of the current notebook when the mouse pointer is in the region where expr appears.
StringApply
StringApply[f,string] applies f to the code points in string.
StringApply[f] represents an operator form of StringApply that can be applied to an expression.
Struckthrough
Struckthrough represents a font with a strike-through line.
SurdForm
SurdForm is an option to RadicalBox and SqrtBox that indicates whether the radical represents a Surd expression.
SurfaceIntegrate
SurfaceIntegrate[f,{x,y,…}∈surface] computes the scalar surface integral of the function f[x,y,…] over the surface.
SurfaceIntegrate[{p,q,…},{x,y,…}∈surface] computes the vector surface integral of the vector field {p[x,y,…],q[x,y,…],…}.
SymbolicDeltaProductArray
SymbolicDeltaProductArray[{n1,n2,…},{{j1,1,j1,2,…},{j2,1,j2,2,…},…}] represents an n1×n2×… array with elements ai1,i2,… equal to 1 if all ijp,1ijp,2…, and 0 otherwise.
SymbolicIdentityArray
SymbolicIdentityArray[{n1,n2,…}] represents an n1×n2×…×n1×n2×… array with elements ai1,i2,…,j1,j2,… equal to 1 if all ikjk, and 0 otherwise.
SymbolicOnesArray
SymbolicOnesArray[] represents an array of ones with unspecified dimensions.
SymbolicOnesArray[{n1,n2,…}] represents an n1×n2×… array of ones.
SymbolicZerosArray
SymbolicZerosArray[] represents an array of zeros with unspecified dimensions.
SymbolicZerosArray[{n1,n2,…}] represents an n1×n2×… array of zeros.
SymmetricDifference
SymmetricDifference[list1,list2,…] gives the symmetric difference of the lists listi.
SymmetricMatrix
SymmetricMatrix[smat] converts the symmetric matrix smat to a structured array.
TanDegrees
TanDegrees[θ] gives the tangent of θ degrees.
TargetStructure
TargetStructure is an option for linear algebra functions that specifies the representation of the result produced by the function.
TerminatedEvaluation
TerminatedEvaluation["reason"] represents an expression whose evaluation overran global kernel session limits and was terminated.
TernaryListPlot
TernaryListPlot[{{u1,v1,w1},…,{un,vn,wn}}] plots a list of points with specified u, v and w coordinates in a barycentric coordinate system.
TernaryListPlot[{data1,data2,…}] plots a ternary plot with several datasets datai.
TernaryPlotCorners
TernaryPlotCorners is an option for TernaryListPlot that determines how the triangle and axes are positioned.
Threaded
Threaded[list] is an object whose elements will automatically be threaded into the lowest level of an array when used in a listable operation such as Plus.
a+Threaded[b] adds elements of an array b to elements of an array a at the lowest possible level.
a+Threaded[b,alev] adds elements at level alev of a.
a+Threaded[b,blev->alev] adds elements at level alev in a to level blev in b.
f[a,Threaded[b,…]] combines elements for a function f with the attribute Listable.
TimeDistribution
TimeDistribution[dist,tunit] represents a linear distribution of time of day according to dist with time scale unit tunit originating at midnight.
TimeDistribution[dist, tunit, torig] represents a linear distribution of time of day with time origin at torig.
ToFiniteField
ToFiniteField[k,ff] converts the integer k to an element of the prime subfield of the finite field ff.
ToFiniteField[expr,ff] converts the coefficients of the rational expression expr to elements of the finite field ff.
ToFiniteField[expr,ff,t] converts the coefficients of the rational expression expr to elements of the finite field ff, with t representing the field generator.
ToRawPointer
ToRawPointer[] creates a new pointer object in compiled code, suitable for use with external libraries.
ToRawPointer[val] creates a new object pointing to the initial value val.
ToRawPointer[p,val] stores val in the pointer p.
ToRawPointer[array,offset,val] stores val in the "CArray" array at the given offset.
TorusGraph
TorusGraph[{n1,n2,…,nk}] gives the k-dimensional torus graph with n1×n2×…×nk vertices.
Tour3DVideo
Tour3DVideo[g] generates a video giving a standard tour around a 3D object g.
Tour3DVideo[g,tour] generates the named video tour.
Tour3DVideo[g,steps] generates a video tour from steps.
TreeElementCoordinates
TreeElementCoordinates is an option for Tree and related functions that specifies the coordinates to use to place the center of subtree elements.
TreeElementLabelFunction
TreeElementLabelFunction is an option for Tree and related functions that specifies functions to use to generate subtree element labels.
TreeElementShape
TreeElementShape is an option for Tree and related functions that specifies what graphics should be used for subtree elements.
TreeElementShapeFunction
TreeElementShapeFunction is an option for Tree and related functions that specifies a function to use to generate primitives for rendering subtree elements.
TreeElementSize
TreeElementSize is an option for Tree and related functions that specifies what size should be used for subtree elements.
TreeElementSizeFunction
TreeElementSizeFunction is an option for Tree and related functions that specifies a function to use to generate sizes for subtree elements.
TreeLeafCount
TreeLeafCount[tree] gives the number of leaves of tree.
TruncateSum
TruncateSum[sexpr,n] truncates each Sum in sexpr to have at most n terms.
TruncateSum[sexpr,{m,n,…}] truncates each multiple Sum in sexpr using the iterative specification {m,n,…}.
TypeEvaluate
TypeEvaluate[expr] represents a type created by evaluating expr.
TypeHint
TypeHint[expr,type] represents an expression of a specified type when compiled and gives expr when evaluated.
TypeOf
TypeOf[expr] gives the type of expr without evaluating it.
TypeOf[expr,Typed[x,ty]] assumes that instances of x in expr have type ty.
TypeOf[expr,{Typed[x1,ty1],Typed[x2,ty2],…}] assumes that xi has type tyi.
TypeOf[expr,decls] uses declarations decls.
UnilateralConvolve
UnilateralConvolve[f,g,u,t] gives the unilateral convolution with respect to u of the expressions f and g.
UnilateralConvolve[f,g,{u1,…,un},{t1,…,tn}] gives the multidimensional unilateral convolution.
UnilateralDiscreteConvolve
UnilateralDiscreteConvolve[f,g,k,n] gives the unilateral discrete convolution with respect to k of the expressions f and g.
UnilateralDiscreteConvolve[f,g,{k1,…,kp},{n1,…,np}] gives the multidimensional unilateral discrete convolution.
UniqueElements
UniqueElements[{list1,list2,…}] gives the elements for each listi that are not in any other list.
UniqueElements[lists,test] uses test to determine whether pairs of elements should be considered equivalent.
UnitaryMatrix
UnitaryMatrix[umat] converts the unitary matrix umat to a structured array.
UnlabeledTree
UnlabeledTree[tree] returns a tree of the same shape as tree in which the nodes and edges are displayed without labels.
UnmanageObject
UnmanageObject[man] takes ownership of memory wrapped in a managed object.
Until
Until[test,body] evaluates body and then test, repetitively, until test first gives True.
UpdateSemanticSearchIndex
UpdateSemanticSearchIndex[index,source] updates the SemanticSearchIndex[…] index with the data in source.
UpdateSemanticSearchIndex[index,{source1, …}] updates the SemanticSearchIndex[…] index with the collection of sources sourcei.
UpdateSemanticSearchIndex[index,{source1 -> val1, …}] associates the new source sourcei to the value vali.
UpperTriangularMatrix
UpperTriangularMatrix[umat] converts the upper triangular matrix umat to a structured array.
VandermondeMatrix
VandermondeMatrix[{x1,x2,…,xn}] gives an n×n Vandermonde matrix corresponding to the nodes xi.
VandermondeMatrix[{x1,x2,…,xn},k] gives an n×k Vandermonde matrix.
VandermondeMatrix[vmat] converts a Vandermonde matrix vmat to a structured array.
VectorSymbol
VectorSymbol[v] represents a vector with name v.
VectorSymbol[v,d] represents a vector of length d.
VectorSymbol[v,d,dom] represents a vector with elements in the domain dom.
VideoExtractTracks
VideoExtractTracks[video] returns a list of video, audio and subtitle tracks of video.
VideoExtractTracks[video,"type"] returns tracks from video of a given "type".
VideoExtractTracks[video,trackspec] returns tracks specified by trackspec.
VideoFrameFold
VideoFrameFold[f,img0,video] gives a video whose frames are {f[img0,img1], f[f[img0,img1],img2],…}, where imgi are frames of video.
VideoFrameFold[f,video] assumes the first frame to be the initial frame.
VideoFrameFold[f,img0,video,n] uses partitions of n frames of the video for each step.
VideoFrameFold[f,img0,video,n,d] uses partitions of n frames with offset of d frames for each step.
VideoPadding
VideoPadding is an option for GridVideo and other video functions to specify how to pad video frames when input videos have different durations.
VideoSummaryPlot
VideoSummaryPlot[video] plots a summary of video and audio tracks of video.
VideoSummaryPlot[video,layout] lays out the video frames according to the provided layout.
VideoTranscribe
VideoTranscribe[video] recognizes speech in an audio track and adds it to video as a subtitle track.