Abort

Abort[ ] generates an interrupt to abort a computation.

$Aborted

$Aborted is a special symbol that is returned as the result from a calculation that has been aborted.

AbortProtect

AbortProtect[expr] evaluates expr, saving any aborts until the evaluation is complete, or until CheckAbort is called.

Above

Above is used to specify alignment in printforms such as ColumnForm and TableForm.

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 is an obsolete function, superseded by FoldList. 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 is an option for various numerical operations which specifies how many digits of accuracy should be sought in the final result. The error is considered acceptable and the result is returned when either the AccuracyGoal or the PrecisionGoal is achieved. 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

AlgebraicRulesData is an object returned by AlgebraicRules. Its OutputForm appears to be a list of rules, but the rules will be used algebraically rather than syntactically by Replace and related functions.

Alias

Alias is an obsolete function, superseded by $Pre and $PreRead.

All

All is a setting used for certain options.

Alternatives

p1 | p2 | ... is a pattern object which represents any of the patterns pi.

$AlwaysUsePrivateColorMap

No usage.

AmbientLight

AmbientLight is an option to Graphics3D and related functions that gives the level of simulated ambient illumination in a three-dimensional picture. The setting must be a GrayLevel, Hue, or RGBColor directive.

Analytic

Analytic is an option for Limit and Series. With Analytic -> True, unrecognized functions are treated as analytic, and processed using Taylor series expansions; with Analytic -> False, Taylor series are not used unless the function is recognized as analytic.

AnchoredSearch

AnchoredSearch is an option for Find and FindList. With 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

e1 && e2 && ... is the logical AND function. It evaluates its arguments in order, giving False immediately if any of them are False, and True if they are all True.

$AnimationFunction

No usage.

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 is an option for Show and related functions. With 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

Automatic represents an option value that is to be chosen automatically by a built-in function.

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 is an option for graphics functions. With 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 is an option for 3D graphics functions. AxesEdge -> {{xdir, ydir}, {xdir, zdir}, {xdir, ydir}} specifies on which three edges of the bounding box axes are drawn. The idir must be either +1 or -1, and specify whether axes are drawn on the edge of the box with a larger or smaller value of coordinate i, respectively. Any pair {idir, jdir} can be replaced by Automatic or None. The default setting is AxesEdge -> Automatic.

AxesLabel

AxesLabel is an option for graphics functions. With 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 is an option for two-dimensional graphics functions. AxesOrigin -> {x, y} specifies that the axes drawn should cross at the point {x, y}. AxesOrigin -> Automatic uses an internal algorithm to determine where the axes should cross.

AxesStyle

AxesStyle is an option for graphics functions. 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 is an option for graphics functions which specifies the background color to use. A setting must be a CMYKColor, GrayLevel, Hue or RGBColor directive. The default setting 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

$BatchInput is True if input in the current session is being fed directly to the Mathematica kernel in batch mode.

$BatchOutput

$BatchOutput is True if output in the current session is being sent in batch mode, suitable for reading by other programs.

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

Below is used to specify alignment in printforms such as ColumnForm and TableForm.

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

_ or 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

BlankForm is an internal symbol used for formatting and printing.

BlankNullSequence

___ (three _ characters) or 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

__ (two _ characters) or 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

Bottom is a setting for the TableAlignments option of TableForm.

Boxed

Boxed is an option for Graphics3D. Boxed -> True draws the edges of the bounding box in a three-dimensional picture. With Boxed -> False, no bounding box is drawn.

BoxRatios

BoxRatios is an option for Graphics3D and SurfaceGraphics. BoxRatios -> {rx, ry, rz} gives the ratios of side lengths for the bounding box of the three-dimensional picture. BoxRatios -> Automatic determines the ratios using the range of actual coordinate values in the plot.

BoxStyle

BoxStyle is an option for three-dimensional graphics functions which specifies how the bounding box should be rendered. BoxStyle can be set to a list of graphics directives such as Dashing, Thickness, GrayLevel and RGBColor. BoxStyle -> Automatic uses a default style.

Break

Break[ ] exits the nearest enclosing Do, For or While.

Byte

Byte represents a single byte of data in Read.

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

No usage.

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

Catalan is Catalan's constant, with numerical value 0.915966....

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

Center is used to specify alignment in printforms such as ColumnForm and TableForm.

CForm

CForm[expr] prints as a C language version of expr.

Character

Character represents a single character in Read.

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

No usage.

ClipFill

ClipFill is an option for SurfaceGraphics. With 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

CofactorExpansion is a possible value for the Method option in Inverse, LinearSolve, NullSpace, and RowReduce. 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 is an option for various graphics functions which specifies a function to apply to z values to determine the color to use for a particular x, y region. The arguments provided for the specified function are always in the range 0 to 1. The specified function must return a CMYKColor, GrayLevel, Hue or RGBColor directive. ColorFunction -> Automatic yields a range of gray levels. ColorFunction -> Hue yields a range of colors.

ColorOutput

ColorOutput is an option for graphics functions which specifies the type of color output to produce. 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

Column is a setting for the TableDirections option of TableForm.

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

$CommandLine is a list of strings giving the elements of the original operating system command line with which Mathematica was invoked.

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 is an option for various numerical and plotting functions. With Compiled -> True, expressions they work with are automatically compiled. With Compiled -> False, they are not.

CompiledFunction

Compiled is an option for various numerical and plotting functions. With 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

Complex is the head used for complex numbers.

ComplexExpand

ComplexExpand[expr] expands expr assuming that all variables are real. ComplexExpand[expr, {x1, x2, ...}] expands expr assuming that variables matching any of the xi are complex.

ComplexInfinity

ComplexInfinity represents a quantity with infinite magnitude, but undetermined complex phase.

Compose

Compose is an obsolete function, superseded by Composition. 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

expr1; expr2; ... evaluates the expri in turn, giving the last one as the result.

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

$ConditionHold is an internal symbol.

Conjugate

Conjugate[z] gives the complex conjugate of the complex number z.

Connect

Connect is a setting for the LinkMode option of LinkOpen. LinkMode -> Connect causes a link to be created that will connect to a link listening on a named port.

Constant

Constant is an attribute which indicates zero derivative of a symbol with respect to all parameters.

Constants

Constants is an option for Dt which gives a list of objects to be taken as 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 is a global variable that gives the current context.

Context

Context[ ] gives the current context. Context[symbol] gives the context in which a symbol appears.

$ContextPath

$ContextPath is a global variable that gives a list of contexts, after $Context, to search in trying to find a symbol that has been entered.

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

ContourLevels is an obsolete graphics option, superseded by Contours.

ContourLines

ContourLines is an option for contour plots. With 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 is an option for ContourGraphics specifying the contours to use. 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 is an option for contour plots. With 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 is an option for contour plots. With ContourSmoothing -> False, contour lines are computed using linear interpolation. With ContourSmoothing -> True, cubic interpolation is used.

ContourSpacing

ContourSpacing is an obsolete graphics option, superseded by Contours.

ContourStyle

ContourStyle is an option for contour plots. With 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

$CreationDate gives the date and time at which the particular release of the Mathematica kernel you are running was created.

Csc

Csc[z] gives the cosecant of z.

Csch

Csch[z] gives the hyperbolic cosecant of z.

Cubics

Cubics is an option for Roots and related functions. With 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 is an option for FindRoot, which can be used to control convergence behavior. DampingFactor -> n uses a damping factor of n in Newton's method.

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 is an option to Dump. When available, the option 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 is an obsolete function, superseded by Trace. 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

x-- decreases the value of x by 1, returning the old value of x.

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 is an option for graphics functions which specifies the default color to use for lines, points, etc. The setting must be a CMYKColor, GrayLevel, Hue or RGBColor directive. The default setting DefaultColor -> Automatic gives a color complementary to the background specified.

$DefaultFont

$DefaultFont gives the default font to use for text in graphics.

DefaultFont

DefaultFont is an option for graphics functions which specifies the default font to use for text. DefaultFont -> {"font", size} specifies the name and size of the font to use. The default setting is 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

No usage.

Definition

Definition[s1, s2, ...] prints as the definitions given for the symbols si.

Degree

Degree gives the number of radians in one degree. It has a numerical value of Pi/180.

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 is an option to DeleteDirectory. 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

Delimiters is an option to Splice that specifies the delimiters to look for. The default is 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

f' represents the derivative of a function f of one argument. Derivative[n1, n2, ...][f] is the general form, representing a function obtained from f by differentiating n1 times with respect to the first argument, n2 times with respect to the second argument, and so on.

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

DialogProlog is an option for Dialog which can give an expression to evaluate before the dialog starts. You must use a delayed rule of the form DialogProlog :> expr to prevent expr from evaluating prematurely.

DialogSymbols

DialogSymbols is an option for Dialog which gives a list of symbols whose values should be localized in the dialog. 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 is an option for NumberForm and related functions which specifies the maximum length of blocks of digits between breaks. With 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 is an obsolete function, superseded by IntegerDigits and RealDigits. 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 is an option for Limit. With 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 gives a list of files and pipes to be used with the default $DisplayFunction.

Display

Display[channel, graphics] writes graphics or sound to the specified output channel.

DisplayAnimation

No usage.

$DisplayFunction

$DisplayFunction gives the default setting for the option DisplayFunction in graphics functions.

DisplayFunction

DisplayFunction is an option for graphics and sound functions that specifies the function to apply to graphics and sound primitives in order to display them. The default setting in graphics functions is $DisplayFunction, and in sound functions is $SoundDisplayFunction. A typical setting is DisplayFunction -> (Display[channel, #]&). DisplayFunction -> Identity causes the objects to be returned, but no display to be generated.

$DisplayHeight

No usage.

$DisplayTitle

No usage.

$DisplayWidth

No usage.

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

x/y or Divide[x, y] is equivalent to x y^-1.

DivideBy

x /= c divides x by c and returns the new value of x.

DivisionFreeRowReduction

DivisionFreeRowReduction is a possible value for the Method options in Inverse, LinearSolve, NullSpace, and RowReduce. 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

a.b.c or Dot[a, b, c] gives products of vectors, matrices and tensors.

DoubleExponential

DoubleExponential is a choice for the option Method of NIntegrate. 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 is an option for LerchPhi. With DoublyInfinite -> True, the summation is taken from -Infinity to Infinity. With DoublyInfinite -> False, the summation is taken from zero to Infinity.

DownValue

DownValue is an obsolete function, superseded by DownValues. 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 is an option to DSolve that determines the constants of integration which may be returned. The default is 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

$DumpDates gives the list of all dates and times at which Dump was used in creating the Mathematica system you are running.

$DumpedPackages

$DumpedPackages gives a list of the packages which have been dumped into the system.

$DumpSupported

$DumpSupported is True if Dump can be used in the version of Mathematica you are running, and is False otherwise.

E

E is the exponential constant e (base of natural logarithms), with numerical value 2.71828....

$Echo

$Echo gives a list of files and pipes to which all input is echoed.

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

EditDef is the obsolete name of EditDefinition.

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

EndOfFile is a symbol returned by Read when it reaches the end of a file.

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

No usage.

EnterExpressionPacket

No usage.

EnterTextPacket

No usage.

Environment

Environment["var"] gives the value of an operating system environment variable.

$Epilog

$Epilog is a symbol whose value, if any, is evaluated when a dialog or a Mathematica session is terminated.

Epilog

Epilog is an option for graphics functions which gives a list of graphics primitives to be rendered after the main part of the graphics is rendered.

Equal

lhs == rhs returns True if lhs and rhs are identical.

EquatedTo

EquatedTo is an option for Roots, which specifies an expression to use in place of the variable in the solution.

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

EulerGamma is Euler's constant gamma, with numerical value 0.577216....

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

No usage.

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 is an option for NumberForm and related functions. 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

(Obsolete: see ExponentFunction) ExponentStep is an option for NumberForm and related functions, which determines the interval between possible exponents to use when printing approximate real numbers.

Expression

Expression is a symbol that represents an ordinary Mathematica expression in Read and related functions.

ExtendedGCD

ExtendedGCD[n, m] gives the extended greatest common divisor of the integers n and m.

ExternalCall

No usage.

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 is an option for three-dimensional graphics functions. With 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 is an option for FactorInteger. With FactorComplete -> True, complete factorization is performed; with FactorComplete -> False, at most one factor is extracted.

Factorial

n! gives the factorial of n.

Factorial2

n!! gives the double factorial of n.

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

Fail is a special symbol returned by evaluation of an obsolete use of Condition.

$Failed

$Failed is a special symbol returned by certain functions when they cannot do what they were asked to do.

False

False is the symbol for the Boolean value false.

File

File is a possible value returned by FileType and related functions to indicate the type of a 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

Flat is an attribute that can be assigned to a symbol f to indicate that all expressions involving nested functions f should be flattened out. This property is accounted for in pattern matching.

Flatten

Flatten[list] flattens out nested lists. Flatten[list, n] flattens to level n. Flatten[list, n, h] flattens subexpressions with head h.

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

Font is an internal symbol used for formatting and printing.

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

FormatType is an option for output streams which specifies the default format type used when printing expressions. The setting can be any standard format type: CForm, FortranForm, InputForm, OutputForm, TeXForm, and TextForm.

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 is an option for two-dimensional graphics functions. With 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

Framed is an obsolete graphics option, superseded by Frame.

FrameLabel

FrameLabel is an option for two-dimensional graphics functions that specifies labels to be placed on the edges of a frame around a plot. FrameLabel -> {xmlabel, ymlabel} specifies labels for the bottom and left-hand edges of the frame. FrameLabel -> {xmlabel, ymlabel, xplabel, yplabel} specifies labels for each of the edges of the frame. With FrameLabel -> None, no labels are given.

FrameStyle

FrameStyle is an option for two-dimensional graphics functions. With 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 is an option for two-dimensional graphics functions. With 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 is an obsolete function, superseded by FromCharacterCode. 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 is an option for FactorInteger, PrimeQ, Factor and related functions. With GaussianIntegers -> True, factorization is done over the Gaussian integers when possible. With GaussianIntegers -> False, factorization is done over the integers.

GaussKronrod

GaussKronrod is a choice for the option Method of NIntegrate. 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 is an option for NIntegrate. With 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

General is a symbol to which general system messages are attached.

Generic

Generic is a setting for the Mode option of Solve and related functions.

Get

<<name reads in a file, evaluating each expression in it, and returning the last one. 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

GoldenRatio is the golden ratio (1 + 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 is an option for FindMinimum, which can be used to specify the gradient of the function whose minimum is being sought. With 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

GraphicsSpacing is an option for GraphicsArray which specifies the spacing between elements in the array.

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

x > y yields True if x is determined to be greater than y. x1 > x2 > x3 yields True if the xi form a strictly decreasing sequence.

GreaterEqual

x >= y 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 is an option for two-dimensional graphics functions. With 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

HashTable is a part of the object which is returned by Dispatch.

Head

Head[expr] gives the head of expr.

HeadCompose

HeadCompose[a, b, c, d] gives a[b][c][d].

Headers

Headers specifies whether output on this channel should be preceded by notebook headers.

Heads

Heads is an option for functions which use level specifications. With 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

HermiteNormalForm gives the Hermite normal form for a matrix of integers.

HiddenSurface

HiddenSurface is an option for SurfaceGraphics. HiddenSurface -> True draws a solid surface. HiddenSurface -> False draws the mesh with transparent polygons.

Hold

Hold[expr] maintains expr in an unevaluated form.

HoldAll

HoldAll is an attribute which specifies that all arguments to a function are to be maintained in an unevaluated form.

HoldFirst

HoldFirst is an attribute which specifies that the first argument to a function is to be maintained in an unevaluated form.

HoldForm

HoldForm[expr] prints as the expression expr, with expr maintained in an unevaluated form.

HoldRest

HoldRest is an attribute which specifies that all but the first argument to a function are to be maintained in an unevaluated form.

HomeDirectory

HomeDirectory[ ] gives your "home" directory.

HorizontalForm

HorizontalForm is an internal symbol used for formatting and printing.

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

I represents the imaginary unit 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 is an option for string manipulation and searching functions. With 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

$IgnoreEOF specifies whether Mathematica should terminate when it receives an end-of-file character as input.

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 is an option for LerchPhi and Zeta. With IncludeSingularTerm -> True, terms of the form (k + a)^-s with k + a == 0 are included. With IncludeSingularTerm -> False, they are not.

Increment

x++ increases the value of x by 1, returning the old value of x.

Indent

Indent[d] is printed as the indentation for a depth d subexpression.

Indeterminate

Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined.

Inequality

Inequality represents a sequence of relational statements.

Infinity

Infinity is a symbol that represents a positive infinite quantity.

Infix

Infix[f[e1, e2, ...]] prints with f[e1, e2, ...] given in default infix form: e1 ~ f ~ e2 ~ f ~ e3 .... Infix[expr, h] prints with arguments separated by h: e1 h e2 h e3 ....

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 is a global variable whose value is the name of the stream from which input to Mathematica is currently being sought.

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

No usage.

InputPacket

No usage.

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

$Inspector is a global variable which gives a function to apply when the inspector is invoked from an interrupt menu.

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

Integer is the head used for integers.

IntegerDigits

IntegerDigits[n] gives a list of the decimal digits in the integer n. IntegerDigits[n, b] gives a list of the base-b digits in the integer n. IntegerDigits[n, b, 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 is an option to Interpolation. 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 is an option to Solve and related functions. With 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

$IterationLimit gives the maximum length of evaluation chain used in trying to evaluate any expression.

JacobiAmplitude

JacobiAmplitude[u, m] gives the amplitude for Jacobi elliptic functions.

Jacobian

Jacobian is an option for FindRoot. Jacobian -> Automatic attempts symbolic computation of the Jacobian of the system of functions whose root is being sought. A typical setting is Jacobian -> {{2 x, Sign[y]}, {y, x}}.

JacobiCD

JacobiCD[u, m] gives the Jacobi elliptic function cd 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

$Language is a list of strings which give the names of languages to use for messages.

LaserPrint

No usage.

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

Launch is a setting for the LinkMode option of LinkOpen. 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

Left is used to specify alignment in printforms such as ColumnForm and TableForm.

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 is an option for LegendreP and LegendreQ which specifies choices of branch cuts for Legendre functions in the complex plane. With 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

x < y yields True if x is determined to be less than y. x1 < x2 < x3 yields True if the xi form a strictly increasing sequence.

LessEqual

x <= y 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

$Letters is a list containing characters which are to be treated as letters. The lower- and upper-case forms of a particular letter can be given in a sublist.

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 is an option to Graphics3D and related functions. With Lighting -> True, simulated illumination is used; with Lighting -> False, it is not.

LightSources

LightSources is an option to Graphics3D and related functions that specifies the properties of point light sources for simulated illumination. The basic form is LightSources -> {{direction1, color1}, {direction2, color2}, ... }. The direction is specified as {x, y, z}. The color can be specified by GrayLevel, Hue or RGBColor.

Limit

Limit[expr, x->x0] finds the limiting value of expr when x approaches x0.

$Line

$Line is a global variable that specifies the number of the current input 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

$Linked is True if the Mathematica kernel is being run through MathLink.

LinkError

LinkError[link] returns error information for link in the form { errorNumber, errorExplanation }.

LinkFlush

LinkFlush[link] transmits immediately any locally buffered outgoing expressions.

LinkHost

LinkHost is an option for LinkOpen that specifies on what computer a program should be launched or on what computer a listening link will be found.

LinkInterrupt

LinkInterrupt[link] sends an interrupt message to an external program over MathLink.

LinkMode

LinkMode is an option for LinkOpen that specifies how the link is to be established and connected. The possible settings for LinkMode are Launch, Listen, and Connect.

LinkObject

LinkObject represents a link to an external process started using LinkOpen.

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

LinkProtocol is an option for LinkOpen that specifies what underlying communication protocol should be used for the link. The possible settings for LinkProtocol are "Pipes", "TCP", or Automatic. LinkProtocol->"TCP", for example, creates a link that uses the TCP stream protocol from the TCP/IP suite of protocols to transmit MathLink data. In general, the setting for LinkProtocol determines the meaning, form and appropriate values for all other arguments and options of LinkOpen.

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

$LinkSupported is True if MathLink can be used in the version of Mathematica you are running, and is False otherwise.

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

{e1, e2, ...} is a list of elements.

Listable

Listable is an attribute that can be assigned to a symbol f to indicate that the function f should automatically be threaded over lists that appear as its arguments.

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

Listen is a setting for the LinkMode option of LinkOpen. LinkMode->Listen causes a link to be created that listens on a named port for an incoming connection request.

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

Locked is an attribute which, once assigned, prevents modification of any attributes of a symbol.

Log

Log[z] gives the natural logarithm of z (logarithm to base E). Log[b, z] gives the logarithm to base b.

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

$MachineEpsilon gives the smallest machine-precision number which can be added to 1.0 to give a result not equal to 1.0.

$MachineID

$MachineID is a string that gives, if possible, a unique identification code for the computer being used.

MachineID

MachineID is an option to Encode which specifies the required value of $MachineID on the computer that reads the encoded file. If no value is specified, any value of $MachineID is allowed on the file-reading computer. A setting for MachineID must be a string.

$MachineName

$MachineName is a string that gives the assigned name of the computer being used, if such a name is defined.

MachineName

MachineName is an option to Encode which specifies the required value of $MachineName on the computer that reads the encoded file. If no value is specified, any value of $MachineName is allowed on the file-reading computer. A setting for MachineName must be a string.

MachineNumberQ

MachineNumberQ[x] returns True if x is a machine floating point number, and returns False otherwise.

$MachinePrecision

$MachinePrecision gives the number of decimal digits of precision used for machine-precision numbers.

$MachineType

$MachineType is a string giving the general type of computer on which Mathematica is being run.

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 is an option to Solve and related functions. With MakeRules -> True, the result is presented as an AlgebraicRulesData object. With MakeRules -> False, the result is presented as a list of rules.

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

MatchBox is an internal symbol.

MatchLocalNameQ

MatchLocalNameQ is an internal symbol.

MatchLocalNames

MatchLocalNames is an option for Trace and related functions. With 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 is an option for Plot which measures the maximum bend angle between successive line segments on a curve. MaxBend -> n specifies the maximum bend as n degrees.

MaxIterations

MaxIterations is an option for various functions that use an iterative algorithm. With MaxIterations -> n, a maximum of n iterations is used.

$MaxMachineNumber

$MaxMachineNumber is the largest machine-precision number that can be used on a particular computer system.

MaxMemoryUsed

MaxMemoryUsed[ ] gives the maximum number of bytes used to store all data for the current Mathematica session.

$MaxNumber

$MaxNumber gives the largest representable number.

$MaxPrecision

$MaxPrecision is the upper bound for the precision of inexact numbers. Even if precision is gained it will always be adjusted to be at most $MaxPrecision.

MaxRecursion

MaxRecursion is an option for various numerical functions that use a recursive algorithm. With MaxRecursion -> n, the maximum depth to which recursion is allowed to go is n even if convergence is not yet achieved.

MaxSteps

MaxSteps is an option to NDSolve. With MaxSteps -> n, the maximum number of steps taken is n.

MaxStepSize

MaxStepSize is an option to NDSolve that determines the maximum size of each step.

$$Media

$$Media is an obsolete symbol, superseded by 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 is an option for SurfaceGraphics and DensityGraphics. With Mesh -> True, an explicit x-y mesh is drawn; with Mesh -> False, no mesh is drawn.

MeshRange

MeshRange is an option for ListPlot3D, SurfaceGraphics, ListContourPlot, ListDensityPlot and related functions. MeshRange -> {{xmin, xmax}, {ymin, ymax}} specifies the range of x and y coordinates that correspond to the array of z values given. MeshRange -> Automatic uses integers determined by indices in the array.

MeshStyle

MeshStyle is an option for Plot3D, DensityPlot and related functions which specifies how mesh lines should be rendered. MeshStyle can be set to a list of graphics directives including Dashing, Thickness, GrayLevel, Hue and RGBColor.

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

$MessageList is a global variable that gives a list of the names of messages generated during the evaluation of the current input line. Each message name is enclosed in 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

symbol::tag (or MessageName[symbol, "tag"]) is a name for a message.

MessagePacket

No usage.

$MessagePrePrint

$MessagePrePrint is a global variable whose value, if set, is applied to expressions before they are included in the text of messages.

$Messages

$Messages gives the list of files and pipes to which message output is sent.

Messages

Messages[symbol] gives all the messages assigned to a particular symbol.

MetaCharacters

MetaCharacters is an option to StringPosition. With MetaCharacters -> None, no strings have special meanings. MetaCharacters -> {c1, c2, c3} specifies the metacharacters for pattern escape, single character matching and multiple character matching. MetaCharacters -> Automatic is equivalent to MetaCharacters -> {"\\", ".", "*"}.

Method

Method is an option to Solve, related functions, and various numerical functions, which specifies what algorithm to use in evaluating the result.

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

$MinMachineNumber is the smallest positive machine-precision number that can be used on a particular computer system.

$MinNumber

$MinNumber gives the smallest (positive) representable number.

Minors

Minors[m, k] gives a matrix consisting of the determinants of all k X k submatrices of m.

$MinPrecision

$MinPrecision is the lower bound for the precision of inexact numbers. Even if precision is lost it will always be adjusted to be at least $MinPrecision.

MinRecursion

MinRecursion is an option for NIntegrate and other numerical functions that use a recursive algorithm. With MinRecursion -> n, a minimum depth of recursion of n is used before tests for convergence begin.

Minus

-x is the arithmetic negation of x.

Mod

Mod[m, n] gives the remainder on division of m by n. The result has the same sign as n.

Mode

Mode is an option to Solve and related functions that specifies in what sense the equations are to be solved. The possible settings for Mode are Generic, Modular, and Rational.

Modular

Modular is a setting for the option Mode in Solve and related functions, which specifies that equations need be satisfied only modulo an integer.

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

$ModuleNumber gives the current serial number to be used for local variables generated by Unique[ ] or Module[ ].

Modulus

Modulus is an option that can be given to Factor and other mathematical operations. 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

No usage.

MultiDimensional

MultiDimensional is a choice for the option Method of NIntegrate. 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 is an option to Roots. 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

$NewMessage is a global variable which, if set, is applied to the symbol name and tag of messages that are requested but have not yet been defined.

$NewSymbol

$NewSymbol is a global variable which, if set, is applied to the name and context of each new symbol that Mathematica creates.

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

NonAssociative is a symbol that represents a non-associative operator in formatting functions.

NonCommutativeMultiply

a ** b ** c is a general associative, but non-commutative, form of multiplication.

NonConstants

NonConstants is an option for D which gives a list of objects to be taken to depend implicitly on the differentiation variables.

None

None is a setting used for certain options.

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

!expr is the logical NOT function. It gives False if expr is True, and True if it is False.

$Notebooks

$Notebooks is True if Mathematica is being used with a notebook-based front end.

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 is an option for NProduct which is used with the method SequenceLimit. NProductExtraFactors -> n uses n factors in the extrapolation process. NProductExtraFactors must be greater than twice WynnDegree.

NProductFactors

NProductFactors is an option for NProduct. NProductFactors -> n explicitly includes n factors in the product before extrapolation.

NProtectedAll

NProtectedAll is an attribute that specifies that none of the arguments to a function will be modified by the application of N[ ].

NProtectedFirst

NProtectedFirst is an attribute that specifies that the first argument to a function will not be modified by the application of N[ ].

NProtectedRest

NProtectedRest is an attribute that specifies that any arguments after the first argument to a function will not be modified by the application of 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 is an option for NSum which is used with the method SequenceLimit. NSumExtraTerms -> n uses n terms in the extrapolation process. NSumExtraTerms must be greater than twice WynnDegree.

NSumTerms

NSumTerms is an option for NSum. NSumTerms -> n explicitly includes n terms in the sum before extrapolation.

Null

Null is a symbol used to indicate the absence of an expression or a result. When it appears as an output expression, no output is printed.

NullRecords

NullRecords is an option for Read and related functions. With 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 is an option for Read and related functions. With 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

Number represents an exact integer or an approximate real number in Read.

$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 is an option for NumberForm and related functions which specifies how the mantissa, base and exponent should be assembled into a final print form. With 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

NumberPadding is an option for NumberForm and related functions which gives strings to use as padding on the left- and right-hand sides of numbers. NumberPadding -> {"sleft", "sright"} specifies strings to use for padding on the left and right.

NumberPoint

NumberPoint is an option for NumberForm and related functions which gives the string to use as a decimal point. The default is NumberPoint -> "." .

NumberQ

NumberQ[expr] gives True if expr is a number, and False otherwise.

NumberSeparator

NumberSeparator is an option for NumberForm and related functions which gives the string to insert at breaks between digits. With NumberSeparator -> "s", the string s is inserted at every break between digits specified by DigitBlock. NumberSeparator -> {"sleft", "sright"} specifies different strings to be used on the left and right of the decimal point.

NumberSigns

NumberSigns is an option for NumberForm and related functions. NumberSigns -> {"sneg", "spos"} specifies that "sneg" should be given as the sign for negative numbers, and "spos" for positive numbers. NumberSigns -> {{"snleft", "snright"}, {"spleft", "spright"}} specifies strings to put both on the left and right of numbers to specify their signs.

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 is used to mark messages that have been turned 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

OneIdentity is an attribute that can be assigned to a symbol f to indicate that f[x], f[f[x]], etc. are all equivalent to x for the purpose of pattern matching.

OneStepRowReduction

OneStepRowReduction is a possible value for the Method option in Inverse, LinearSolve, NullSpace, and RowReduce. 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

$OperatingSystem is a string giving the type of operating system under which Mathematica is being run.

Optional

p:v is a pattern object which represents an expression of the form p, which, if omitted, should be replaced by v.

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

e1 || e2 || ... is the logical OR function. It evaluates its arguments in order, giving True immediately if any of them are True, and False if they are all False.

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

Orderless is an attribute that can be assigned to a symbol f to indicate that the elements ei in expressions of the form f[e1, e2, ...] should automatically be sorted into canonical order. This property is accounted for in pattern matching.

Out

%n or Out[n] is a global object that is assigned to be the value produced on the nth output line. % gives the last result generated. %% gives the result before last. %%...% (k times) gives the kth previous result.

Outer

Outer[f, list1, list2, ...] gives the generalized outer product of the listi.

$Output

$Output gives the list of files and pipes to which standard output from Mathematica is sent.

OutputForm

OutputForm[expr] prints as the standard Mathematica output form for expr.

$OutputForms

$OutputForms is a list of the formatting functions that get stripped off when wrapped around the output.

OutputNamePacket

No usage.

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 is an option to StringPosition. With 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

$Packages gives a list of the contexts corresponding to all packages which have been loaded in your current Mathematica session.

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 is an option for output streams. PageHeight -> n specifies that n lines of text should be printed between page breaks. With PageHeight -> Infinity, there are no page breaks.

PageWidth

PageWidth is an option which can be set for output streams. 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

No usage.

ParentDirectory

ParentDirectory[ ] gives the parent of the current working directory. ParentDirectory["dir"] gives the parent of the directory dir.

$ParentLink

$ParentLink is the LinkObject through which Mathematica communicates with a frontend in mathlink mode. It is assigned implicitly when Mathematica is started with a -mathlink command line option, or can be assigned explicitly. Assigning $ParentLink to Null resets the normal (terminal) mode.

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

$Path gives a list of directories to search in attempting to find an external file.

$PathnameSeparator

$PathnameSeparator is a string that should separate the names of directories and files in pathnames used by this operating system.

Pattern

s:obj represents the pattern object obj, assigned the name s.

PatternTest

p?test is a pattern object that stands for any expression which matches p, and on which the application of test gives True.

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

Pi is pi, with numerical value 3.14159....

$PipeSupported

$PipeSupported is True if pipes can be used in the version of Mathematica you are running, and is False otherwise.

Pivoting

Pivoting is an option to certain matrix decomposition functions. With Pivoting -> False, no pivoting is done. With Pivoting -> True, column pivoting is carried out and the list of matrices returned is augmented by the appropriate permutation matrix.

Plain

Plain is a setting that can be given for the option TextRendering to specify output on a character-oriented display device. The TextRendering option is not supported in Version 2.0.

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 is an option for Play and related functions. With 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

PlotColor is an obsolete graphics option, superseded by ColorOutput.

PlotDivision

PlotDivision is an option for Plot. PlotDivision -> n specifies that a maximum of n subdivisions should be used in attempting to generate a smooth curve.

PlotJoined

PlotJoined is an option for ListPlot. With PlotJoined -> True, the points plotted are joined by a line. With PlotJoined -> False, they are not.

PlotLabel

PlotLabel is an option for graphics functions that specifies an overall label for a plot. With PlotLabel -> None, no label is given. PlotLabel -> label specifies a label.

PlotPoints

PlotPoints is an option for plotting functions. With a single variable, 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 is an option for graphics functions. With 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 is an option for graphics functions. PlotRegion -> {{sxmin, sxmax}, {symin, symax}} specifies the region in scaled coordinates that the plot should fill in the final display area. With PlotRegion -> Automatic, the plot fills the final display area.

PlotStyle

PlotStyle is an option for Plot, ParametricPlot and ListPlot. 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

Plot3Matrix is an obsolete graphics option, superseded by ViewCenter and ViewVertical.

Plus

x + y + z represents a sum of terms.

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 is an option for Graphics3D and ParametricPlot3D. With 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

$Post is a global variable whose value, if set, is applied to every output expression.

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

x^y gives x to the power y.

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

$Pre is a global variable whose value, if set, is applied to every input expression.

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 is an option for various numerical operations which specifies how many digits of precision should be sought in the final result. The error is considered acceptable and the result is returned when either the AccuracyGoal or the PrecisionGoal is achieved. 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

--x decreases the value of x by 1, returning the new value of x.

Prefix

Prefix[f[expr]] prints with f[expr] given in default prefix form: f @ expr. Prefix[f[expr], h] prints as hexpr.

PreIncrement

++x increases the value of x by 1, returning the new value of x.

Prepend

Prepend[expr, elem] gives expr with elem prepended.

PrependTo

PrependTo[s, elem] prepends elem to the value of s, and resets s to the result.

$PrePrint

$PrePrint is a global variable whose value, if set, is applied to every expression before it is printed.

$PreRead

$PreRead is a global variable whose value, if set, is applied to the text of every input expression before it is fed to Mathematica.

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

$PrintForms is the list of basic print forms. It is automatically updated when Format definitions using new printforms are made.

$PrintLiteral

$PrintLiteral is an internal symbol.

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

Prolog is an option for graphics functions which gives a list of graphics primitives to be rendered before the main part of the graphics is rendered.

PromptForm

PromptForm[prompt,expr] prints as an output prompt and expression.

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

Protected is an attribute which prevents any values associated with a symbol from being modified.

PseudoInverse

PseudoInverse[m] finds the pseudoinverse of a rectangular matrix.

PSPrint

PSPrint[-graphics-] sends graphics to a printer.

Put

expr >> filename writes expr to a file. Put[expr1, expr2, ..., "filename"] writes a sequence of expressions expri to a file.

PutAppend

expr >>> filename appends expr to a file. 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 is an option for Roots and related functions. With 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

$RandomState is the current state of the random number generator represented as a large integer.

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

No usage.

Rational

Rational is the head used for rational numbers.

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

RawMedium is an internal symbol.

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

ReadProtected is an attribute which prevents values associated with a symbol from being seen.

Real

Real is the head used for real (floating-point) numbers.

RealBlockForm

RealBlockForm is an option of SchurDecomposition which specifies whether complex eigenvalues of a real input matrix should be returned as 2x2 real blocks or as complex values.

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

RealInterval is an obsolete function, superseded by Interval.

Record

Record represents a record in Read, Find and related functions.

RecordLists

RecordLists is an option for ReadList. With 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

RecordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for records. The default setting is RecordSeparators -> {"\n"}. RecordSeparators -> { } specifies that everything is to be included in a single record. RecordSeparators -> {{lsep1, ... }, {rsep1, ... }} specifies different left and right separators for records.

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

$RecursionLimit gives the current limit on the number of levels of recursion that Mathematica can use.

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

Release is provided for backward compatibility only; its two independent functions are now provided by Evaluate and ReleaseHold. 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

$ReleaseNumber is an integer which gives the current Mathematica kernel release number, and increases in successive releases.

$Remote

$Remote is True if Mathematica is being used in remote mode or with a front end, and is False otherwise.

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 is an option to Graphics3D. When 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

p.. is a pattern object which represents a sequence of one or more expressions, each matching p.

RepeatedNull

p... is a pattern object which represents a sequence of zero or more expressions, each matching p.

RepeatedString

RepeatedString is an internal symbol used for formatting and printing.

Replace

Replace[expr, rules] applies a rule or list of rules in an attempt to transform the entire expression expr.

ReplaceAll

expr /. rules applies a rule or list of rules in an attempt to transform each subpart of an expression expr.

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

expr //. rules repeatedly performs replacements until expr no longer changes.

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

No usage.

Return

Return[expr] returns the value expr from a function. Return[ ] returns the value Null.

ReturnExpressionPacket

No usage.

ReturnPacket

No usage.

ReturnTextPacket

No usage.

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

Right is used to specify alignment in printforms such as ColumnForm and TableForm.

Roots

Roots[lhs==rhs, var] yields a disjunction of equations which represent the roots of a polynomial equation.

RotateLabel

RotateLabel is an option for two-dimensional graphics functions. With 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

Row is a setting for the TableDirections option of TableForm.

RowReduce

RowReduce[m] gives the row-reduced form of the matrix m.

Rule

lhs -> rhs represents a rule that transforms lhs to rhs.

RuleCondition

RuleCondition is an internal symbol.

RuleDelayed

lhs :> rhs represents a rule that transforms lhs to rhs, evaluating rhs only when the rule is used.

RuleForm

RuleForm is an internal symbol used for formatting and printing.

RuleTable

RuleTable is an internal symbol.

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

lhs === rhs yields True if the expression lhs is identical to rhs, and yields False otherwise.

SameTest

SameTest is an option for functions like FixedPoint that specifies the comparison function to apply to pairs of results to determine whether they should be considered the same. Settings for SameTest must be functions that take two arguments, and return True or False.

SampleDepth

SampleDepth is an option for sound primitives. 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 is an option for sound primitives. 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

Second is a unit of time used by functions such as Timing.

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

$SessionID is a number set up to be unique to a particular Mathematica session.

SessionTime

SessionTime[ ] gives the total number of seconds of real time that have elapsed since the beginning of your Mathematica session.

Set

lhs = rhs evaluates rhs and assigns the result to be the value of lhs. From then on, lhs is replaced by rhs whenever it appears. {l1, l2, ...} = {r1, r2, ...} evaluates the ri, and assigns the results to be the values of the corresponding li.

SetAccuracy

SetAccuracy[expr, 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

lhs := rhs assigns rhs to be the delayed value of lhs. rhs is maintained in an unevaluated form. When lhs appears, it is replaced by rhs, evaluated afresh each time.

SetDirectory

SetDirectory["dir"] sets the current working directory.

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

No usage.

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 is an option for SurfaceGraphics. With 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 is an option for NumberForm and related functions. With 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 is an option for NIntegrate. 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

# represents the first argument supplied to a pure function. #n represents the nth argument.

SlotSequence

## represents the sequence of arguments supplied to a pure function. ##n represents the sequence of arguments supplied to a pure function, starting with the nth argument.

Socket

Socket is a possible value returned by FileType and related functions.

SolutionOf

SolutionOf is an internal symbol.

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

No usage.

$SoundDisplayFunction

$SoundDisplayFunction gives the default setting for the option DisplayFunction in sound functions.

$SoundDisplayTitle

No usage.

Space

Space is a string consisting of a space.

SpaceForm

SpaceForm[n] prints as n spaces.

SpellingCorrection

SpellingCorrection is an option for StringMatchQ, Names and related functions. With 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 is an option for three-dimensional graphics functions. With 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 is an option to NDSolve. 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

String is the head of a character string "text".

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 gives the default setting for the option StringConversion in output functions.

StringConversion

StringConversion is an option for output functions. 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

"s1" <> "s2" <> ..., StringJoin["s1", "s2", ...] or StringJoin[{"s1", "s2", ...}] yields a string consisting of a concatenation of the si.

StringLength

StringLength["string"] gives the number of characters in a string.

StringMatchQ

StringMatchQ["string", "pattern"] yields True if "string" matches the specified string pattern, and yields False otherwise.

$StringOrder

$StringOrder gives the ordering of characters to be used in sorting strings and symbol names.

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

Stub is an attribute which specifies that if a symbol is ever used, Needs should automatically be called on the context of the symbol.

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

x - y is equivalent to x + (-1 * y).

SubtractFrom

x -= dx subtracts dx from x and returns the new value of x.

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

$SuppressInputFormHeads is a list of the heads of expressions whose InputForm should not be sent automatically to front ends.

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

No usage.

Switch

Switch[expr, form1, value1, form2, value2, ...] evaluates expr, then compares it with each of the formi in turn, evaluating and returning the valuei corresponding to the first match found.

Symbol

Symbol is the head associated with a symbol.

Syntax

No usage.

$SyntaxHandler

$SyntaxHandler is a global variable which, if set, is applied to any input string that is found to contain a syntax error. The arguments given to $SyntaxHandler are the complete input string and an integer specifying the character position at which the syntax error was detected.

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

$System is a string specifying the type of computer system used.

SystemStub

No usage.

Tab

Tab is a string consisting of a tab character.

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 is an option for TableForm and MatrixForm. TableAlignments -> {a1, a2, ... } specifies alignments for successive dimensions. For dimensions that are given as columns, possible alignments are Left, Center and Right. For dimensions that are given as rows, possible alignments are Bottom, Center and Top. The default setting TableAlignments -> Automatic uses Left for column alignment, and Bottom for row alignment.

TableDepth

TableDepth is an option for TableForm and MatrixForm. 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 is an option for TableForm and MatrixForm. 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 is an option for TableForm and MatrixForm which gives the labels to be printed for entries in each dimension of a table or matrix. 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 is an option for TableForm and MatrixForm which specifies how many spaces should be left between each successive row or column. TableSpacing -> {s1, s2, ... } specifies that si spaces should be left in dimension i. For TableForm, TableSpacing -> Automatic yields spacings {1, 3, 0, 1, 0, 1, ... }.

TagSet

f/: lhs = rhs assigns rhs to be the value of lhs, and associates the assignment with the symbol f.

TagSetDelayed

f/: lhs := rhs assigns rhs to be the delayed value of lhs, and associates the assignment with the symbol f.

TagUnset

f/: lhs =. removes any rules defined for lhs, associated with the symbol f.

Take

Take[list, n] gives the first n elements of list. Take[list, -n] gives the last n elements of list. Take[list, {m, n}] gives elements m through n of list.

Tan

Tan[z] gives the tangent of z.

Tanh

Tanh[z] gives the hyperbolic tangent of z.

TargetFunctions

TargetFunctions is an option to ComplexExpand. The value can be given as a list chosen from {Re, Im, Abs, Arg, Conjugate, Sign}. ComplexExpand will try to return results in terms of the functions requested.

Temporary

Temporary is an attribute assigned to symbols which are created as local variables by Module.

$TemporaryPrefix

$TemporaryPrefix forms the initial part of filenames returned by 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

No usage.

TextRendering

TextRendering is an option for OpenWrite etc. which specifies how text is to be rendered in a particular output file. This option is not supported in Version 2.0.

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

$Thin = True means that a thin Kernel has been started which uses an autoloading mechanism to load system packages on demand.

ThisLink

ThisLink is used in patterns for external packages to distinguish between several instances of the same package.

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 is an internal symbol.

Throw

Throw[expr] exits from nested control structures, returning the value expr to the nearest enclosing Catch.

Ticks

Ticks is an option for graphics functions. With 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

x*y*z or x y z represents a product of terms.

TimesBy

x *= c multiplies x by c and returns the new value of x.

$TimeUnit

$TimeUnit gives the minimum time interval in seconds recorded on your computer system.

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 is an obsolete function, superseded by ToCharacterCode. 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

TokenWords is an option for Read and related functions. The setting for TokenWords is a list of strings which are used as delimiters for words to be read.

Tolerance

Tolerance is an option to certain functions that specifies the numerical tolerance under which the calculation is to be effected. Tolerance -> r sets a tolerance of r.

ToLowerCase

ToLowerCase[string] yields a string in which all letters have been converted to lower case.

TooBig

TooBig is an internal symbol.

Top

Top is a setting for the TableAlignments option of TableForm.

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 is an option for output streams. 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 is an option for output streams. 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 is an option for Trace and related functions which specifies whether to include evaluation chains which contain the evaluation chain containing the pattern form sought. 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

TraceAction is an option for TracePrint and TraceDialog that specifies the function to be applied to each expression they trace.

TraceBackward

TraceBackward is an option for Trace and related functions which specifies whether to include preceding expressions on the evaluation chain that contains the pattern sought. 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 is an option for Trace and related functions which specifies the maximum nesting of evaluation chains that are to be included. Setting 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 is an option for Trace and related functions which specifies whether to include later expressions on the evaluation chain that contains the pattern sought. TraceForward -> True includes the final expression on the evaluation chain. TraceForward -> All includes all expressions on the evaluation chain after the pattern sought.

TraceInternal

TraceInternal is an option for Trace and related functions which, if True or False, specifies whether to trace evaluations of expressions generated internally by Mathematica. The intermediate Automatic setting traces a selected set of internal evaluations including Messages and sets or unsets of visible symbols.

TraceLevel

Whenever Trace[] or a related function is being evaluated, TraceLevel[] returns the level of its output currently being filled.

$TraceOff

$TraceOff is the currently active TraceOff option value to Trace and related functions. It can be reset during the trace to alter the set of expressions in which tracing is disabled.

TraceOff

TraceOff is an option for Trace and related functions. With TraceOff -> patt, tracing will be switched off while any expression matching the pattern patt is being evaluated. The default is TraceOn -> None.

$TraceOn

$TraceOn is the currently active TraceOn option value to Trace and related functions. It can be reset during the trace to alter the set of expressions in which tracing will occur.

TraceOn

TraceOn is an option for Trace and related functions. With 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 is an option for Trace and related functions. With TraceOriginal -> True, the form of each expression is tested before its head and arguments are evaluated. With TraceOriginal -> False, it is not.

$TracePattern

$TracePattern is the currently active pattern argument to Trace and related functions. It can be reset during the trace to alter the set of expressions recorded or printed.

$TracePostAction

$TracePostAction is the currently active fourth argument to TraceScan (or the equivalent in related functions). It can be reset during the trace to alter the action taken after intercepted expressions are evaluated.

$TracePreAction

$TracePreAction is the currently active first argument to TraceScan (or the equivalent in related functions). It can be reset during the trace to alter the action taken before intercepted expressions are evaluated.

TracePrint

TracePrint[expr] prints all expressions used in the evaluation of expr. TracePrint[expr, form] includes only those expressions which match form. TracePrint[expr, s] includes all evaluations which use transformation rules associated with the symbol s.

TraceScan

TraceScan[f, expr] applies f to all expressions used in the evaluation of expr. TraceScan[f, expr, form] includes only those expressions which match form. TraceScan[f, expr, s] includes all evaluations which use transformation rules associated with the symbol s. TraceScan[f, expr, form, fp] applies f before evaluation and fp after evaluation to expressions used in the evaluation of expr.

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

Trapezoidal is a choice for the option Method of NIntegrate. 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 is an option for algebraic manipulation functions. With Trig -> True, trigonometric functions are treated as rational functions of exponentials. With Trig -> False, trigonometric functions are treated as indivisible objects.

True

True is the symbol for the Boolean value true.

TrueQ

TrueQ[expr] yields True if expr is True, and yields False otherwise.

UnAlias

No usage.

Underflow

Underflow[] is the result of a numerical calculation whose result is too small to represent.

Unequal

lhs != rhs returns False if lhs and rhs are identical.

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

lhs =!= rhs yields True if the expression lhs is not identical to rhs, and yields False otherwise.

$Unset

$Unset is an internal symbol.

Unset

lhs =. removes any rules defined for lhs.

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

lhs^=rhs assigns rhs to be the value of lhs, and associates the assignment with symbols that occur at level one in lhs.

UpSetDelayed

lhs^:=rhs assigns rhs to be the delayed value of lhs, and associates the assignment with symbols that occur at level one in lhs.

UpValues

UpValues[f] gives a list of transformation rules corresponding to all upvalues defined for the symbol f.

$Urgent

$Urgent gives the list of files and pipes to which urgent output from Mathematica is sent.

UseDump

No usage.

Using

Using is an option to Roots that specifies any subsidiary equations that are to be used.

ValueForm

ValueForm is an internal symbol.

ValueList

ValueList is an internal symbol.

ValueQ

ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise.

ValueTable

ValueTable is an internal symbol.

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 is an option to NSum and NProduct. 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 is an option to Solve and related functions. With 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

$Version is a string that represents the version of Mathematica you are running.

$VersionNumber

$VersionNumber is a real number which gives the current Mathematica kernel version number, and increases in successive versions.

VerticalForm

VerticalForm is an internal symbol used for formatting and printing.

ViewCenter

ViewCenter is an option for Graphics3D and SurfaceGraphics. With 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

ViewPoint is an option for Graphics3D and SurfaceGraphics which gives the point in space from which the objects plotted are to be viewed. ViewPoint -> {x, y, z} gives the position of the view point relative to the center of the three-dimensional box that contains the object being plotted.

ViewVertical

ViewVertical is an option for Graphics3D and SurfaceGraphics. ViewVertical -> {x, y, z} specifies the direction in scaled coordinates which should be vertical in the final image.

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

Word represents a word in Read, Find and related functions.

WordSearch

WordSearch is an option for Find and FindList. With WordSearch -> True, the text searched for must appear as a word. With WordSearch -> False, it does not.

WordSeparators

WordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for words. The default setting is WordSeparators -> {" ", "\t"}. WordSeparators -> {{lsep1, ... }, {rsep1, ... }} specifies different left and right separators for words.

WorkingPrecision

WorkingPrecision is an option for various numerical operations which specifies how many digits of precision should be maintained in internal computations. 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 is an option to SequenceLimit which specifies the degree of the algorithm. 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

ZeroTest is an option for LinearSolve and other linear algebra functions, which gives a function to be applied to combinations of matrix elements to determine whether or not they should be considered equal to zero.

Zeta

Zeta[s] gives the Riemann zeta function zeta(s). Zeta[s, a] gives the generalized Riemann zeta function.