Abort
Abort[ ]
generates an interrupt to abort a computation.
$Aborted
AbortProtect
AbortProtect[expr]
evaluates expr, saving any aborts until the evaluation is complete, or until CheckAbort is called.
Above
Abs
Abs[z]
gives the absolute value of the real or complex number z.
AbsoluteDashing
AbsoluteDashing[{d1, d2, ...}]
is a two-dimensional graphics directive which specifies that lines which follow are to be drawn dashed, with successive segments having absolute lengths d1, d2, ... (repeated cyclically). The lengths di are given in points.
AbsolutePointSize
AbsolutePointSize[d]
is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with absolute radius d. The radius d is given in points.
AbsoluteThickness
AbsoluteThickness[d]
is a graphics directive which specifies that lines which follow are to be drawn with absolute thickness d. The thickness d is given in points.
AbsoluteTime
AbsoluteTime[ ]
gives the total number of seconds since the beginning of January 1, 1900, in your time zone.
AccountingForm
AccountingForm[expr]
prints with all numbers in expr given in standard accounting notation.
Accumulate
Accumulate[f, g[e1, e2, ...]
] gives g[e1, f[e1, e2]
, f[f[e1, e2]
, e3], ...].
Accuracy
Accuracy[x]
gives the number of digits to the right of the decimal point in the number x.
AccuracyGoal
AccuracyGoal -> Automatic
yields an accuracy goal equal to 10 digits less than the setting for WorkingPrecision. With AccuracyGoal -> Infinity
, accuracy is not used as the criterion for terminating the numerical procedure. Even though you specify AccuracyGoal -> n
, the results you get may have much less than n-digit accuracy.
AddTo
x += dx
adds dx to x and returns the new value of x.
AiryAi
AiryAi[z]
gives the Airy function Ai(z).
AiryAiPrime
AiryAiPrime[z]
gives the derivative of the Airy function Ai'(z).
AiryBi
AiryBi[z]
gives the Airy function Bi(z).
AiryBiPrime
AiryBiPrime[z]
gives the derivative of the Airy function Bi'(z).
AlgebraicRules
AlgebraicRules[eqns, {x1, x2, ...}]
generates a set of algebraic rules which replace variables earlier in the list of xi with ones later in the list, according to the equation or equations eqns.
AlgebraicRulesData
Alias
All
Alternatives
$AlwaysUsePrivateColorMap
AmbientLight
Analytic
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.
AnchoredSearch
AnchoredSearch -> True
, the text searched for must be at the beginning of a record; with AnchoredSearch -> False
, the text searched for can be anywhere in a record.
And
$AnimationFunction
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, var]
writes expr as a sum of terms with square-free denominators in the variable var.
Append
Append[expr, elem]
gives expr with elem appended.
AppendTo
AppendTo[s, elem]
appends elem to the value of s, and resets s to the result.
Apply
Apply[f, expr]
or f @@ expr replaces the head of expr by f. Apply[f, expr, levelspec]
replaces heads in parts of expr specified by levelspec.
ArcCos
ArcCos[z]
gives the arc cosine of the complex number z.
ArcCosh
ArcCosh[z]
gives the inverse hyperbolic cosine of the complex number z.
ArcCot
ArcCot[z]
gives the arc cotangent of the complex number z.
ArcCoth
ArcCoth[z]
gives the inverse hyperbolic cotangent of the complex number z.
ArcCsc
ArcCsc[z]
gives the arc cosecant of the complex number z.
ArcCsch
ArcCsch[z]
gives the inverse hyperbolic cosecant of the complex number z.
ArcSec
ArcSec[z]
gives the arc secant of the complex number z.
ArcSech
ArcSech[z]
gives the inverse hyperbolic secant of the complex number z.
ArcSin
ArcSin[z]
gives the arc sine of the complex number z.
ArcSinh
ArcSinh[z]
gives the inverse hyperbolic sine of the complex number z.
ArcTan
ArcTan[z]
gives the inverse tangent of z. ArcTan[x, y]
gives the inverse tangent of y/x where x and y are real, taking into account which quadrant the point (x, y) is in.
ArcTanh
ArcTanh[z]
gives the inverse hyperbolic tangent of the complex number z.
Arg
Arg[z]
gives the argument of the complex number z.
ArithmeticGeometricMean
ArithmeticGeometricMean[a, b]
gives the arithmetic-geometric mean of a and b.
Array
Array[f, n]
generates a list of length n, with elements f[i]
. Array[f, {n1, n2, ...}]
generates an n1 X n2 X ... array of nested lists, with elements f[i1, i2, ...]
. Array[f, dims, origin]
generates a list using the specified index origin (default 1). Array[f, dims, origin, h]
uses head h, rather than List, for each level of the array.
AspectRatio
AspectRatio -> Automatic
, the ratio of height to width of the plot is determined from the actual coordinate values in the plot. AspectRatio -> r
makes the ratio equal to r.
AtomQ
AtomQ[expr]
yields True if expr is an expression which cannot be divided into subexpressions, and yields False otherwise.
Attributes
Attributes[symbol]
gives the list of attributes for a symbol.
$AutoLoad
$AutoLoad = True
enables the autoloading of system packages. Small memory systems may wish to set $AutoLoad = False
.
Automatic
Auxiliary
Auxiliary[v]
is used by the Solve package to indicate that the variable v is to be used by Roots for producing solutions, but that the corresponding values of v are not to be included in the final answer.
Axes
Axes -> True
, all axes are drawn. Axes -> False
draws no axes. Axes -> {False, True} draws a y axis but no x axis in two dimensions. Axes -> {False, False, True} draws a z axis but no x or y axis in three dimensions.
AxesEdge
AxesEdge -> Automatic
.
AxesLabel
AxesLabel -> None
, no labels are drawn on the axes in the plot. AxesLabel -> label
specifies a label for the y axis of a two-dimensional plot, and the z axis of a three-dimensional plot. AxesLabel -> {xlabel, ylabel, ... } specifies labels for different axes.
AxesOrigin
AxesOrigin -> Automatic
uses an internal algorithm to determine where the axes should cross.
AxesStyle
AxesStyle -> style
specifies that all axes are to be rendered with the specified graphics directive, or list of graphics directives. AxesStyle -> {{xstyle}, {ystyle}, ... } specifies that axes should use graphics directives xstyle, ... .
Background
Background -> Automatic
produces a white background on most output devices.
BaseForm
BaseForm[expr, n]
prints with the numbers in expr given in base n.
$BatchInput
$BatchOutput
Begin
Begin["context`"]
resets the current context.
BeginPackage
BeginPackage["context`"]
makes context` and System` the only active contexts. BeginPackage["context`", {"need1`", "need2`", ...}]
calls Needs on the needi.
Below
BernoulliB
BernoulliB[n]
gives the nth Bernoulli number. BernoulliB[n, x]
gives the nth Bernoulli polynomial.
BesselI
BesselI[n, z]
gives the modified Bessel function of the first kind I(n, z).
BesselJ
BesselJ[n, z]
gives the Bessel function of the first kind J(n, z).
BesselK
BesselK[n, z]
gives the modified Bessel function of the second kind K(n, z).
BesselY
BesselY[n, z]
gives the Bessel function of the second kind Y(n, z).
Beta
Beta[a, b]
gives the Euler beta function B(a, b). Beta[z, a, b]
gives the incomplete beta function. Beta[z0, z1, a, b]
gives the generalized incomplete Beta function Beta[z1, a, b]
- Beta[z0, a, b]
.
BetaRegularized
BetaRegularized[z, a, b]
gives the regularized incomplete beta function I(z, a, b) = Beta[z, a, b]
/Beta[a, b]
. BetaRegularized[z0, z1, a, b]
gives the generalized incomplete beta function I(z1, a, b) - I(z0, a, b).
Binomial
Binomial[n, m]
gives the binomial coefficient.
Blank
Blank[ ]
is a pattern object that can stand for any Mathematica expression. _h or Blank[h]
can stand for any expression with head h.
BlankForm
BlankNullSequence
BlankNullSequence[ ]
is a pattern object that can stand for any sequence of zero or more Mathematica expressions. ___h or BlankNullSequence[h]
can stand for any sequence of expressions, all of which have head h.
BlankSequence
BlankSequence[ ]
is a pattern object that can stand for any sequence of one or more Mathematica expressions. __h or BlankSequence[h]
can stand for any sequence of one or more expressions, all of which have head h.
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, .... Block[{vars}, body /; cond]
allows local variables to be shared between conditions and function bodies.
Bottom
Boxed
Boxed -> True
draws the edges of the bounding box in a three-dimensional picture. With Boxed -> False
, no bounding box is drawn.
BoxRatios
BoxRatios -> Automatic
determines the ratios using the range of actual coordinate values in the plot.
BoxStyle
BoxStyle -> Automatic
uses a default style.
Break
Break[ ]
exits the nearest enclosing Do, For or While.
Byte
ByteCount
ByteCount[expr]
gives the number of bytes used internally by Mathematica to store expr.
C
C[i]
is the default form for the i-th constant of integration produced in solving a differential equation with DSolve.
CallPacket
CallProcess
CallProcess["command", f, {x1, x2, ...}]
calls the function f in an external process, with arguments xi. (CallProcess has been superseded by MathLink operations.)
Cancel
Cancel[expr]
cancels out common factors in the numerator and denominator of expr.
Cases
Cases[{e1, e2, ...}, pattern]
gives a list of the ei that match the pattern. Cases[{e1, ...}, pattern -> rhs
]
or 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 which match the pattern.
Catalan
Catch
Catch[expr]
returns the argument of the first Throw generated in the evaluation of expr.
Ceiling
Ceiling[x]
gives the smallest integer greater than or equal to x.
CellArray
CellArray[{{a11, a12, ...}, ...}]
is a two-dimensional graphics primitive which represents a rectangular array of gray cells.
Center
CForm
CForm[expr]
prints as a C language version of expr.
Character
CharacteristicPolynomial
CharacteristicPolynomial[m, x]
gives the characteristic polynomial defined by the square matrix m and the variable x. The result is normally equivalent to Det[m - x IdentityMatrix[Length[m]
]].
Characters
Characters["string"]
gives a list of the characters in a string.
ChebyshevT
ChebyshevT[n, x]
gives the nth Chebyshev polynomial of the first kind.
ChebyshevU
ChebyshevU[n, x]
gives the nth Chebyshev polynomial of the second kind.
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.
CheckAbort
CheckAbort[expr, failexpr]
evaluates expr, returning failexpr if an abort occurs.
Chop
Chop[expr]
replaces approximate real numbers in expr that are close to zero by the exact integer 0. Chop[expr, tol]
replaces approximate real numbers in expr that differ from zero by less than tol with 0.
Circle
Circle[{x, y}, r]
is a two-dimensional graphics primitive that represents a circle of radius r centered at the point {x, y}. Circle[{x, y}, {rx, ry}]
yields an ellipse with semi-axes rx and ry. Circle[{x, y}, r, {theta1, theta2}]
represents a circular arc.
Clear
Clear[symbol1, symbol2, ...]
clears values and definitions for the specified symbols. Clear["pattern1", "pattern2", ...]
clears values and definitions for all symbols whose names match any of the specified string patterns.
ClearAll
ClearAll[symbol1, symbol2, ...]
clears all values, definitions, attributes, messages and defaults associated with symbols. ClearAll["pattern1", "pattern2", ...]
clears all symbols whose names textually match any of the specified string patterns.
ClearAttributes
ClearAttributes[s, attr]
removes attr from the list of attributes of the symbol s.
ClebschGordan
ClebschGordan[{j1,m1},{j2,m2},{j3,m3}]
evaluates the Clebsch-Gordan coefficient through its relation to the 3-j symbol. The ji must satisfy triangularity conditions and m1+m2 = m3.
$ClickKillsWindow
ClipFill
ClipFill -> Automatic
, places where the surface extends beyond the bounding box are shown like the rest of the surface. ClipFill -> None
shows holes in the surface where it would be clipped. ClipFill -> color
shows clipped areas with a particular color. ClipFill -> {bottom, top} uses different specifications for bottom and top clipped areas.
Close
Close[stream]
closes a stream.
CMYKColor
CMYKColor[cyan, magenta, yellow, black]
is a graphics directive which specifies that graphical objects which follow are to be displayed in the color given.
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.
CoefficientList
CoefficientList[poly, var]
gives a list of coefficients of powers of var in poly, starting with power 0. CoefficientList[poly, {var1, var2, ...}]
gives a matrix of coefficients of the vari.
CofactorExpansion
Method -> CofactorExpansion
will cause RowReduce and related functions to attempt to invert the leftmost n x n submatrix of a given matrix of n rows (if it has at least n columns), and to multiply by that inverse if it is exists. This will put the original matrix into reduced row-echelon form.
Collect
Collect[expr, x]
collects together terms involving the same power of x. Collect[expr, {x1, x2, ...}]
collects together terms that involve the same powers of x1, x2, ....
ColonForm
ColonForm[a,b]
prints as a: b.
ColorFunction
ColorFunction -> Automatic
yields a range of gray levels. ColorFunction -> Hue
yields a range of colors.
ColorOutput
ColorOutput -> Automatic
uses whatever color directives are given. ColorOutput -> CMYKColor
converts to CMYKColor. ColorOutput -> GrayLevel
converts to GrayLevel. ColorOutput -> RGBColor
converts to RGBColor. ColorOutput -> f
converts using the function f.
Column
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.
$CommandLine
Compile
Compile[{x1, x2, ...}, expr]
creates a compiled function which evaluates expr assuming numerical values of the xi. Compile[{{x1, t1}, ...}, expr]
assumes that xi is of a type which matches ti. Compile[vars, expr, {{p1, pt1}, ...}]
assumes that subexpressions in expr which match pi are of types which match pti.
Compiled
Compiled -> True
, expressions they work with are automatically compiled. With Compiled -> False
, they are not.
CompiledFunction
Compiled -> True
, expressions they work with are automatically compiled. With Compiled -> False
, they are not.
Complement
Complement[eall, e1, e2, ...]
gives the elements in eall which are not in any of the ei.
Complex
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
Compose
Compose[a,b,c,d]
gives a[b[c[d]
]].
ComposeList
ComposeList[{f1, f2, ...}, x]
generates a list of the form {x, f1[x]
, f2[f1[x]
], ...}.
ComposeSeries
ComposeSeries[s,t,u,...]
composes the power series s,t,u, etc. The series (except for the first element) must begin with a positive power of the variable.
Composition
Composition[f1, f2, f3, ...]
represents a composition of the functions f1, f2, f3, ....
CompoundExpression
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.
$ConditionHold
Conjugate
Conjugate[z]
gives the complex conjugate of the complex number z.
Connect
LinkMode -> Connect
causes a link to be created that will connect to a link listening on a named port.
Constant
Constants
ConstrainedMax
ConstrainedMax[f, {inequalities}, {x, y, ...}]
finds the global maximum of f in the domain specified by the inequalities. The variables x, y, ... are all assumed to be non-negative.
ConstrainedMin
ConstrainedMin[f, {inequalities}, {x, y, ...}]
finds the global minimum of f in the domain specified by the inequalities. The variables x, y, ... are all assumed to be non-negative.
$Context
Context
Context[ ]
gives the current context. Context[symbol]
gives the context in which a symbol appears.
$ContextPath
Contexts
Contexts[ ]
gives a list of all contexts. Contexts["string"]
gives a list of the contexts which match the string. The string can contain metacharacters. See also: $Packages, $ContextPath.
ContextToFilename
ContextToFilename["context`"]
gives the string specifying the file name that is by convention associated with a particular context.
Continuation
Continuation[n]
is output at the beginning of the nth line in a multiline printed expression.
Continue
Continue[ ]
exits to the nearest enclosing Do, For or While in a procedural program.
ContourGraphics
ContourGraphics[array]
is a representation of a contour plot.
ContourLevels
ContourLines
ContourLines -> True
, explicit contour lines are drawn. With ContourLines -> False
, no contour lines are drawn.
ContourPlot
ContourPlot[f, {x, xmin, xmax}, {y, ymin, ymax}]
generates a contour plot of f as a function of x and y.
Contours
Contours -> n
chooses n equally spaced contours between the minimum and maximum z values. Contours -> {z1, z2, ... } specifies the explicit z values to use for contours.
ContourShading
ContourShading -> False
, regions between contour lines are left blank. With ContourShading -> True
, regions are colored based on the setting for the option ColorFunction.
ContourSmoothing
ContourSmoothing -> False
, contour lines are computed using linear interpolation. With ContourSmoothing -> True
, cubic interpolation is used.
ContourSpacing
ContourStyle
ContourStyle -> style
, all contour lines are generated with the specified graphics directive, or list of graphics directives. ContourStyle -> {{style1}, {style2}, ... } specifies that successive contour lines should use graphics directives style1, ... . ContourStyle -> Automatic
uses a default style.
CopyDirectory
CopyDirectory["dir1", "dir2"]
copies the directory dir1 to dir2.
CopyFile
CopyFile["file1", "file2"]
copies file1 to file2.
Cos
Cos[z]
gives the cosine of z.
Cosh
Cosh[z]
gives the hyperbolic cosine of z.
CoshIntegral
CoshIntegral[x]
gives the hyperbolic cosine integral EulerGamma + Log[x]
+ Integrate[(Cosh[t]
- 1)/t, {t, 0, x}].
CosIntegral
CosIntegral[x]
gives the cosine integral EulerGamma + Log[x]
+ Integrate[(Cos[t]
- 1)/t, {t, 0, x}].
Cot
Cot[z]
gives the cotangent of z.
Coth
Coth[z]
gives the hyperbolic cotangent of z.
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.
CreateDirectory
CreateDirectory["dir"]
creates a directory.
$CreationDate
Csc
Csc[z]
gives the cosecant of z.
Csch
Csch[z]
gives the hyperbolic cosecant of z.
Cubics
Cubics -> True
, explicit solutions are generated for irreducible cubic equations. Cubics -> False
causes irreducible cubics to be left unsolved in their original symbolic form.
Cuboid
Cuboid[{xmin, ymin, zmin}]
is a three-dimensional graphics primitive that represents a unit cuboid, oriented parallel to the axes. Cuboid[{xmin, ymin, zmin}, {xmax, ymax, zmax}]
specifies a cuboid by giving the coordinates of opposite corners.
Cyclotomic
Cyclotomic[n, x]
gives the cyclotomic polynomial of order n in x.
D
D[f, x]
gives the partial derivative of f with respect to x. D[f, {x, n}]
gives the nth partial derivative with respect to x. D[f, x1, x2, ...]
gives a mixed derivative.
DampingFactor
DampingFactor -> n
uses a damping factor of n in Newton's method.
Dashing
Dashing[{r1, r2, ...}]
is a two-dimensional graphics directive which specifies that lines which 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.
DataOnly
DataOnly -> True
can be used to specify that only data and not Mathematica program text should be included in the dump file. With DataOnly -> False
, both data and text are included.
Date
Date[ ]
gives the current local date and time in the form {year, month, day, hour, minute, second}.
Debug
Debug[expr]
evaluates expr, allowing you to stop at certain points in some control structures, and see what's happening or run commands. Debug[expr, {f1, f2, ...}]
stops only in evaluation of the functions fi (and everything they call).
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.
Decrement
Default
Default[f]
, if defined, gives the default value for arguments of the function f obtained with a _. pattern object. Default[f, i]
gives the default value to use when _. appears as the ith argument of f. Default[f, i, n]
gives the default value for the ith argument out of a total of n arguments.
DefaultColor
DefaultColor -> Automatic
gives a color complementary to the background specified.
$DefaultFont
DefaultFont
DefaultValues
DefaultValues[f]
gives a list of transformation rules corresponding to all defaults (values for Default[f[x,..]
,..], etc.) defined for the symbol f.
DefineExternal
Definition
Definition[s1, s2, ...]
prints as the definitions given for the symbols si.
Degree
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.
DeleteCases
DeleteCases[expr, pattern]
removes all elements of expr which match pattern. DeleteCases[expr, pattern, levspec]
removes all parts of expr on levels specified by levspec which match pattern.
DeleteContents
DeleteContents -> True
deletes the directory and all files and directories it contains. DeleteContents -> False
deletes the directory only if it contains no files.
DeleteDirectory
DeleteDirectory["dir"]
deletes the specified directory.
DeleteFile
DeleteFile["file"]
deletes a file. DeleteFile[{"file1", "file2", ...}]
deletes a list of files.
Delimiters
Denominator
Denominator[expr]
gives the denominator of expr.
DensityGraphics
DensityGraphics[array]
is a representation of a density plot.
DensityPlot
DensityPlot[f, {x, xmin, xmax}, {y, ymin, ymax}]
makes a density plot of f as a function of x and y.
Depth
Depth[expr]
gives the maximum number of indices needed to specify any part of expr, plus one.
Derivative
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.
Det
Det[m]
gives the determinant of the square matrix m.
DiagonalMatrix
DiagonalMatrix[list]
gives a matrix with the elements of list on the leading diagonal, and 0 elsewhere.
Dialog
Dialog[ ]
initiates a dialog. Dialog[expr]
initiates a dialog with expr as the current value of %.
DialogIndent
DialogIndent[d]
is printed as the indentation for input and output lines in a depth d dialog.
DialogProlog
DialogSymbols
DialogSymbols :> {x, y, ... }
specifies that x, y, ... should have local values for the duration of the dialog. DialogSymbols :> {x = x0, y = y0, ... }
defines initial values for variables.
DigitBlock
DigitBlock -> Infinity
, no breaks are inserted. DigitBlock -> n
inserts a break every n digits. DigitBlock -> {nleft, nright} inserts a break every nleft digits to the left of the decimal point, and every nright digits to the right of the decimal point.
DigitQ
DigitQ[string]
yields True if all the characters in the string are digits in the range 0 through 9, and yields False otherwise.
Digits
Digits[n]
gives a list of the digits of the integer n. Digits[n, b]
gives a list of the digits in base b. Digits[x, b]
gives a list containing a list of digits of the integer part of x, a list of digits of the fractional part, and the exponent of b.
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.
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 -> 1
, the limit is taken from below. With Direction -> -1, the limit is taken from above. Direction -> Automatic
uses Direction -> -1 except for limits at Infinity, where it is equivalent to Direction -> 1
.
Directory
Directory[ ]
gives the current working directory.
DirectoryStack
DirectoryStack[ ]
gives the directory stack which represents the sequence of current directories used.
Disk
Disk[{x, y}, r]
is a two-dimensional graphics primitive that represents a filled disk of radius r centered at the point {x, y}. Disk[{x, y}, {rx, ry}]
yields an elliptical disk with semi-axes rx and ry. Disk[{x, y}, r, {theta1, theta2}]
represents a segment of a disk.
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.
$Display
Display
Display[channel, graphics]
writes graphics or sound to the specified output channel.
DisplayAnimation
$DisplayFunction
DisplayFunction
Display[channel, #]
&). DisplayFunction -> Identity
causes the objects to be returned, but no display to be generated.
$DisplayHeight
$DisplayTitle
$DisplayWidth
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.
Divide
Divide[x, y]
is equivalent to x y^-1.
DivideBy
x /= c
divides x by c and returns the new value of x.
DivisionFreeRowReduction
Method -> DivisionFreeRowReduction
causes Gaussian elimination of symbolic matrices to initially clear denominators in each row and subsequently to not attempt to simplify pivots for row operations.
Divisors
Divisors[n]
gives a list of the integers that divide n.
DivisorSigma
DivisorSigma[k, n]
gives the sum of the kth powers of the positive divisors of n.
Do
Do[expr, {imax}]
evaluates expr imax 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, imin, imax}, {j, jmin, jmax}, ...]
evaluates expr looping over different values of j, etc. for each i. Do[]
returns Null, or the argument of the first Return it evaluates.
Dot
Dot[a, b, c]
gives products of vectors, matrices and tensors.
DoubleExponential
Method -> DoubleExponential
causes a doubly exponentially convergent algorithm to be used. For multi-dimensional integration, DoubleExponential refers to a Cartesian product of one-dimensional doubly exponentially convergent quadrature rules.
DoublyInfinite
DoublyInfinite -> True
, the summation is taken from -Infinity to Infinity. With DoublyInfinite -> False
, the summation is taken from zero to Infinity.
DownValue
DownValues[f]
gives a list of transformation rules corresponding to all downvalues (values for f[x,..]
, etc.) defined for the symbol f.
DownValues
DownValues[f]
gives a list of transformation rules corresponding to all downvalues defined for the symbol f.
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.
DSolve
DSolve[eqn, y[x]
, x] solves a differential equation for the functions y[x]
, with independent variable x. DSolve[{eqn1, eqn2, ...}, {y1[x1, ...]
, ...}, {x1, ...}] solves a list of differential equations.
DSolveConstants
DSolveConstants -> C
, which yields constants of integration C[1]
, C[2]
, ... .
Dt
Dt[f, x]
gives the total derivative of f with respect to x. Dt[f]
gives the total differential of f. Dt[f, {x, n}]
gives the nth total derivative with respect to x. Dt[f, x1, x2, ...]
gives a mixed total derivative.
Dump
Dump["filename"]
writes a complete image of the current state of your Mathematica session to a file. Dump["filename", startup]
includes the Mathematica expression startup, to be run when the image is executed. Dump["filename", startup, "code"]
uses the executable binary in the file "code". The default for "code" is First[$CommandLine]
.
$DumpDates
$DumpedPackages
$DumpSupported
E
$Echo
EdgeForm
EdgeForm[g]
is a three-dimensional graphics directive which specifies that edges of polygons are to be drawn using the graphics directive or list of graphics directives g.
Edit
Edit[expr___]
lets you edit the expressions expr.
EditDef
EditDefinition
EditDefinition[syms___]
lets you edit the rules attached to the symbols syms.
EditIn
EditIn[n__Integer]
lets you edit input lines n. EditIn[]
edits the previous input line.
Eigensystem
Eigensystem[m]
gives a list {values, vectors} of the eigenvalues and eigenvectors of the square matrix m.
Eigenvalues
Eigenvalues[m]
gives a list of the eigenvalues of the square matrix m.
Eigenvectors
Eigenvectors[m]
gives a list of the eigenvectors of the square matrix m.
Eliminate
Eliminate[eqns, vars]
eliminates variables between a set of simultaneous equations.
EllipticE
EllipticE[m]
gives the complete elliptic integral E(m). EllipticE[phi, m]
gives the elliptic integral of the second kind E(phi|m).
EllipticExp
EllipticExp[u, {a, b}]
gives the generalized exponential associated with the elliptic curve y^2 = x^3 + a x^2 + b x
.
EllipticExpPrime
EllipticExpPrime[u, {a, b}]
gives the derivative with respect to the first argument of EllipticExp[u, {a, b}]
.
EllipticF
EllipticF[phi, m]
gives the elliptic integral of the first kind F(phi|m).
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 y^2 == x^3 + a x^2 + b x
.
EllipticNomeQ
EllipticNomeQ[m]
gives the nome q == Exp[-Pi EllipticK[1-m]/EllipticK[m]]
.
EllipticPi
EllipticPi[n, phi, m]
gives the elliptic integral of the third kind Pi(n; phi|m). EllipticPi[n, m]
gives the complete elliptic integral Pi(n|m).
EllipticTheta
EllipticTheta[i, z, q]
gives the elliptic theta function theta_i(z, q), where i = 1, 2, 3, or 4.
EllipticThetaC
EllipticThetaC[u, m]
gives Neville's elliptic theta function theta_c(u, m).
EllipticThetaD
EllipticThetaD[u, m]
gives Neville's elliptic theta function theta_d(u, m).
EllipticThetaN
EllipticThetaN[u, m]
gives Neville's elliptic theta function theta_n(u, m).
EllipticThetaPrime
EllipticThetaPrime[i, z, q]
gives the derivative with respect to the second argument of the elliptic theta function theta_i(z, q), where i = 1, 2, 3, or 4.
EllipticThetaS
EllipticThetaS[u, m]
gives Neville's elliptic theta function theta_s(u, m).
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 which must be read in using Get["dest", "key"]
.
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.
EndOfFile
EndPackage
EndPackage[ ]
restores $Context and $ContextPath to their values before the preceding BeginPackage, and prepends the current context to the list $ContextPath.
EndProcess
EndProcess["command"]
terminates an external process in which functions could be called from Mathematica. (EndProcess has been superseded by MathLink operations.)
EngineeringForm
EngineeringForm[expr]
prints with all real numbers in expr given in engineering notation.
Enter
EnterExpressionPacket
EnterTextPacket
Environment
Environment["var"]
gives the value of an operating system environment variable.
$Epilog
Epilog
Equal
lhs == rhs
returns True if lhs and rhs are identical.
EquatedTo
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) == 1 - erf(z).
Erfi
Erfi[z]
gives the imaginary error function erfi(z) == -i erf(i z).
EulerE
EulerE[n]
gives the nth Euler number. EulerE[n, x]
gives the nth Euler polynomial.
EulerGamma
EulerPhi
EulerPhi[n]
gives the Euler totient function phi(n). It is the number of positive integers less than n which are relatively prime to 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
EvenQ
EvenQ[expr]
gives True if expr is an even integer, and False otherwise.
Exit
Exit[ ]
terminates a Mathematica session.
Exp
Exp[z]
is the exponential function.
Expand
Expand[expr]
expands out products and positive integer powers in expr. Expand[expr, patt]
avoids expanding elements of expr which do not contain terms matching 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 which do not contain terms matching the pattern patt.
ExpandDenominator
ExpandDenominator[expr]
expands out products and powers that appear as denominators in expr.
ExpandNumerator
ExpandNumerator[expr]
expands out products and powers that appear in the numerator of expr.
ExpIntegralE
ExpIntegralE[n, z]
gives the exponential integral function E(n,z).
ExpIntegralEi
ExpIntegralEi[z]
gives the exponential integral function Ei(z).
Exponent
Exponent[expr, form]
gives the maximum power with which form appears in expr. Exponent[expr, form, h]
applies h to the set of exponents with which form appears in expr.
ExponentFunction
ExponentFunction -> Automatic
determines the exponent to be used in printing approximate real numbers based on the output form of the number. A typical setting is ExponentFunction -> (3 Quotient[#, 3]
&).
ExponentStep
Expression
ExtendedGCD
ExtendedGCD[n, m]
gives the extended greatest common divisor of the integers n and m.
ExternalCall
FaceForm
FaceForm[gf, gb]
is a three-dimensional graphics directive which specifies that the front faces of polygons are to be drawn with the graphics primitive gf, and the back faces with gb.
FaceGrids
FaceGrids -> All
, grid lines are drawn on all the faces of the bounding box. FaceGrids -> None
draws no grid lines. FaceGrids -> {face1, face2, ... } draws grid lines on the specified faces. FaceGrids -> {{face1, {xgrid, ygrid}}, ... } specifies an arrangement of the grid lines.
Factor
Factor[poly]
factors a polynomial over the integers. Factor[poly, Modulus->p
]
factors a polynomial modulo a prime p.
FactorComplete
FactorComplete -> True
, complete factorization is performed; with FactorComplete -> False
, at most one factor is extracted.
Factorial
Factorial2
FactorInteger
FactorInteger[n]
gives a list of the prime factors of the integer n, together with their exponents.
FactorList
FactorList[poly]
gives a list of the factors of a polynomial, together with their exponents. FactorList[poly, Modulus->p
]
factors a polynomial modulo a prime p.
FactorSquareFree
FactorSquareFree[poly]
writes a polynomial as a product of square-free factors. FactorSquareFree[poly, Modulus->p
]
factors a polynomial modulo a prime p.
FactorSquareFreeList
FactorSquareFreeList[poly]
gives a list of square-free factors of a polynomial, together with their exponents. FactorSquareFreeList[poly, Modulus->p
]
factors a polynomial modulo a prime p.
FactorTerms
FactorTerms[poly]
pulls out any overall numerical factor in poly.
FactorTermsList
FactorTermsList[poly]
pulls out any overall numerical factor in poly and returns a list of factors.
Fail
$Failed
False
File
FileByteCount
FileByteCount["file"]
gives the number of bytes in a file.
FileDate
FileDate["file"]
gives the date and time at which a file was last modified.
FileInformation
FileInformation[file]
gives information about a file.
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[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.
FileType
FileType["file"]
gives the type of a file, typically File, Directory or None.
Find
Find[stream, "text"]
finds the first record in an input stream that contains the specified string. Find[stream, {"text1", "text2", ...}]
finds the first record that contains any of the specified strings.
FindList
FindList["file", "text"]
gives a list of all records in the file that contain the specified string. FindList["file", {"text1", "text2", ...}]
gives a list of all records that contain any of the specified strings. FindList[{"file1", ...}, text]
gives a list of records containing the specified strings in any of the files. FindList[files, text, n]
includes only the first n records found.
FindMinimum
FindMinimum[f, {x, x0}]
searches for a local minimum in f, starting from the point x=x0.
FindRoot
FindRoot[lhs == rhs, {x, x0}]
searches for a numerical solution to the equation lhs == rhs
, starting with x == x0
.
First
First[expr]
gives the first element in expr.
Fit
Fit[data, funs, vars]
finds a least-squares fit to a list of data as a linear combination of the functions funs of variables vars. The data can have the form {{x1, y1, ..., f1}, {x2, y2, ..., f2}, ...}, where the number of coordinates x, y, ... is equal to the number of variables in the list vars. The data can also be of the form {f1, f2, ...}, with a single coordinate assumed to take values 1, 2, .... The argument funs can be any list of functions that depend only on the objects vars.
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
Flatten
Flatten[list]
flattens out nested lists. Flatten[list, n]
flattens to level n. Flatten[list, n, h]
flattens subexpressions with head h.
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.
Floor
Floor[x]
gives the greatest integer less than or equal to x.
Fold
Fold[f, x, list]
gives the last element of FoldList[f, x, list]
.
FoldList
FoldList[f, x, {a, b, ...}]
gives {x, f[x, a]
, f[f[x, a]
, b], ...}.
Font
FontForm
FontForm[expr, {"font", size}]
specifies that expr should be printed in the specified font and size.
For
For[start, test, incr, body]
executes start, then repeatedly evaluates body and incr until test fails to give True.
Format
Format[expr]
prints as the formatted form of expr. Assigning values to Format[expr]
defines print forms for expressions. Format[expr, type]
gives a format of the specified type.
FormatType
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.
FortranForm
FortranForm[expr]
prints as a Fortran language version of expr.
Fourier
Fourier[list]
finds the discrete Fourier transform of a list of complex numbers.
Frame
Frame -> True
, a frame is drawn around the plot. With Frame -> False
, no frame is drawn. Frame -> {True, False, True, False} draws just the top and bottom of the frame.
Framed
FrameLabel
FrameLabel -> None
, no labels are given.
FrameStyle
FrameStyle -> Automatic
, the edges of a frame are rendered using a default style. With FrameStyle -> style
, the specified graphics directive, or list of graphics directives is used. FrameStyle -> {{xmstyle}, {ymstyle}, ... } specifies different styles for different edges of the frame.
FrameTicks
FrameTicks -> Automatic
, tick marks for the edges of a frame are chosen automatically. With FrameTicks -> None
, no tick marks are drawn. FrameTicks -> {xmticks, ymticks, ... } specifies tick mark options separately for each edge.
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.
FresnelC
FresnelC[x]
gives the Fresnel integral C[x] = Integrate[Cos[Pi t^2/2], {t, 0, x}]
.
FresnelS
FresnelS[x]
gives the Fresnel integral S[x] = Integrate[Sin[Pi t^2/2], {t, 0, x}]
.
FromASCII
FromASCII["c"]
gives the ASCII integer code corresponding to the character c.
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.
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.
FullAxes
FullAxes[graphics]
returns the axes options of a graphics object.
FullDefinition
FullDefinition[s1, s2, ...]
prints as the definitions given for the symbols si, 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.
FullOptions
FullOptions[expr]
gives the full settings of options explicitly specified in an expression such as a graphics object. FullOptions[expr, name]
gives the full setting for the option name. FullOptions[expr, {name1, name2, ...}]
gives a list of the full settings for the options namei.
Function
Function[body]
or body& is a pure function. The formal parameters are # (or #1), #2, etc. Function[x, body]
is a pure function with a single formal parameter x. Function[{x1, x2, ...}, body]
is a pure function with a list of formal parameters. Function[{x1, x2, ...}, body, {attributes}]
has the given attributes during evaluation.
Gamma
Gamma[a]
is the Euler gamma function Gamma(a). Gamma[a, z]
is the incomplete gamma function Gamma(a, z). Gamma[a, z0, z1]
is the generalized incomplete gamma function Gamma(a, z0) - Gamma(a, z1).
GammaRegularized
GammaRegularized[a, z]
is the regularized incomplete gamma function Q(a, z) = Gamma(a, z)/Gamma(a). GammaRegularized[a, z0, z1]
is the generalized incomplete gamma function Q(a, z0) - Q(a, z1);
GaussianIntegers
GaussianIntegers -> True
, factorization is done over the Gaussian integers when possible. With GaussianIntegers -> False
, factorization is done over the integers.
GaussKronrod
Method -> GaussKronrod
causes adaptive Gauss-Kronrod quadrature to be used. For multi-dimensional integration, GaussKronrod refers to a Cartesian product of one-dimensional Gauss-Kronrod quadrature rules.
GaussPoints
GaussPoints -> n
, the Gaussian part of Gauss-Kronrod quadrature uses n points. With GaussPoints -> Automatic
, an internal algorithm chooses the number of points.
GCD
GCD[n1, n2, ...]
gives the greatest common divisor of the integers ni.
GegenbauerC
GegenbauerC[n, m, x]
gives the nth Gegenbauer polynomial.
General
Generic
Get
Get["name", key]
gets a file that has been encoded with a certain key.
GetContext
GetContext["context`"]
loads the file named by ContextToFilename["context`"]
, which gives the conventional filename for a package that defines "context`".
GoldenRatio
Sqrt[5]
)/2, with numerical value 1.61803....
Goto
Goto[tag]
scans the current compound expression for Label[tag]
, and transfers control to that point.
Gradient
Gradient-> Automatic
, the gradient is computed symbolically. A typical setting is Gradient -> {2 x, Sign[y]
}.
Graphics
Graphics[primitives, options]
represents a two-dimensional graphical image.
GraphicsArray
GraphicsArray[{g1, g2, ...}]
represents a row of graphics objects. GraphicsArray[{{g11, g12, ...}, ...}]
represents a two-dimensional array of graphics objects.
GraphicsSpacing
Graphics3D
Graphics3D[primitives, options]
represents a three-dimensional graphical image.
GrayLevel
GrayLevel[level]
is a graphics directive which specifies the gray-level intensity with which graphical objects that follow should be displayed.
Greater
GreaterEqual
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 non-increasing sequence.
GridLines
GridLines -> None
, no grid lines are drawn. GridLines -> Automatic
places the grid lines automatically. GridLines -> {xgrid, ygrid} specifies the position of grid lines in each direction.
GroebnerBasis
GroebnerBasis[{poly1, poly2, ...}, {x1, x2, ...}]
gives a list of polynomials which form a Groebner basis for the ideal generated by the polyi.
Hash
Hash[expr]
gives an integer hash code for any expression expr.
HashTable
Head
Head[expr]
gives the head of expr.
HeadCompose
HeadCompose[a, b, c, d]
gives a[b]
[c][d].
Headers
Heads
Heads -> True
, heads are treated like other elements of expressions for the purpose of levels. Heads -> False
never includes heads as part of any level of an expression.
HeldPart
HeldPart[expr, pos]
extracts the part or parts specified by pos, and wraps each of them in Hold.
HermiteH
HermiteH[n, x]
gives the nth Hermite polynomial.
HermiteNormalForm
HiddenSurface
HiddenSurface -> True
draws a solid surface. HiddenSurface -> False
draws the mesh with transparent polygons.
Hold
Hold[expr]
maintains expr in an unevaluated form.
HoldAll
HoldFirst
HoldForm
HoldForm[expr]
prints as the expression expr, with expr maintained in an unevaluated form.
HoldRest
HomeDirectory
HomeDirectory[ ]
gives your "home" directory.
HorizontalForm
Hue
Hue[h]
is a graphics directive which specifies that graphical objects which follow are to be displayed, if possible, in a color corresponding to hue h. Hue[h, s, b]
specifies colors in terms of hue, saturation and brightness.
HypergeometricPFQ
HypergeometricPFQ[numlist, denlist, z]
gives the generalized hypergeometric function pFq where numlist is a list of the p parameters in the numerator and denlist is a list of the q parameters in the denominator.
HypergeometricPFQRegularized
HypergeometricPFQRegularized[numlist, denlist, z]
gives the regularized generalized hypergeometric function pFq where numlist is a list of the p parameters in the numerator and q is a list of the q parameters in the denominator. HypergeometricPFQRegularized[numlist, denlist, z] == HypergeometricPFQ[numlist, denlist, z]/(Times @@ (Gamma /@ denlist))
except when denlist contains a non-positive integer when it is defined by analytic continuation to remove the indeterminacy.
HypergeometricU
HypergeometricU[a, b, z]
is the confluent hypergeometric function U(a, b, z).
Hypergeometric0F1
Hypergeometric0F1[a, z]
is the hypergeometric function 0F1(; a; z).
Hypergeometric0F1Regularized
Hypergeometric0F1Regularized[a, z]
is the hypergeometric function 0F1(; a; z)/Gamma(a).
Hypergeometric1F1
Hypergeometric1F1[a, b, z]
is the Kummer confluent hypergeometric function 1F1(a; b; z).
Hypergeometric1F1Regularized
Hypergeometric1F1Regularized[a, b, z]
is the Kummer confluent hypergeometric function 1F1(a; b; z)/Gamma(b).
Hypergeometric2F1
Hypergeometric2F1[a, b, c, z]
is the hypergeometric function 2F1(a, b; c; z).
Hypergeometric2F1Regularized
Hypergeometric2F1Regularized[a, b, c, z]
is the hypergeometric function 2F1(a, b; c; z)/Gamma(c).
I
Sqrt[-1]
.
Identity
Identity[expr]
gives expr (the identity operation).
IdentityMatrix
IdentityMatrix[n]
gives the n X n 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 -> True
, lower- and upper-case letters are treated as equivalent. With IgnoreCase -> False
, lower- and upper-case letters are treated as totally different.
$IgnoreEOF
Im
Im[z]
gives the imaginary part of the complex number z.
Implies
Implies[p, q]
represents the logical implication p => q
.
In
In[n]
is a global object that is assigned to have a delayed value of the nth input line.
IncludeSingularTerm
IncludeSingularTerm -> True
, terms of the form (k + a)^-s with k + a == 0 are included. With IncludeSingularTerm -> False
, they are not.
Increment
Indent
Indent[d]
is printed as the indentation for a depth d subexpression.
Indeterminate
Inequality
Infinity
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 ....
Information
Information[symbol]
prints information about a symbol.
Inner
Inner[f, list1, list2, g]
is a generalization of Dot in which f plays the role of multiplication and g of addition.
$Input
Input
Input[ ]
interactively reads in one Mathematica expression. Input["prompt"]
requests input, using the specified string as a prompt.
InputForm
InputForm[expr]
prints as a version of expr suitable for input to Mathematica.
InputNamePacket
InputPacket
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, using the specified string as a prompt.
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.
$Inspector
Install
Install["command"]
starts an external program and installs Mathematica definitions to call functions in it.
InString
InString[n]
is a global object that is assigned to be the text of the nth input line.
Integer
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, k]
gives a list of length k containing the least significant digits of n.
IntegerQ
IntegerQ[expr]
gives True if expr is an integer, and False otherwise.
Integrate
Integrate[f,x]
gives the indefinite integral of f with respect to x. Integrate[f,{x,xmin,xmax}]
gives the definite integral. Integrate[f,{x,xmin,xmax},{y,ymin,ymax}]
gives a multiple integral.
InterpolatingFunction
InterpolatingFunction[range, table]
represents an approximate function whose values are found by interpolation.
InterpolatingPolynomial
InterpolatingPolynomial[data, var]
gives a polynomial in the variable var which provides an exact fit to a list of data. The data can have the forms {{x1, f1}, {x2, f2}, ...} or {f1, f2, ...}, where in the second case, the xi are taken to have values 1, 2, .... The fi can be replaced by {fi, dfi, ddfi, ...}, specifying derivatives at the points xi.
Interpolation
Interpolation[data]
constructs an InterpolatingFunction object which represents an approximate function that interpolates the data. The data can have the forms {{x1, f1}, {x2, f2}, ...} or {f1, f2, ...}, where in the second case, the xi are taken to have values 1, 2, ....
InterpolationOrder
InterpolationOrder -> n
specifies interpolating polynomials of order n.
Interrupt
Interrupt[ ]
generates an interrupt.
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[{a,b}, {c,d}, ...]
represents the union of the ranges a to b, c to d, ....
IntervalIntersection
IntervalIntersection[int1, int2, ...]
gives an interval representing the intersection of the intervals int1, int2, ....
IntervalMemberQ
IntervalMemberQ[int, x]
gives True if the number x in in the interval int, False otherwise. IntervalMemberQ[int1, int2]
gives True if the interval int2 is contained within the interval int1.
IntervalUnion
IntervalUnion[int1, int2, ...]
gives an interval representing the union of the intervals int1, int2, ....
Inverse
Inverse[m]
gives the inverse of a square matrix m.
InverseFourier
InverseFourier[list]
finds the discrete inverse Fourier transform of a list of complex numbers.
InverseFunction
InverseFunction[f]
represents the inverse of the function f, defined so that InverseFunction[f]
[y] gives the value of x for which f[x]
is equal to y. For a function with several arguments, InverseFunction[f]
represents the inverse with respect to the first argument. InverseFunction[f, n]
represents the inverse with respect to the nth argument. InverseFunction[f, n, tot]
represents the inverse with respect to the nth argument when there are tot arguments in all.
InverseFunctions
InverseFunctions -> True
, inverse functions are used if necessary. With InverseFunctions -> False
, they are never used. InverseFunctions -> Automatic
uses inverse functions if necessary and prints a warning message.
InverseJacobiCD
InverseJacobiCD[v, m]
gives the inverse of the Jacobi elliptic function cd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K.
InverseJacobiCN
InverseJacobiCN[v, m]
gives the inverse of the Jacobi elliptic function cn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K.
InverseJacobiCS
InverseJacobiCS[v, m]
gives the inverse of the Jacobi elliptic function cs at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K.
InverseJacobiDC
InverseJacobiDC[v, m]
gives the inverse of the Jacobi elliptic function dc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'.
InverseJacobiDN
InverseJacobiDN[v, m]
gives the inverse of the Jacobi elliptic function dn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'.
InverseJacobiDS
InverseJacobiDS[v, m]
gives the inverse of the Jacobi elliptic function ds at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at K + I K'.
InverseJacobiNC
InverseJacobiNC[v, m]
gives the inverse of the Jacobi elliptic function nc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'.
InverseJacobiND
InverseJacobiND[v, m]
gives the inverse of the Jacobi elliptic function nd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'.
InverseJacobiNS
InverseJacobiNS[v, m]
gives the inverse of the Jacobi elliptic function ns at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at I K'.
InverseJacobiSC
InverseJacobiSC[v, m]
gives the inverse of the Jacobi elliptic function sc at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0.
InverseJacobiSD
InverseJacobiSD[v, m]
gives the inverse of the Jacobi elliptic function sd at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0.
InverseJacobiSN
InverseJacobiSN[v, m]
gives the inverse of the Jacobi elliptic function sn at v for the parameter m. The result will be in the parallelogram with sides 2K and 2I K' centered at 0.
InverseSeries
InverseSeries[s]
takes the series s generated by Series, and gives a series for the inverse of the function represented by s. InverseSeries[s, y]
gives the inverse series in terms of the variable y.
InverseWeierstrassP
InverseWeierstrassP[{P, P'}, g2, g3]
gives a value of u such that P = WeierstrassP[u, g2, g3]
and P' = WeierstrassPPrime[u, g2, g3]
. Note that P and P' are not independent. No attempt is made to ensure that the result is in any particular period parallelogram.
$IterationLimit
JacobiAmplitude
JacobiAmplitude[u, m]
gives the amplitude for Jacobi elliptic functions.
Jacobian
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 at u for the parameter m.
JacobiCN
JacobiCN[u, m]
gives the Jacobi elliptic function cn at u for the parameter m.
JacobiCS
JacobiCS[u, m]
gives the Jacobi elliptic function cs at u for the parameter m.
JacobiDC
JacobiDC[u, m]
gives the Jacobi elliptic function dc at u for the parameter m.
JacobiDN
JacobiDN[u, m]
gives the Jacobi elliptic function dn at u for the parameter m.
JacobiDS
JacobiDS[u, m]
gives the Jacobi elliptic function ds at u for the parameter m.
JacobiNC
JacobiNC[u, m]
gives the Jacobi elliptic function nc at u for the parameter m.
JacobiND
JacobiND[u, m]
gives the Jacobi elliptic function nd at u for the parameter m.
JacobiNS
JacobiNS[u, m]
gives the Jacobi elliptic function ns at u for the parameter m.
JacobiP
JacobiP[n, a, b, x]
gives the nth Jacobi polynomial.
JacobiSC
JacobiSC[u, m]
gives the Jacobi elliptic function sc at u for the parameter m.
JacobiSD
JacobiSD[u, m]
gives the Jacobi elliptic function sd at u for the parameter m.
JacobiSN
JacobiSN[u, m]
gives the Jacobi elliptic function sn at u for the parameter m.
JacobiSymbol
JacobiSymbol[n, m]
gives the Jacobi symbol of n and m.
JacobiZeta
JacobiZeta[phi, m]
gives Jacobi's Zeta function Z(phi|m).
Join
Join[list1, list2, ...]
concatenates lists together. Join can be used on any set of expressions that have the same head.
JordanDecomposition
JordanDecomposition[A]
returns { S, J }, where A = S . J . Inverse[S]
and J is the Jordan canonical form of A. All entries of A must have infinite precision.
Label
Label[tag]
represents a point in a compound expression to which control can be transferred using Goto.
LaguerreL
LaguerreL[n, x]
gives the nth Laguerre polynomial. LaguerreL[n, a, x]
gives the nth generalized Laguerre polynomial.
$Language
LaserPrint
Last
Last[expr]
gives the last element in expr.
LatticeReduce
LatticeReduce[{v1, v2, ...}]
gives a reduced basis for the set of integer vectors vi.
Launch
LinkMode->Launch
causes a link to be created by launching another program.
LCM
LCM[n1, n2, ...]
gives the least common multiple of the integers ni.
LeafCount
LeafCount[expr]
gives the total number of indivisible subexpressions in expr.
Left
LegendreP
LegendreP[n, x]
gives the nth Legendre polynomial. LegendreP[n, m, x]
gives the associated Legendre polynomial.
LegendreQ
LegendreQ[n, z]
gives the nth Legendre function of the second kind. LegendreQ[n, m, z]
gives the associated Legendre function of the second kind.
LegendreType
LegendreType -> Complex
, there is a branch cut from -Infinity to +1. With LegendreType -> Real
, there are branch cuts from -Infinity to -1 and from +1 to +Infinity.
Length
Length[expr]
gives the number of elements in expr.
LerchPhi
LerchPhi[z, s, a]
gives the Lerch transcendent Phi(z, s, a).
Less
LessEqual
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 non-decreasing sequence.
LetterQ
LetterQ[string]
yields True if all the characters in the string are letters, and yields False otherwise.
$Letters
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 list of subexpressions.
Lighting
Lighting -> True
, simulated illumination is used; with Lighting -> False
, it is not.
LightSources
Limit
Limit[expr, x->x0
]
finds the limiting value of expr when x approaches x0.
$Line
Line
Line[{pt1, pt2, ...}]
is a graphics primitive which represents a line joining a sequence of points.
LinearProgramming
LinearProgramming[c, m, b]
finds the vector x which minimizes the quantity c.x subject to the constraints m.x >= b and x >= 0.
LinearSolve
LinearSolve[m, b]
gives the vector x which solves the matrix equation m.x==b.
LineBreak
LineBreak[n]
is output between the nth and (n+1)th lines in a multiline printed expression.
LineForm
LineForm[g]
is a three-dimensional graphics directive that specifies that lines are to be drawn with the graphics directive g or the list of graphics directives g.
LinkClose
LinkClose[link]
closes a previously opened MathLink connection.
LinkConnect
LinkConnect[link]
connects an unconnected link.
LinkConnectedQ
LinkConnectedQ[link]
checks if link is connected to another process.
$Linked
LinkError
LinkError[link]
returns error information for link in the form { errorNumber, errorExplanation }.
LinkFlush
LinkFlush[link]
transmits immediately any locally buffered outgoing expressions.
LinkHost
LinkInterrupt
LinkInterrupt[link]
sends an interrupt message to an external program over MathLink.
LinkMode
LinkObject
LinkOpen
LinkOpen["command"]
returns a MathLink connection to the external program command.
LinkPatterns
LinkPatterns[link]
gives the list of patterns defined in the external package which is accessed via the specified link.
LinkProtocol
LinkRead
LinkRead[link]
reads an expression via MathLink from link.
LinkReadHeld
LinkReadHeld[link]
reads an expression via MathLink from link and returns it wrapped in Hold.
LinkReadyQ
LinkReadyQ[link]
returns True if the link has incoming data ready to be read by LinkRead.
Links
Links[]
returns a list of all active MathLinks.
$LinkSupported
LinkWrite
LinkWrite[link, expr, (flush:True)]
writes expr via MathLink to link (synchronizing unless flush is False).
LinkWriteHeld
LinkWriteHeld[link, Hold[expr]
, (flush:True)] writes expr (without the Hold) via MathLink to link (synchronizing unless flush is False).
List
Listable
ListContourPlot
ListContourPlot[array]
generates a contour plot from an array of height values.
ListDensityPlot
ListDensityPlot[array]
generates a density plot from an array of height values.
Listen
LinkMode->Listen
causes a link to be created that listens on a named port for an incoming connection request.
ListPlay
ListPlay[{a1, a2, ...}]
plays a sound whose amplitude is given by the sequence of levels ai.
ListPlot
ListPlot[{y1, y2, ...}]
plots a list of values. The x coordinates for each point are taken to be 1, 2, .... ListPlot[{{x1, y1}, {x2, y2}, ...}]
plots a list of values with specified x and y coordinates.
ListPlot3D
ListPlot3D[array]
generates a three-dimensional plot of a surface representing an array of height values. ListPlot3D[array, shades]
generates a plot with each element of the surface shaded according to the specification in shades.
ListQ
ListQ[expr]
gives True if expr is a list, and False otherwise.
Literal
Literal[expr]
is equivalent to expr for pattern matching, but maintains expr in an unevaluated form.
Locked
Log
Log[z]
gives the natural logarithm of z (logarithm to base E). Log[b, z]
gives the logarithm to base b.
LogGamma
LogGamma[z]
is the logarithm of the Euler gamma function Gamma(z). LogGamma[z]
is different from Log[Gamma[z]
] in that it has a single branch cut along the negative real axis.
LogicalExpand
LogicalExpand[expr]
expands out expressions containing logical connectives such as && and ||.
LogIntegral
LogIntegral[z]
is the logarithmic integral function li(z).
LowerCaseQ
LowerCaseQ[string]
yields True if all the characters in the string are lower-case letters, and yields False otherwise.
LUBackSubstitution
LUBackSubstitution[factor, b]
yields the solution to the linear system A . x == b, where factor is the output of LUDecomposition[A]
.
LUDecomposition
LUDecomposition[m]
yields the LU decomposition for a square numerical matrix m. The result is a matrix and a permutation vector to be interpreted by LUBackSubstitution[]
.
$MachineEpsilon
$MachineID
MachineID
$MachineName
MachineName
MachineNumberQ
MachineNumberQ[x]
returns True if x is a machine floating point number, and returns False otherwise.
$MachinePrecision
$MachineType
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.
MakeRules
MakeRules -> True
, the result is presented as an AlgebraicRulesData object. With MakeRules -> False
, the result is presented as a list of rules.
MantissaExponent
MantissaExponent[x]
gives a list containing the mantissa and exponent of an approximate real number x.
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.
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.
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, levspec]
applies f to all parts of expr on levels specified by levspec.
MapThread
MapThread[f, {{a1, a2, ...}, {b1, b2, ...}, ...}]
gives {f[a1, b1, ...]
, f[a2, b2, ...]
, ...}. MapThread[f, {xa, xb, ...}, n]
maps f over the nth level of the n-dimensional tensors xa, xb, ... .
MatchBox
MatchLocalNameQ
MatchLocalNames
MatchLocalNames -> True
, symbols such as x match symbols with local names of the form x$nnn. With MatchLocalNames -> False
, they do not.
MatchQ
MatchQ[expr, form]
returns True if the pattern form matches expr, and returns False otherwise.
MatrixExp
MatrixExp[mat]
gives the matrix exponential of mat.
MatrixForm
MatrixForm[list]
prints with the elements of list arranged in a regular array.
MatrixPower
MatrixPower[mat, n]
gives the nth matrix power of mat.
MatrixQ
MatrixQ[expr]
gives True if expr is a list of lists 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.
Max
Max[x1, x2, ...]
yields the numerically largest of the xi. Max[{x1, x2, ...}, {y1, ...}, ...]
yields the largest element of any of the lists.
MaxBend
MaxBend -> n
specifies the maximum bend as n degrees.
MaxIterations
MaxIterations -> n
, a maximum of n iterations is used.
$MaxMachineNumber
MaxMemoryUsed
MaxMemoryUsed[ ]
gives the maximum number of bytes used to store all data for the current Mathematica session.
$MaxNumber
$MaxPrecision
MaxRecursion
MaxRecursion -> n
, the maximum depth to which recursion is allowed to go is n even if convergence is not yet achieved.
MaxSteps
MaxSteps -> n
, the maximum number of steps taken is n.
MaxStepSize
$$Media
Streams[ ]
.
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.
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.
MemoryInUse
MemoryInUse[ ]
gives the number of bytes currently being used to store all data in the current Mathematica session.
Mesh
Mesh -> True
, an explicit x-y mesh is drawn; with Mesh -> False
, no mesh is drawn.
MeshRange
MeshRange -> Automatic
uses integers determined by indices in the array.
MeshStyle
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.
$MessageList
HoldForm[ ]
. $MessageList is saved in MessageList[n]
and reset to { } after the nth output line is generated.
MessageList
MessageList[n]
is a global object assigned to be a list of the names of messages generated during the processing of the nth input line.
MessageName
MessageName[symbol, "tag"]
) is a name for a message.
MessagePacket
$MessagePrePrint
$Messages
Messages
Messages[symbol]
gives all the messages assigned to a particular symbol.
MetaCharacters
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 -> {"\\", ".", "*"}.
Method
Min
Min[x1, x2, ...]
yields the numerically smallest of the xi. Min[{x1, x2, ...}, {y1, ...}, ...]
yields the smallest element of any of the lists.
$MinMachineNumber
$MinNumber
Minors
Minors[m, k]
gives a matrix consisting of the determinants of all k X k submatrices of m.
$MinPrecision
MinRecursion
MinRecursion -> n
, a minimum depth of recursion of n is used before tests for convergence begin.
Minus
Mod
Mod[m, n]
gives the remainder on division of m by n. The result has the same sign as n.
Mode
Modular
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, ....
$ModuleNumber
Unique[ ]
or Module[ ]
.
Modulus
Modulus -> n
specifies that numbers should be treated modulo n. Modulus -> 0
specifies that the full ring of integers should be used.
MoebiusMu
MoebiusMu[n]
gives the Moebius function mu(n).
$MotifAnimationFunction
MultiDimensional
Method -> MultiDimensional
causes a multi-dimensional algorithm to be used. Method -> MultiDimensional
is only valid for integration in two or more dimensions.
Multinomial
Multinomial[n1, n2, ...]
gives the multinomial coefficient (n1+n2+...)!/(n1! n2! ...).
Multiplicity
Multiplicity -> n
specifies that the multiplicity of each of the roots is n in the final result.
N
N[expr]
gives the numerical value of expr. N[expr, n]
does computations to n-digit precision.
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 which match the string. Names["string", SpellingCorrection->True
]
includes names which match after spelling correction.
NBernoulliB
NBernoulliB[n]
gives the numerical value of the nth Bernoulli number. NBernoulliB[n, d]
gives the result to d-digit precision.
NDSolve
NDSolve[eqns, y, {x, xmin, xmax}]
finds a numerical solution to the differential equations eqns for the function y with the independent variable x in the range xmin to xmax. NDSolve[eqns, {y1, y2, ...}, {x, xmin, xmax}]
finds numerical solutions for the functions yi. NDSolve[eqns, y, {x, x1, x2, ...}]
forces a function evaluation at each of x1, x2, ... The range of numerical integration is from Min[x1, x2, ...]
to Max[x1, x2, ...]
.
Needs
Needs["context`", "file"]
loads file if the specified context is not already in $Packages. Needs["context`"]
loads the file specified by ContextToFilename["context`"]
if the specified context is not already in $Packages.
Negative
Negative[x]
gives True if x is a negative number.
Nest
Nest[f, expr, n]
gives an expression with f applied n times to expr.
NestList
NestList[f, expr, n]
gives a list of the results of applying f to expr 0 through n times.
$NewMessage
$NewSymbol
NIntegrate
NIntegrate[f, {x, xmin, xmax}]
gives a numerical approximation to the integral of f with respect to x over the interval xmin to xmax.
NModule
NModule[{x, y, ...}, expr, prec]
specifies that occurrences of the symbols x, y, ... in expr should be treated as local and that all local arithmetic is fixed precision and is to be done to prec digits. NModule[{x, y, ...}, expr, {minprec, maxprec}]
bounds the local arithmetic to be between minprec and maxprec.
NonAssociative
NonCommutativeMultiply
NonConstants
None
NonNegative
NonNegative[x]
gives True if x is a non-negative number.
Normal
Normal[expr]
converts expr to a normal expression, from a variety of special forms.
Not
$Notebooks
NProduct
NProduct[f, {i, imin, imax}]
gives a numerical approximation to the product of f with i running from imin to imax. NProduct[f, {i, imin, imax, di}]
uses a step di in the product.
NProductExtraFactors
NProductExtraFactors -> n
uses n factors in the extrapolation process. NProductExtraFactors must be greater than twice WynnDegree.
NProductFactors
NProductFactors -> n
explicitly includes n factors in the product before extrapolation.
NProtectedAll
N[ ]
.
NProtectedFirst
N[ ]
.
NProtectedRest
N[ ]
.
NRoots
NRoots[lhs==rhs, var]
gives a list of numerical approximations to the roots of a polynomial equation.
NSolve
NSolve[eqns, vars]
attempts to solve numerically an equation or set of equations for the variables vars. Any variable in eqns but not vars is regarded as a parameter. NSolve[eqns]
treats all variables encountered as vars above. NSolve[eqns, vars, prec]
attempts to solve numerically the equations for vars using prec digits precision.
NSum
NSum[f, {i, imin, imax}]
gives a numerical approximation to the sum of f with i running from imin to imax. NSum[f, {i, imin, imax, di}]
uses a step di in the sum. NSum[f, {i, imin, imax}, {j, jmin, jmax}, ...]
gives a multi-dimensional summation.
NSumExtraTerms
NSumExtraTerms -> n
uses n terms in the extrapolation process. NSumExtraTerms must be greater than twice WynnDegree.
NSumTerms
NSumTerms -> n
explicitly includes n terms in the sum before extrapolation.
Null
NullRecords
NullRecords -> True
, null records are taken to exist between repeated record separators. With NullRecords -> False
, repeated record separators are treated like single record separators.
NullSpace
NullSpace[m]
gives a list of vectors that forms a basis for the null space of the matrix m.
NullWords
NullWords -> True
, null words are taken to exist between repeated word separators. With NullWords -> False
, repeated word separators are treated like single word separators.
Number
$NumberBits
NumberBits[x]
gives a list containing the sign, a list of the bits thought to be correct, a list of the bits not thought to be correct, and the binary exponent. The number x must have a head of Real.
NumberForm
NumberForm[expr, n]
prints with approximate real numbers in expr given to n-digit precision.
NumberFormat
NumberFormat -> f
, the function f is supplied with three arguments: the mantissa, base and exponent of each number to be printed. The function f must return the final format for the number. The default NumberFormat -> Automatic
chooses a format automatically.
NumberPadding
NumberPoint
NumberQ
NumberQ[expr]
gives True if expr is a number, and False otherwise.
NumberSeparator
NumberSigns
Numerator
Numerator[expr]
gives the numerator of expr.
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.
O
O[x]
^n represents a term of order x^n. 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.
OddQ
OddQ[expr]
gives True if expr is an odd integer, and False otherwise.
$Off
Off
Off[symbol::tag]
switches off a message, so that it is no longer printed. Off[s]
switches off tracing messages associated with the symbol s. Off[m1, m2, ...]
switches off several messages. Off[ ]
switches off all tracing messages.
On
On[symbol::tag]
switches on a message, so that it can be printed. On[s]
switches on tracing for the symbol s. On[m1, m2, ...]
switches on several messages. On[ ]
switches on tracing for all symbols.
OneIdentity
f[x]
, f[f[x]
], etc. are all equivalent to x for the purpose of pattern matching.
OneStepRowReduction
Method -> OneStepRowReduction
causes matrix entries created in the process of Gaussian elimination (row reduction) of a matrix to be divided by the previous pivot. This is always an exact (remainder-free) division. Prior to starting the reduction, denominators are cleared in each row of the matrix.
OpenAppend
OpenAppend["file"]
opens a file to append output to it, and returns an OutputStream object.
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.
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.
$OperatingSystem
Optional
OptionQ
OptionQ[e]
returns True if e can be considered an option or list of options, and False otherwise.
Options
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]
or Options["sname"]
gives options associated with a particular stream. Options[expr, name]
gives the setting for the option name in an expression. Options[expr, {name1, name2, ...}]
gives a list of the settings for the options namei.
Or
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.
OrderedQ
OrderedQ[h[e1, e2, ...]
] gives True if the ei are in canonical order, and False otherwise.
Orderless
f[e1, e2, ...]
should automatically be sorted into canonical order. This property is accounted for in pattern matching.
Out
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.
$Output
OutputForm
OutputForm[expr]
prints as the standard Mathematica output form for expr.
$OutputForms
OutputNamePacket
OutputStream
OutputStream["name", n]
is an object that represents an output stream for functions such as Write.
Overflow
Overflow[]
is the result of a numerical calculation whose result is too large to represent.
Overlaps
Overlaps -> True
, substrings that overlap are included; with Overlaps -> False
, they are not.
OwnValues
OwnValues[f]
gives a list of transformation rules corresponding to all ownvalues (values for f itself) defined for the symbol f.
$Packages
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.
PageHeight
PageHeight -> n
specifies that n lines of text should be printed between page breaks. With PageHeight -> Infinity
, there are no page breaks.
PageWidth
PageWidth -> n
specifies that each line of printed text can be n characters. With PageWidth -> Infinity
, individual lines can be arbitrarily long.
ParametricPlot
ParametricPlot[{fx, fy}, {t, tmin, tmax}]
produces a parametric plot with x and y coordinates fx and fy generated as a function of t. ParametricPlot[{{fx, fy}, {gx, gy}, ...}, {t, tmin, tmax}]
plots several parametric curves.
ParametricPlot3D
ParametricPlot3D[{fx, fy, fz}, {t, tmin, tmax}]
produces a three-dimensional space curve parameterized by a variable t which runs from tmin to tmax. ParametricPlot3D[{fx, fy, fz}, {t, tmin, tmax}, {u, umin, umax}]
produces a three-dimensional surface parametrized by t and u. ParametricPlot3D[{fx, fy, fz, s}, ...]
shades the plot according to the color specification s. ParametricPlot3D[{{fx, fy, fz}, {gx, gy, gz}, ...}, ...]
plots several objects together.
ParentConnect
ParentDirectory
ParentDirectory[ ]
gives the parent of the current working directory. ParentDirectory["dir"]
gives the parent of the directory dir.
$ParentLink
Part
expr[[i]
] or Part[expr, i]
gives the ith part of expr. expr[[-i]
] counts from the end. expr[[0]
] gives the head of expr. 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.
Partition
Partition[list, n]
partitions list into non-overlapping sublists of length n. Partition[list, n, d]
generates sublists with offset d. Partition[list, {n1, n2, ...}, {d1, d2, ...}]
partitions successive levels in list into length ni sublists with offsets di.
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.
$Path
$PathnameSeparator
Pattern
PatternTest
Pause
Pause[n]
pauses for at least n seconds.
Permutations
Permutations[list]
generates a list of all possible permutations of the elements in list.
Pi
$PipeSupported
Pivoting
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.
Plain
Play
Play[f, {t, tmin, tmax}]
plays a sound whose amplitude is given by f as a function of time t in seconds between tmin and tmax.
PlayRange
PlayRange -> All
, all sound amplitude levels are included. PlayRange -> {amin, amax} specifies an explicit amplitude range. PlayRange -> Automatic
drops outlying amplitude levels.
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.
PlotColor
PlotDivision
PlotDivision -> n
specifies that a maximum of n subdivisions should be used in attempting to generate a smooth curve.
PlotJoined
PlotJoined -> True
, the points plotted are joined by a line. With PlotJoined -> False
, they are not.
PlotLabel
PlotLabel -> None
, no label is given. PlotLabel -> label
specifies a label.
PlotPoints
PlotPoints -> n
uses a total of n sample points. With two variables, PlotPoints -> n
specifies that n points should be used in both the x and y directions, and PlotPoints -> {nx, ny} specifies different numbers of sample points for the two directions.
PlotRange
PlotRange -> All
, all points are included in the plot. With PlotRange -> Automatic
, outlying points are dropped. PlotRange -> {min, max} specifies explicit limits for y (2D) or z (3D). PlotRange -> {{xmin, xmax}, ... } gives explicit limits for each coordinate.
PlotRegion
PlotRegion -> Automatic
, the plot fills the final display area.
PlotStyle
PlotStyle -> style
specifies that all lines or points are to be generated with the specified graphics directive, or list of graphics directives. PlotStyle -> {{style1}, {style2}, ... } specifies that successive lines generated should use graphics directives style1, style2, ... .
Plot3D
Plot3D[f, {x, xmin, xmax}, {y, ymin, ymax}]
generates a three-dimensional plot of f as a function of x and y. Plot3D[{f, s}, {x, xmin, xmax}, {y, ymin, ymax}]
generates a three-dimensional plot in which the height of the surface is specified by f, and the shading is specified by s.
Plot3Matrix
Plus
Pochhammer
Pochhammer[a, n]
gives the Pochhammer symbol.
Point
Point[coords]
is a graphics primitive that represents a point.
PointForm
PointForm[g]
is a three-dimensional graphics directive that specifies that points are to be drawn with the graphics directive g or the list of graphics directives g.
PointSize
PointSize[r]
is a graphics directive which specifies that points which follow are to be shown if possible as circular regions with radius r. The radius r is given as a fraction of the total width of the graph.
PolyGamma
PolyGamma[z]
gives the digamma function psi(z). PolyGamma[n, z]
gives nth derivative of the digamma function.
Polygon
Polygon[{pt1, pt2, ...}]
is a graphics primitive that represents a filled polygon.
PolygonIntersections
PolygonIntersections -> True
, intersecting polygons are left unchanged. With PolygonIntersections -> False
, Graphics3D objects are modified by breaking polygons into smaller pieces which do not intersect each other.
PolyLog
PolyLog[n, z]
gives the nth polylogarithm function of z.
PolynomialDivision
PolynomialDivision[p, q, x]
gives a list of the quotient and remainder obtained by division of the polynomials p and q in x.
PolynomialGCD
PolynomialGCD[poly1, poly2, ...]
gives the greatest common divisor of the polynomials poly1, poly2, ... . PolynomialGCD[poly1, poly2, ..., Modulus->p
]
gives the GCD modulo the prime p.
PolynomialLCM
PolynomialLCM[poly1, poly2, ...]
gives the least common multiple of the polynomials poly1, poly2, ... . PolynomialLCM[poly1, poly2, ..., Modulus->p
]
gives 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.
PolynomialRemainder
PolynomialRemainder[p, q, x]
gives the remainder from dividing p by q, treated as polynomials in x.
Position
Position[expr, pattern]
gives a list of the positions at which objects matching pattern appear in expr. Position[expr, pattern, levspec]
finds only objects that appear on levels specified by levspec.
Positive
Positive[x]
gives True if x is a positive number.
$Post
Postfix
Postfix[f[expr]
] prints with f[expr]
given in default postfix form: expr // f. Postfix[f[expr]
, h] prints as exprh.
PostScript
PostScript["string1", "string2", ...]
is a graphics primitive which specifies PostScript code to include verbatim in graphics output.
Power
PowerExpand
PowerExpand[expr]
expands nested powers, powers of products, logarithms of powers, and logarithms of products. PowerExpand[expr, {x1, x2, ...}]
expands expr with respect to the x1. Use PowerExpand with caution because PowerExpand does not pay attention to branch cuts.
PowerMod
PowerMod[a, b, n]
gives Mod[a^b, n]
. For negative b, PowerMod[a, b, n]
gives modular inverses.
$Pre
PrecedenceForm
PrecedenceForm[expr, prec]
prints with expr parenthesized as it would be if it contained an operator with precedence prec.
Precision
Precision[x]
gives the number of digits of precision in the number x.
PrecisionGoal
PrecisionGoal -> Automatic
yields a precision goal equal to 10 digits less than the setting for WorkingPrecision. With PrecisionGoal -> Infinity
, precision is not used as the criterion for terminating the numerical procedure. Even though you may specify PrecisionGoal -> n
, the results you get may have much less than n-digit precision.
PreDecrement
Prefix
Prefix[f[expr]
] prints with f[expr]
given in default prefix form: f @ expr. Prefix[f[expr]
, h] prints as hexpr.
PreIncrement
Prepend
Prepend[expr, elem]
gives expr with elem prepended.
PrependTo
PrependTo[s, elem]
prepends elem to the value of s, and resets s to the result.
$PrePrint
$PreRead
Prime
Prime[n]
gives the nth prime number.
PrimePi
PrimePi[x]
gives the number of primes less than or equal to x.
PrimeQ
PrimeQ[expr]
yields True if expr is a prime number, and yields False otherwise. In the current version of Mathematica, the algorithm used for large integers is probabilistic, but very reliable (pseudoprime test and Lucas test).
Print
Print[expr1, expr2, ...]
prints the expri, followed by a newline (line feed).
PrintForm
PrintForm[expr]
returns the internal printform representation of expr.
$PrintForms
$PrintLiteral
Product
Product[f, {i, imax}]
evaluates the product of f with i running from 1 to imax. Product[f, {i, imin, imax}]
starts with i = imin. Product[f, {i, imin, imax, di}]
uses steps di. Product[f, {i, imin, imax}, {j, jmin, jmax}, ...]
evaluates a multiple product.
Prolog
PromptForm
PromptForm[prompt,expr]
prints as an output prompt and expression.
Protect
Protect[s1, s2, ...]
sets the attribute Protected for the symbols si. Protect["form1", "form2", ...]
protects all symbols whose names match any of the string patterns formi.
Protected
PseudoInverse
PseudoInverse[m]
finds the pseudoinverse of a rectangular matrix.
PSPrint
PSPrint[-graphics-]
sends graphics to a printer.
Put
Put[expr1, expr2, ..., "filename"]
writes a sequence of expressions expri to a file.
PutAppend
PutAppend[expr1, expr2, ..., "filename"]
appends a sequence of expressions expri to a file.
QRDecomposition
QRDecomposition[m]
yields the QR decomposition for a numerical matrix m. The result is a list {q, r}, where q is an orthogonal matrix, r is an upper triangular matrix, and m can be written as Conjugate[Transpose[q]
].r.
Quartics
Quartics -> True
, explicit solutions are generated for irreducible quartic equations. With Quartics -> False
, they are not.
Quit
Quit[ ]
terminates a Mathematica session.
Quotient
Quotient[n, m]
gives the integer quotient of n and m, defined as Floor[n/m]
.
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}.
$RandomState
Range
Range[imax]
generates the list {1, 2, ..., imax}. Range[imin, imax]
generates the list {imin, ..., imax}. Range[imin, imax, di]
uses step di.
Raster
Raster[{{a11, a12, ...}, ...}]
is a two-dimensional graphics primitive which represents a rectangular array of gray cells.
RasterArray
RasterArray[{{g11, g12, ...}, ...}]
is a two-dimensional graphics primitive which represents a rectangular array of cells colored according to the graphics directives gij.
$RasterFunction
Rational
Rationalize
Rationalize[x]
takes Real numbers in x that are close to rationals, and converts them to exact Rational numbers. Rationalize[x, dx]
performs the conversion whenever the error made is smaller in magnitude than dx.
Raw
Raw[h, "hexstring"]
constructs a raw data object with head h, and with contents corresponding to the binary bit pattern represented by the string hexstring, interpreted as a hexadecimal number.
RawMedium
Re
Re[z]
gives the real part of the complex number z.
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.
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
Real
RealBlockForm
RealDigits
RealDigits[x]
gives a list of the digits in the approximate real number x, together with the number of digits that appear to the left of the decimal point in scientific notation. RealDigits[x, b]
gives a list of base-b digits in x.
RealInterval
Record
RecordLists
RecordLists -> True
, ReadList returns a list containing a sublist for each separate record it reads. With RecordLists -> False
, ReadList returns a single list of all objects it reads.
RecordSeparators
Rectangle
Rectangle[{xmin, ymin}, {xmax, ymax}]
is a two-dimensional graphics primitive that represents a filled rectangle, oriented parallel to the axes. Rectangle[{xmin, ymin}, {xmax, ymax}, graphics]
gives a rectangle filled with the specified graphics.
$RecursionLimit
Reduce
Reduce[eqns, vars]
simplifies the equations eqns, attempting to solve for the variables vars. The equations generated by Reduce are equivalent to eqns, and contain all the possible solutions. Any variable in eqns but not vars is regarded as a parameter. Reduce[eqns]
treats all variables encountered as vars above. Reduce[eqns, vars, elims]
simplifies the equations, trying to eliminate the variables elims.
Reinstall
Reinstall[link]
un-installs the specified external package and installs it again.
Release
f[..., Release[expr]
, ...] is equivalent to f[..., Evaluate[expr]
, ...], which evaluates expr even if f would otherwise Hold expr in that position. Evaluation of Release[expr]
removes the outer Hold from expr, or from its head and arguments; the similar function ReleaseHold is recommended.
ReleaseHold
ReleaseHold[expr]
removes Hold and HoldForm in expr.
$ReleaseNumber
$Remote
Remove
Remove[symbol1, ...]
removes symbols completely, so that their names are no longer recognized by Mathematica. Remove["form1", "form2", ...]
removes all symbols whose names match any of the string patterns formi.
Removed
Removed[string]
is printed to indicated a symbol that has been removed.
RenameDirectory
RenameDirectory["dir1", "dir2"]
renames the directory dir1 to dir2.
RenameFile
RenameFile["file1", "file2"]
renames file1 to file2.
RenderAll
RenderAll -> False
, PostScript will be generated only for those polygons or parts of polygons which are visible in the final picture. If RenderAll -> True
, PostScript is generated for all polygons.
Repeated
RepeatedNull
RepeatedString
Replace
Replace[expr, rules]
applies a rule or list of rules in an attempt to transform the entire expression expr.
ReplaceAll
ReplaceHeldPart
ReplaceHeldPart[expr, Hold[new]
, n] yields an expression in which the nth part of expr is replaced by new. ReplaceHeldPart[expr, Hold[new]
, {i, j, ...}] replaces the part at position {i, j, ...}. ReplaceHeldPart[expr, Hold[new]
, {{i1, j1, ...}, {i2, j2, ...}, ...}] replaces parts at several positions by new.
ReplacePart
ReplacePart[expr, new, n]
yields an expression in which the nth part of expr is replaced by new. ReplacePart[expr, new, {i, j, ...}]
replaces the part at position {i, j, ...}. ReplacePart[expr, new, {{i1, j1, ...}, {i2, j2, ...}, ...}]
replaces parts at several positions by new.
ReplaceRepeated
ResetDirectory
ResetDirectory[ ]
resets the current working directory to its previous value.
ResetMedium
ResetMedium["file", options]
resets the options associated with a file that is already open. ResetMedium[options]
resets the options for the standard output. It is recommended that you use SetOptions in Version 2.0.
Residue
Residue[expr, {x, x0}]
finds the residue of expr at the point x = x0.
Rest
Rest[expr]
gives expr with the first element removed.
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
Return
Return[expr]
returns the value expr from a function. Return[ ]
returns the value Null.
ReturnExpressionPacket
ReturnPacket
ReturnTextPacket
Reverse
Reverse[expr]
reverses the order of the elements in expr.
RGBColor
RGBColor[red, green, blue]
is a graphics directive which specifies that graphical objects which follow are to be displayed, if possible, in the color given.
RiemannSiegelTheta
RiemannSiegelTheta[t]
gives the analytic function theta(t) which satisfies RiemannSiegelZ[t]
== Exp[I RiemannSiegelTheta[t]
] Zeta[1/2 + I t]
. The argument t need not be real, but if it is, then RiemannSiegelTheta[t]
] == Im[LogGamma[1/4 + I t/2]
] - t Log[Pi]
/2.
RiemannSiegelZ
RiemannSiegelZ[t]
gives the function Exp[I RiemannSiegelTheta[t]
] Zeta[1/2 + I t]
.
Right
Roots
Roots[lhs==rhs, var]
yields a disjunction of equations which represent the roots of a polynomial equation.
RotateLabel
RotateLabel -> True
, labels on vertical frame axes are rotated to be vertical. With RotateLabel -> False
, they are not.
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.
Round
Round[x]
gives the integer closest to x.
Row
RowReduce
RowReduce[m]
gives the row-reduced form of the matrix m.
Rule
lhs -> rhs
represents a rule that transforms lhs to rhs.
RuleCondition
RuleDelayed
RuleForm
RuleTable
Run
Run[expr1, expr2, ...]
generates the printed form of the expressions expri, separated by spaces, and runs it as an external, operating system, command.
RunThrough
RunThrough["command", expr]
executes an external command, giving the printed form of expr as input, and taking the output, reading it as Mathematica input, and returning the result.
SameQ
SameTest
SampleDepth
SampleDepth -> n
specifies that n bits should be used to encode sound amplitude levels.
SampledSoundFunction
SampledSoundFunction[f, n, r]
is a sound primitive, which 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, which represents a sound whose amplitude has levels ai sampled r times a second.
SampleRate
SampleRate -> n
specifies that n samples per second should be used to generate sounds.
Save
Save["filename", symb1, symb2, ...]
appends the definitions of the symbols symbi to a file.
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 in each direction. Scaled[{dx, dy, ...}, {x0, y0, ...}]
gives a position obtained by starting at absolute coordinates {x0, y0, ...}, then moving by a scaled offset {dx, dy, ...}.
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.
SchurDecomposition
SchurDecomposition[m]
yields the Schur decomposition for a numerical matrix m. The result is a list {q, t} where q is an orthogonal matrix and t is a block upper triangular matrix.
ScientificForm
ScientificForm[expr]
prints with all real numbers in expr given in scientific notation.
Sec
Sec[z]
gives the secant of z.
Sech
Sech[z]
gives the hyperbolic secant of z.
Second
SeedRandom
SeedRandom[n]
resets the pseudorandom number generator, using the integer n as a seed. SeedRandom[ ]
resets the generator, using as a seed the time of day.
Select
Select[list, crit]
picks out all elements ei of list for which crit[ei]
is True. Select[list, crit, n]
picks out the first n elements for which crit[ei]
is True.
Sequence
Sequence[e1,e2,...]
is a special form representing a sequence of arguments in an expression.
SequenceForm
SequenceForm[expr1, expr2, ...]
prints as the textual concatenation of the printed forms of the expri.
SequenceLimit
SequenceLimit[list]
returns the approximation given by Wynn's epsilon algorithm to the limit of a sequence whose first few terms are given by list. Warning: Wynn's epsilon algorithm can give finite results for divergent sequences.
Series
Series[f, {x, x0, n}]
generates a power series expansion for f about the point x = x0 to order (x - x0)^n. Series[f, {x, x0, nx}, {y, y0, ny}]
successively finds series expansions with respect to y, then x.
SeriesCoefficient
SeriesCoefficient[s,n]
returns the coefficient of the n-th power of the variable in the series s.
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.
$SessionID
SessionTime
SessionTime[ ]
gives the total number of seconds of real time that have elapsed since the beginning of your Mathematica session.
Set
SetAccuracy
SetAccuracy[expr, n]
yields a version of expr in which all numbers have been set to have an accuracy of n digits.
SetAttributes
SetAttributes[s, attr]
adds attr to the list of attributes of the symbol s.
SetDelayed
SetDirectory
SetDirectory["dir"]
sets the current working directory.
SetFileDate
SetFileDate["file"]
sets the modification date for a file to be the current date. SetFileDate["file", date]
sets the modification date to be the specified date. The date must be given in the {year, month, day, hour, minute, second} format used by Date.
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.
$SetParentLink
SetPrecision
SetPrecision[expr, n]
yields a version of expr in which all numbers have been set to have a precision of n digits.
SetStreamPosition
SetStreamPosition[stream, n]
sets the current point in an open stream.
Shading
Shading -> True
, surfaces are shaded. With Shading -> False
, they are not.
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 which match the pattern form.
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.
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.
Show
Show[graphics, options]
displays two- and three-dimensional graphics, using the options specified. Show[g1, g2, ...]
shows several plots combined. Show can also be used to play Sound objects.
Sign
Sign[x]
gives -1, 0 or 1 depending on whether x is negative, zero, or positive. Sign[z]
gives the sign of the complex number z.
Signature
Signature[list]
gives the signature of the permutation needed to place the elements of list in canonical order.
SignPadding
SignPadding -> True
, padding that is needed is inserted between the sign and the digits in a number. With SignPadding -> False
, the padding is inserted before the sign.
Simplify
Simplify[expr]
performs a sequence of transformations on expr, and returns the simplest form it finds.
SimplifyGamma
SimplifyGamma[expr]
performs a sequence of gamma-function transformations on expr, and returns the simplest form it finds.
SimplifyPolyGamma
SimplifyPolyGamma[expr]
performs a sequence of polygamma-function transformations on expr, and returns the simplest form it finds.
Sin
Sin[z]
gives the sine of z.
SingularityDepth
SingularityDepth -> n
specifies that n recursive subdivisions can be done before a change of variable is used at the endpoints of the interval of integration.
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 nonzero singular values, and m can be written as Conjugate[Transpose[u]
].DiagonalMatrix[w]
.v.
Sinh
Sinh[z]
gives the hyperbolic sine of z.
SinhIntegral
SinhIntegral[x]
gives the hyperbolic sine integral Integrate[Sinh[t]
/t, {t, 0, x}].
SinIntegral
SinIntegral[x]
gives the sine integral Integrate[Sin[t]
/t, {t, 0, x}].
SixJSymbol
SixJSymbol[{j1, j2, j3},{j4, j5, j6}]
gives the values of the Racah 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>>.
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.
Slot
SlotSequence
Socket
SolutionOf
Solve
Solve[eqns, vars]
attempts to solve an equation or set of equations for the variables vars. Any variable in eqns but not vars is regarded as a parameter. Solve[eqns]
treats all variables encountered as vars above. Solve[eqns, vars, elims]
attempts to solve the equations for vars, eliminating the variables elims.
SolveAlways
SolveAlways[eqns, vars]
gives the values of parameters that make the equations eqns valid for all values of the variables vars.
Sort
Sort[list]
sorts the elements of list into canonical order. Sort[list, p]
sorts using the ordering function p.
Sound
Sound[primitives]
represents a sound.
$SoundDisplay
$SoundDisplayFunction
$SoundDisplayTitle
Space
SpaceForm
SpaceForm[n]
prints as n spaces.
SpellingCorrection
SpellingCorrection -> True
, strings are considered to match even when a small fraction of the characters in them are different. SpellingCorrection -> False
requires exact matching.
SphericalHarmonicY
SphericalHarmonicY[l, m, theta, phi]
gives the spherical harmonic Ylm(theta, phi).
SphericalRegion
SphericalRegion -> True
, the final image is scaled so that a sphere drawn around the three-dimensional bounding box will fit in the display area specified. SphericalRegion -> False
scales three-dimensional images to be as large as possible, given the display area specified.
Splice
Splice["file"]
splices Mathematica output into an external file. It takes text enclosed between <* and *> in the file, evaluates the text as Mathematica input, and replaces the text with the resulting Mathematica output.
Sqrt
Sqrt[z]
gives the square root of z.
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.
StackInhibit
StackInhibit[expr]
evaluates expr without modifying the evaluation stack.
StartingStepSize
StartingStepSize -> r
specifies an initial step size of r.
StartProcess
StartProcess["command"]
starts up an external process in which functions can be called from Mathematica. (StartProcess has been superseded by MathLink operations.)
StieltjesGamma
StieltjesGamma[n]
is the nth Stieltjes constant and is related to the Laurent series expansion of Zeta[s]
about s == 1.
StirlingS1
StirlingS1[n, m]
gives the Stirling number of the first kind.
StirlingS2
StirlingS2[n, m]
gives the Stirling number of the second kind.
StreamPosition
StreamPosition[stream]
returns an integer which 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.
String
StringBreak
StringBreak[n]
is output at the end of the nth line where a string is broken.
StringByteCount
StringByteCount["string"]
gives the total number of bytes used to store the characters in a string.
$StringConversion
StringConversion
StringConversion -> None
specifies that all special characters should be output without modification. StringConversion -> Automatic
specifies that all special characters should be output using backslash sequences. StringConversion -> f
specifies that the function f should be applied to convert all strings containing special characters. The default setting is StringConversion :> $StringConversion.
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.
StringForm
StringForm["controlstring", expr1, ...]
prints as the text of the controlstring, with the printed forms of the expri embedded.
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".
StringJoin
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", "pattern"]
yields True if "string" matches the specified string pattern, and yields False otherwise.
$StringOrder
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", "sub", k]
includes only the first k occurrences of "sub". StringPosition["string", {"sub1", "sub2", ...}]
gives positions of all the "subi".
StringQ
StringQ[expr]
gives True if expr is a string, and False otherwise.
StringReplace
StringReplace["string", "s1" -> "sp1"]
or StringReplace["string", {"s1" -> "sp1", "s2" -> "sp2", ...}]
replaces the "si" by "spi" whenever they appear as substrings of "string".
StringReverse
StringReverse["string"]
reverses the order of the characters in "string".
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.
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".
StringToStream
StringToStream["string"]
opens an input stream for reading from a string.
Stub
Subscript
Subscript[expr]
prints expr as a subscript.
Subscripted
Subscripted[f[arg1, arg2, ...]
] prints with the argi given as subscripts of f. Subscripted[expr, sub, sup]
prints with the arguments specified by sub as subscripts, and the arguments specified by sup as superscripts. Arguments not included either in sub or sup are printed in standard functional form. The specification n takes the first n arguments. -n takes the last n arguments. {m, n} takes arguments m through n.
Subtract
SubtractFrom
SubValues
SubValues[f]
gives a list of transformation rules corresponding to all subvalues (values for f[x,..]
[..], etc.) defined for the symbol f.
Sum
Sum[f, {i, imax}]
evaluates the sum of f with i running from 1 to imax. Sum[f, {i, imin, imax}]
starts with i = imin. Sum[f, {i, imin, imax, di}]
uses steps di. Sum[f, {i, imin, imax}, {j, jmin, jmax}, ...]
evaluates a multiple sum.
Superscript
Superscript[expr]
prints expr as a superscript.
$SuppressInputFormHeads
SurfaceColor
SurfaceColor[dcol]
is a three-dimensional graphics directive which specifies that the polygons 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.
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.
SuspendPacket
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
Syntax
$SyntaxHandler
SyntaxLength
SyntaxLength["string"]
finds the number of characters starting at the beginning of a string that correspond to syntactically correct input for a single Mathematica expression.
SyntaxQ
SyntaxQ["string"]
returns True if the string corresponds to syntactically correct input for a single Mathematica expression, and returns False otherwise.
$System
SystemStub
Tab
Table
Table[expr, {imax}]
generates a list of imax 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, imin, imax}, {j, jmin, jmax}, ...]
gives a nested list. The list associated with i is outermost.
TableAlignments
TableAlignments -> Automatic
uses Left for column alignment, and Bottom for row alignment.
TableDepth
TableDepth -> n
prints elements in list below level n as ordinary lists, rather than arranging them in tabular form. With the default setting TableDepth -> Infinity
, as many levels as possible are printed in tabular form.
TableDirections
TableDirections -> Column
specifies that successive dimensions should be arranged alternately as columns and rows, with the first dimension arranged as columns. TableDirections -> Row
takes the first dimension to be arranged as rows. TableDirections -> {dir1, dir2, ... } specifies explicitly whether each dimension should be arranged with Column or Row.
TableForm
TableForm[list]
prints with the elements of list arranged in an array of rectangular cells.
TableHeadings
TableHeadings -> None
gives no labels in any dimension. TableHeadings -> Automatic
gives successive integer labels for each entry in each dimension. TableHeadings -> {{lab11, lab12, ... }, ... } gives explicit labels for each entry.
TableSpacing
TableSpacing -> Automatic
yields spacings {1, 3, 0, 1, 0, 1, ... }.
TagSet
TagSetDelayed
TagUnset
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.
Tan
Tan[z]
gives the tangent of z.
Tanh
Tanh[z]
gives the hyperbolic tangent of z.
TargetFunctions
Temporary
$TemporaryPrefix
OpenTemporary[]
.
TensorRank
TensorRank[expr]
gives the depth to which expr is a full array, with all the parts at a particular level being lists of the same length.
TeXForm
TeXForm[expr]
prints as a TeX language version of expr.
Text
Text[expr, coords]
is a graphics primitive that represents text corresponding to the printed form of expr, centered at the point specified by coords.
TextForm
TextForm[expr]
prints as a textual form of expr.
TextPacket
TextRendering
Thickness
Thickness[r]
is a graphics directive which specifies that lines which follow are to be drawn with a thickness r. The thickness r is given as a fraction of the total width of the graph.
$Thin
ThisLink
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. Thread[f[args]
, h, -n] threads over the last n args. Thread[f[args]
, h, {m, n}] threads over arguments m through n.
ThreeJSymbol
ThreeJSymbol[{j1,m1},{j2,m2},{j3,m3}]
gives the values of the Wigner 3-j symbol. The 3-j symbols vanish except when m1 + m2 + m3 = 0 and the ji satisfy a triangle inequality.
Through
Through[p[f1, f2]
[x]] gives p[f1[x]
, f2[x]
]. Through[expr, h]
performs the transformation wherever h occurs in the head of expr.
$Throw
Throw
Throw[expr]
exits from nested control structures, returning the value expr to the nearest enclosing Catch.
Ticks
Ticks -> None
, no tick marks are drawn on the axes. With Ticks -> Automatic
, tick marks are placed automatically. Ticks -> {xticks, yticks, ... } specifies tick mark options separately for each axis.
TimeConstrained
TimeConstrained[expr, t]
evaluates expr, stopping after t seconds. TimeConstrained[expr, t, failexpr]
returns failexpr if the time constraint is not met.
Times
TimesBy
$TimeUnit
TimeUsed
TimeUsed[ ]
yields the total number of seconds of CPU time used so far in the current Mathematica session.
TimeZone
TimeZone[ ]
gives the time zone set for your computer system.
Timing
Timing[expr]
evaluates expr, and returns a list of time used, together with the result obtained.
ToASCII
ToASCII["c"]
gives the ASCII integer code corresponding to the character c.
ToCharacterCode
ToCharacterCode["string"]
gives a list of the integer codes corresponding to the characters in a string.
ToColor
ToColor[ color, form]
converts color to form if form is GrayLevel, RGBColor or CMYKColor color is converted into it. Otherwise form[ color]
is evaluated and the result is expected to be a valid color directive.
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}.
ToExpression
ToExpression["string"]
gives the expression obtained by taking string as Mathematica input.
Together
Together[expr]
puts terms in a sum over a common denominator, and cancels factors in the result.
ToHeldExpression
ToHeldExpression["string"]
gives the expression obtained by taking string as Mathematica input, enclosed in Hold[]
.
TokenWords
Tolerance
Tolerance -> r
sets a tolerance of r.
ToLowerCase
ToLowerCase[string]
yields a string in which all letters have been converted to lower case.
TooBig
Top
ToRules
ToRules[eqns]
takes logical combinations of equations, in the form generated by Reduce or Roots, and converts them to a sequence of lists of rules where the sequence corresponds to Or and the lists correspond to And. {ToRules[eqns]
} gives a result of the form produced by Solve.
ToString
ToString[expr]
gives a string corresponding to the printed form of expr. Options set the line width, format type, etc.
TotalHeight
TotalHeight -> n
specifies that a maximum of n lines of text should be printed for each output expression. Short forms of expressions are given if the number of lines needed to print the whole expression is too large. TotalHeight -> Infinity
allows expressions of any length to be printed.
TotalWidth
TotalWidth -> n
specifies that a maximum of n characters of text 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. TotalWidth -> Infinity
allows expressions of any length to be printed.
ToUpperCase
ToUpperCase[string]
yields a string in which all letters have been converted to upper case.
Trace
Trace[expr]
generates a list of all expressions used in the evaluation of expr. Trace[expr, form]
includes only those expressions which match form. Trace[expr, s]
includes all evaluations which use transformation rules associated with the symbol s.
TraceAbove
TraceAbove -> True
includes the first and last expressions in all evaluation chains within which the evaluation chain containing form occurs. TraceAbove -> All
includes all expressions in these evaluation chains. TraceAbove -> {backspec, forspec} allows you to specify separately which expressions to include in the backward and forward directions.
TraceAction
TraceBackward
TraceBackward -> True
includes the first expression on the evaluation chain. TraceBackward -> All
includes all expressions on the evaluation chain before the pattern sought.
TraceDepth
TraceDepth -> n
keeps only parts down to level n in nested lists generated by Trace.
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 -> True
includes the final expression on the evaluation chain. TraceForward -> All
includes all expressions on the evaluation chain after the pattern sought.
TraceInternal
TraceLevel
Trace[]
or a related function is being evaluated, TraceLevel[]
returns the level of its output currently being filled.
$TraceOff
TraceOff
TraceOff -> patt
, tracing will be switched off while any expression matching the pattern patt is being evaluated. The default is TraceOn -> None
.
$TraceOn
TraceOn
TraceOn -> patt
, Trace and related functions do not start tracing until they encounter expressions to evaluate which match the pattern patt. The default is TraceOn -> None
.
TraceOriginal
TraceOriginal -> True
, the form of each expression is tested before its head and arguments are evaluated. With TraceOriginal -> False
, it is not.
$TracePattern
$TracePostAction
$TracePreAction
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.
Transpose
Transpose[list]
transposes the first two levels in list. Transpose[list, {n1, n2, ...}]
transposes list so that the nk-th level in list is the k-th level in the result.
Trapezoidal
Method -> Trapezoidal
causes a recursive trapezoidal algorithm to be used. This is particularly useful when the integrand is periodic and the interval of integration is exactly one period. For multi-dimensional integration Trapezoidal refers to a Cartesian product of one dimensional trapezoidal rules.
TreeForm
TreeForm[expr]
prints with different levels in expr shown at different depths.
Trig
Trig -> True
, trigonometric functions are treated as rational functions of exponentials. With Trig -> False
, trigonometric functions are treated as indivisible objects.
True
TrueQ
TrueQ[expr]
yields True if expr is True, and yields False otherwise.
UnAlias
Underflow
Underflow[]
is the result of a numerical calculation whose result is too small to represent.
Unequal
Unevaluated
Unevaluated[expr]
represents the unevaluated form of expr when it appears as the argument to a function.
Uninstall
Uninstall[link]
terminates an external program started by Install, and removes Mathematica 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.
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. Unique[name, {attr1, attr2, ...}]
generates a symbol which has the attributes attri.
Unprotect
Unprotect[s1, s2, ...]
removes the attribute Protected for the symbols si. Unprotect["form1", "form2", ...]
unprotects all symbols whose names textually match any of the formi.
UnsameQ
$Unset
Unset
Update
Update[symbol]
tells Mathematica that hidden changes have been made which could affect values associated with a symbol. Update[ ]
specifies that the value of any symbol could be affected.
UpperCaseQ
UpperCaseQ[string]
yields True if all the characters in the string are upper-case letters, and yields False otherwise.
UpSet
UpSetDelayed
UpValues
UpValues[f]
gives a list of transformation rules corresponding to all upvalues defined for the symbol f.
$Urgent
UseDump
Using
ValueForm
ValueList
ValueQ
ValueQ[expr]
gives True if a value has been defined for expr, and gives False otherwise.
ValueTable
Variables
Variables[expr]
gives a list of all independent variables in a polynomial.
VectorQ
VectorQ[expr]
gives True if expr is a list, 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.
VerifyConvergence
VerifyConvergence -> True
causes the limit of the terms and the limit of the ratio of the terms to be checked in the case of infinite sums and products. With VerifyConvergence -> False
no checking is done.
VerifySolutions
VerifySolutions -> True
, solutions are verified and extraneous solutions are eliminated. With VerifySolutions -> False
, they are not. Note that only those solutions that are obviously extraneous are eliminated.
$Version
$VersionNumber
VerticalForm
ViewCenter
ViewCenter -> Automatic
, the whole bounding box is centered in the final image area. With ViewCenter -> {x, y, z}, the point in the three-dimensional bounding box with scaled coordinates x, y, z is placed at the center of the final display area.
ViewPoint
ViewVertical
WeierstrassP
WeierstrassP[u, g2, g3]
gives the Weierstrass elliptic function P.
WeierstrassPPrime
WeierstrassPPrime[u, g2, g3]
gives the derivative with respect to u of the Weierstrass elliptic function P.
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.
With
With[{x = x0, y = y0, ...}, expr]
specifies that in expr occurrences of the symbols x, y, ... should be replaced by x0, y0, ....
Word
WordSearch
WordSearch -> True
, the text searched for must appear as a word. With WordSearch -> False
, it does not.
WordSeparators
WorkingPrecision
WorkingPrecision -> n
causes all internal computations to be done to at most n-digit precision.
Write
Write[channel, expr1, expr2, ...]
writes the expressions expri in sequence, followed by a newline, to the specified output channel.
WriteString
WriteString[channel, expr1, expr2, ...]
converts the expri to strings, and then writes them in sequence to the specified output channel.
WynnDegree
WynnDegree -> 1
gives Aitken's delta-squared algorithm. WynnDegree is also an option to NSum and NProduct, where it is passed to SequenceLimit for the extrapolation.
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.
ZeroTest
Zeta
Zeta[s]
gives the Riemann zeta function zeta(s). Zeta[s, a]
gives the generalized Riemann zeta function.