Abort::usage = "Abort[ ] generates an interrupt to abort a computation."
$Aborted::usage = "$Aborted is a special symbol that is returned as the result from a calculation that has been aborted."
AbortProtect::usage = "AbortProtect[expr] evaluates expr, saving any aborts until the evaluation is complete, or until CheckAbort is called."
Above::usage = "Above is used to specify alignment in printforms such as ColumnForm and TableForm."
Abs::usage = "Abs[z] gives the absolute value of the real or complex number z."
AbsoluteDashing::usage = "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::usage = "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::usage = "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::usage = "AbsoluteTime[ ] gives the total number of seconds since the beginning of January 1, 1900, in your time zone."
AccountingForm::usage = "AccountingForm[expr] prints with all numbers in expr given in standard accounting notation."
Accumulate::usage = "Accumulate is an obsolete function, superseded by FoldList.\n Accumulate[f, g[e1, e2, ...]] gives g[e1, f[e1, e2], f[f[e1, e2], e3], ...]."
Accuracy::usage = "Accuracy[x] gives the number of digits to the right of the decimal point in the number x."
AccuracyGoal::usage = "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."
AddTo::usage = "x += dx adds dx to x and returns the new value of x."
AiryAi::usage = "AiryAi[z] gives the Airy function Ai(z)."
AiryAiPrime::usage = "AiryAiPrime[z] gives the derivative of the Airy function Ai'(z)."
AiryBi::usage = "AiryBi[z] gives the Airy function Bi(z)."
AiryBiPrime::usage = "AiryBiPrime[z] gives the derivative of the Airy function Bi'(z)."
AlgebraicRules::usage = "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::usage = "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::usage = "Alias is an obsolete function, superseded by $Pre and $PreRead."
All::usage = "All is a setting used for certain options."
Alternatives::usage = "p1 | p2 | ... is a pattern object which represents any of the patterns pi."
AmbientLight::usage = "AmbientLight is an option to Graphics3D and related functions that gives the level of simulated ambient illumination in a three-dimensional picture."
Analytic::usage = "Analytic is an option for Limit and Series that specifies whether unrecognized functions should be treated as analytic."
AnchoredSearch::usage = "AnchoredSearch is an option for Find and FindList which specifies whether the text searched for must be at the beginning of a record."
And::usage = "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."
Apart::usage = "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::usage = "ApartSquareFree[expr, var] writes expr as a sum of terms with square-free denominators in the variable var."
Append::usage = "Append[expr, elem] gives expr with elem appended."
AppendTo::usage = "AppendTo[s, elem] appends elem to the value of s, and resets s to the result."
Apply::usage = "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::usage = "ArcCos[z] gives the arc cosine of the complex number z."
ArcCosh::usage = "ArcCosh[z] gives the inverse hyperbolic cosine of the complex number z."
ArcCot::usage = "ArcCot[z] gives the arc cotangent of the complex number z."
ArcCoth::usage = "ArcCoth[z] gives the inverse hyperbolic cotangent of the complex number z."
ArcCsc::usage = "ArcCsc[z] gives the arc cosecant of the complex number z."
ArcCsch::usage = "ArcCsch[z] gives the inverse hyperbolic cosecant of the complex number z."
ArcSec::usage = "ArcSec[z] gives the arc secant of the complex number z."
ArcSech::usage = "ArcSech[z] gives the inverse hyperbolic secant of the complex number z."
ArcSin::usage = "ArcSin[z] gives the arc sine of the complex number z."
ArcSinh::usage = "ArcSinh[z] gives the inverse hyperbolic sine of the complex number z."
ArcTan::usage = "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::usage = "ArcTanh[z] gives the inverse hyperbolic tangent of the complex number z."
Arg::usage = "Arg[z] gives the argument of the complex number z."
ArithmeticGeometricMean::usage = "ArithmeticGeometricMean[a, b] gives the arithmetic-geometric mean of a and b."
Array::usage = "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::usage = "AspectRatio is an option for Show and related functions which specifies the ratio of height to width for a plot."
AtomQ::usage = "AtomQ[expr] yields True if expr is an expression which cannot be divided into subexpressions, and yields False otherwise."
Attributes::usage = "Attributes[symbol] gives the list of attributes for a symbol."
Automatic::usage = "Automatic represents an option value that is to be chosen automatically by a built-in function."
Auxiliary::usage = "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::usage = "Axes is an option for graphics functions that specifies whether axes should be drawn."
AxesEdge::usage = "AxesEdge is an option for 3D graphics functions that specifies on which edges of the bounding box axes should be drawn."
AxesLabel::usage = "AxesLabel is an option for graphics functions that specifies labels for axes."
AxesOrigin::usage = "AxesOrigin is an option for two-dimensional graphics functions which specifies where any axes drawn should cross."
AxesStyle::usage = "AxesStyle is an option for graphics functions which specifies how axes should be rendered."
Background::usage = "Background is an option for graphics functions which specifies the background color to use."
BaseForm::usage = "BaseForm[expr, n] prints with the numbers in expr given in base n."
$BatchInput::usage = "$BatchInput is True if input in the current session is being fed directly to the Mathematica kernel in batch mode."
$BatchOutput::usage = "$BatchOutput is True if output in the current session is being sent in batch mode, suitable for reading by other programs."
Begin::usage = "Begin[\"context`\"] resets the current context."
BeginPackage::usage = "BeginPackage[\"context`\"] makes context` and System` the only active contexts. BeginPackage[\"context`\", {\"need1`\", \"need2`\", ...}] calls Needs on the needi."
Below::usage = "Below is used to specify alignment in printforms such as ColumnForm and TableForm."
BernoulliB::usage = "BernoulliB[n] gives the nth Bernoulli number. BernoulliB[n, x] gives the nth Bernoulli polynomial."
BesselI::usage = "BesselI[n, z] gives the modified Bessel function of the first kind I(n, z)."
BesselJ::usage = "BesselJ[n, z] gives the Bessel function of the first kind J(n, z)."
BesselK::usage = "BesselK[n, z] gives the modified Bessel function of the second kind K(n, z)."
BesselY::usage = "BesselY[n, z] gives the Bessel function of the second kind Y(n, z)."
Beta::usage = "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::usage = "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::usage = "Binomial[n, m] gives the binomial coefficient."
Blank::usage = "_ 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::usage = "BlankForm is an internal symbol used for formatting and printing."
BlankNullSequence::usage = "___ (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::usage = "__ (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::usage = "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::usage = "Bottom is a setting for the TableAlignments option of TableForm."
Boxed::usage = "Boxed is an option for Graphics3D which specifies whether to draw the edges of the bounding box in a three-dimensional picture."
BoxRatios::usage = "BoxRatios is an option for Graphics3D and SurfaceGraphics which gives the ratios of side lengths for the bounding box of the three-dimensional picture."
BoxStyle::usage = "BoxStyle is an option for three-dimensional graphics functions which specifies how the bounding box should be rendered."
Break::usage = "Break[ ] exits the nearest enclosing Do, For or While."
Byte::usage = "Byte represents a single byte of data in Read."
ByteCount::usage = "ByteCount[expr] gives the number of bytes used internally by Mathematica to store expr."
C::usage = "C[i] is the default form for the i-th constant of integration produced in solving a differential equation with DSolve."
CallProcess::usage = "CallProcess[\"command\", f, {x1, x2, ...}] calls the function f in an external process, with arguments xi. (CallProcess has been superseded by MathLink operations.)"
Cancel::usage = "Cancel[expr] cancels out common factors in the numerator and denominator of expr."
Cases::usage = "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::usage = "Catalan is Catalan's constant, with numerical value 0.915966...."
Catch::usage = "Catch[expr] returns the argument of the first Throw generated in the evaluation of expr."
Ceiling::usage = "Ceiling[x] gives the smallest integer greater than or equal to x."
CellArray::usage = "CellArray[{{a11, a12, ...}, ...}] is a two-dimensional graphics  primitive which represents a rectangular array of gray cells."
Center::usage = "Center is used to specify alignment in printforms such as ColumnForm and TableForm."
CForm::usage = "CForm[expr] prints as a C language version of expr."
Character::usage = "Character represents a single character in Read."
Characters::usage = "Characters[\"string\"] gives a list of the characters in a string."
ChebyshevT::usage = "ChebyshevT[n, x] gives the nth Chebyshev polynomial of the first kind."
ChebyshevU::usage = "ChebyshevU[n, x] gives the nth Chebyshev polynomial of the second kind."
Check::usage = "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::usage = "CheckAbort[expr, failexpr] evaluates expr, returning failexpr if an abort occurs."
Chop::usage = "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::usage = "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::usage = "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::usage = "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::usage = "ClearAttributes[s, attr] removes attr from the list of attributes of the symbol s."
ClebschGordan::usage = "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."
ClipFill::usage = "ClipFill is an option for SurfaceGraphics that specifies how clipped parts of the surface are to be drawn."
Close::usage = "Close[stream] closes a stream."
CMYKColor::usage = "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::usage = "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::usage = "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."
Collect::usage = "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::usage = "ColonForm[a,b] prints as a: b."
ColorFunction::usage = "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."
ColorOutput::usage = "ColorOutput is an option for graphics functions which specifies the type of color output to produce."
Column::usage = "Column is a setting for the TableDirections option of TableForm."
ColumnForm::usage = "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::usage = "$CommandLine is a list of strings giving the elements of the original operating system command line with which Mathematica was invoked."
Compile::usage = "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::usage = "Compiled is an option for various numerical and plotting functions which specifies whether the expressions they work with should automatically be compiled."
CompiledFunction::usage = "CompiledFunction[args, nregs, instr, func] represents compiled code for evaluating a compiled function."
Complement::usage = "Complement[eall, e1, e2, ...] gives the elements in eall which are not in any of the ei."
Complex::usage = "Complex is the head used for complex numbers."
ComplexExpand::usage = "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::usage = "ComplexInfinity represents a quantity with infinite magnitude, but undetermined complex phase."
Compose::usage = "Compose is an obsolete function, superseded by Composition.\n Compose[a,b,c,d] gives a[b[c[d]]]."
ComposeList::usage = "ComposeList[{f1, f2, ...}, x] generates a list of the form {x, f1[x], f2[f1[x]], ...}."
ComposeSeries::usage = "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::usage = "Composition[f1, f2, f3, ...] represents a composition of the functions f1, f2, f3, ...."
CompoundExpression::usage = "expr1; expr2; ... evaluates the expri in turn, giving the last one as the result."
Condition::usage = "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::usage = "$ConditionHold is an internal symbol."
Conjugate::usage = "Conjugate[z] gives the complex conjugate of the complex number z."
Constant::usage = "Constant is an attribute which indicates zero derivative of a symbol with respect to all parameters."
Constants::usage = "Constants is an option for Dt which gives a list of objects to be taken as constants."
ConstrainedMax::usage = "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::usage = "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::usage = "Context[ ] gives the current context. Context[symbol] gives the context in which a symbol appears."
Contexts::usage = "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::usage = "ContextToFilename[\"context`\"] gives the string specifying the file name that is by convention associated with a particular context."
Continuation::usage = "Continuation[n] is output at the beginning of the nth line in a multiline printed expression."
Continue::usage = "Continue[ ] exits to the nearest enclosing Do, For or While in a procedural program."
ContourGraphics::usage = "ContourGraphics[array] is a representation of a contour plot."
ContourLevels::usage = "ContourLevels is an obsolete graphics option, superseded by Contours."
ContourLines::usage = "ContourLines is an option for contour plots which specifies whether to draw explicit contour lines."
ContourPlot::usage = "ContourPlot[f, {x, xmin, xmax}, {y, ymin, ymax}] generates a contour plot of f as a function of x and y."
Contours::usage = "Contours is an option for ContourGraphics specifying the contours to use."
ContourShading::usage = "ContourShading is an option for contour plots which specifies whether the regions between contour lines should be shaded."
ContourSmoothing::usage = "ContourSmoothing is an option for contour plots which specifies how contour lines should be smoothed."
ContourSpacing::usage = "ContourSpacing is an obsolete graphics option, superseded by Contours."
ContourStyle::usage = "ContourStyle is an option for contour plots that specifies the style in which contour lines should be drawn."
CopyDirectory::usage = "CopyDirectory[\"dir1\", \"dir2\"] copies the directory dir1 to dir2."
CopyFile::usage = "CopyFile[\"file1\", \"file2\"] copies file1 to file2."
Cos::usage = "Cos[z] gives the cosine of z."
Cosh::usage = "Cosh[z] gives the hyperbolic cosine of z."
CoshIntegral::usage = "CoshIntegral[x] gives the hyperbolic cosine integral EulerGamma + Log[x] + Integrate[(Cosh[t] - 1)/t, {t, 0, x}]."
CosIntegral::usage = "CosIntegral[x] gives the cosine integral EulerGamma + Log[x] + Integrate[(Cos[t] - 1)/t, {t, 0, x}]."
Cot::usage = "Cot[z] gives the cotangent of z."
Coth::usage = "Coth[z] gives the hyperbolic cotangent of z."
Count::usage = "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::usage = "CreateDirectory[\"dir\"] creates a directory."
$CreationDate::usage = "$CreationDate gives the date and time at which the particular release of the Mathematica kernel you are running was created."
Csc::usage = "Csc[z] gives the cosecant of z."
Csch::usage = "Csch[z] gives the hyperbolic cosecant of z."
Cubics::usage = "Cubics is an option for Roots and related functions which specifies whether explicit solutions should be generated for irreducible cubic equations."
Cuboid::usage = "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::usage = "Cyclotomic[n, x] gives the cyclotomic polynomial of order n in x."
D::usage = "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::usage = "DampingFactor is an option for FindRoot, which can be used to control convergence behavior. "
Dashing::usage = "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."
Date::usage = "Date[ ] gives the current local date and time in the form {year, month, day, hour, minute, second}."
Debug::usage = "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::usage = "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::usage = "Decompose[poly, x] decomposes a polynomial, if possible, into a composition of simpler polynomials."
Decrement::usage = "x-- decreases the value of x by 1, returning the old value of x."
Default::usage = "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::usage = "DefaultColor is an option for graphics functions which specifies the default color to use for lines, points, etc."
$DefaultFont::usage = "$DefaultFont gives the default font to use for text in graphics."
DefaultFont::usage = "DefaultFont is an option for graphics functions which specifies the default font to use for text."
DefaultValues::usage = "DefaultValues[f] gives a list of transformation rules corresponding to all defaults (values for Default[f[x,..],..], etc.) defined for the symbol f."
Definition::usage = "Definition[s1, s2, ...] prints as the definitions given for the symbols si."
Degree::usage = "Degree gives the number of radians in one degree. It has a numerical value of Pi/180."
Delete::usage = "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::usage = "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::usage = "DeleteContents is an option to DeleteDirectory that specifies whether the directory is to be deleted if it is not empty."
DeleteDirectory::usage = "DeleteDirectory[\"dir\"] deletes the specified directory."
DeleteFile::usage = "DeleteFile[\"file\"] deletes a file. DeleteFile[{\"file1\", \"file2\", ...}] deletes a list of files."
Denominator::usage = "Denominator[expr] gives the denominator of expr."
DensityGraphics::usage = "DensityGraphics[array] is a representation of a density plot."
DensityPlot::usage = "DensityPlot[f, {x, xmin, xmax}, {y, ymin, ymax}] makes a density plot of f as a function of x and y."
Depth::usage = "Depth[expr] gives the maximum number of indices needed to specify any part of expr, plus one."
Derivative::usage = "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::usage = "Det[m] gives the determinant of the square matrix m."
DiagonalMatrix::usage = "DiagonalMatrix[list] gives a matrix with the elements of list on the leading diagonal, and 0 elsewhere."
Dialog::usage = "Dialog[ ] initiates a dialog. Dialog[expr] initiates a dialog with expr as the current value of %."
DialogIndent::usage = "DialogIndent[d] is printed as the indentation for input and output lines in a depth d dialog."
DialogProlog::usage = "DialogProlog is an option for Dialog which can give an expression to evaluate before the dialog starts."
DialogSymbols::usage = "DialogSymbols is an option for Dialog which gives a list of symbols whose values should be localized in the dialog."
DigitBlock::usage = "DigitBlock is an option for NumberForm and related functions which specifies the maximum length of blocks of digits between breaks."
DigitQ::usage = "DigitQ[string] yields True if all the characters in the string are digits in the range 0 through 9, and yields False otherwise."
Digits::usage = "Digits is an obsolete function, superseded by IntegerDigits and RealDigits.\n 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::usage = "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::usage = "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::usage = "Direction is an option for Limit which specifies the direction towards which to approach the limit."
Directory::usage = "Directory[ ] gives the current working directory."
DirectoryStack::usage = "DirectoryStack[ ] gives the directory stack which represents the sequence of current directories used."
Disk::usage = "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::usage = "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::usage = "$Display gives a list of files and pipes to be used with the default $DisplayFunction."
Display::usage = "Display[channel, graphics] writes graphics or sound to the specified output channel."
$DisplayFunction::usage = "$DisplayFunction gives the default setting for the option DisplayFunction in graphics functions."
DisplayFunction::usage = "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."
Distribute::usage = "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::usage = "x/y or Divide[x, y] is equivalent to x y^-1."
DivideBy::usage = "x /= c divides x by c and returns the new value of x."
Divisors::usage = "Divisors[n] gives a list of the integers that divide n."
DivisorSigma::usage = "DivisorSigma[k, n] gives the sum of the kth powers of the positive divisors of n."
Do::usage = "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::usage = "a.b.c or Dot[a, b, c] gives products of vectors, matrices and tensors."
DoubleExponential::usage = "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::usage = "DoublyInfinite is an option for LerchPhi, which specifies the range of the summation variable. The possible values for the option are True and False."
DownValue::usage = "DownValue is an obsolete function, superseded by DownValues.\n DownValues[f] gives a list of transformation rules corresponding to all downvalues (values for f[x,..], etc.) defined for the symbol f."
DownValues::usage = "DownValues[f] gives a list of transformation rules corresponding to all downvalues defined for the symbol f."
Drop::usage = "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::usage = "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::usage = "DSolveConstants is an option to DSolve that determines the constants of integration which may be returned."
Dt::usage = "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::usage = "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::usage = "$DumpDates gives the list of all dates and times at which Dump was used in creating the Mathematica system you are running."
$DumpSupported::usage = "$DumpSupported is True if Dump can be used in the version of Mathematica you are running, and is False otherwise."
E::usage = "E is the exponential constant e (base of natural logarithms), with numerical value 2.71828...."
$Echo::usage = "$Echo gives a list of files and pipes to which all input is echoed."
EdgeForm::usage = "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::usage = "Edit[expr___] lets you edit the expressions expr."
EditDef::usage = "EditDef is the obsolete name of EditDefinition."
EditDefinition::usage = "EditDefinition[syms___] lets you edit the rules  attached to the symbols syms."
EditIn::usage = "EditIn[n__Integer] lets you edit input lines n.  EditIn[] edits the previous input line."
Eigensystem::usage = "Eigensystem[m] gives a list {values, vectors} of the eigenvalues and eigenvectors of the square matrix m."
Eigenvalues::usage = "Eigenvalues[m] gives a list of the eigenvalues of the square matrix m."
Eigenvectors::usage = "Eigenvectors[m] gives a list of the eigenvectors of the square matrix m."
Eliminate::usage = "Eliminate[eqns, vars] eliminates variables between a set of simultaneous equations."
EllipticE::usage = "EllipticE[m] gives the complete elliptic integral E(m). EllipticE[phi, m] gives the elliptic integral of the second kind E(phi|m)."
EllipticExp::usage = "EllipticExp[u, {a, b}] gives the generalized exponential associated with the elliptic curve y^2 = x^3 + a x^2 + b x."
EllipticExpPrime::usage = "EllipticExpPrime[u, {a, b}] gives the derivative with respect to the first argument of EllipticExp[u, {a, b}]."
EllipticF::usage = "EllipticF[phi, m] gives the elliptic integral of the first kind F(phi|m)."
EllipticK::usage = "EllipticK[m] gives the complete elliptic integral of the first kind K(m)."
EllipticLog::usage = "EllipticLog[{x, y}, {a, b}] gives the generalized logarithm associated with the elliptic curve y^2 == x^3 + a x^2 + b x."
EllipticNomeQ::usage = "EllipticNomeQ[m] gives the nome q == Exp[-Pi EllipticK[1-m]/EllipticK[m]]."
EllipticPi::usage = "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::usage = "EllipticTheta[i, z, q] gives the elliptic theta function theta_i(z, q), where i = 1, 2, 3, or 4."
EllipticThetaC::usage = "EllipticThetaC[u, m] gives Neville's elliptic theta function theta_c(u, m)."
EllipticThetaD::usage = "EllipticThetaD[u, m] gives Neville's elliptic theta function theta_d(u, m)."
EllipticThetaN::usage = "EllipticThetaN[u, m] gives Neville's elliptic theta function theta_n(u, m)."
EllipticThetaPrime::usage = "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::usage = "EllipticThetaS[u, m] gives Neville's elliptic theta function theta_s(u, m)."
Encode::usage = "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::usage = "End[ ] returns the present context, and reverts to the previous one."
EndAdd::usage = "EndAdd[ ] returns the present context, and reverts to the previous one, prepending the present context to $ContextPath."
EndOfFile::usage = "EndOfFile is a symbol returned by Read when it reaches the end of a file."
EndPackage::usage = "EndPackage[ ] restores $Context and $ContextPath to their values before the preceding BeginPackage, and prepends the current context to the list $ContextPath."
EndProcess::usage = "EndProcess[\"command\"] terminates an external process in which functions could be called from Mathematica. (EndProcess has been superseded by MathLink operations.)"
EngineeringForm::usage = "EngineeringForm[expr] prints with all real numbers in expr given in engineering notation."
Environment::usage = "Environment[\"var\"] gives the value of an operating system environment variable."
$Epilog::usage = "$Epilog is a symbol whose value, if any, is evaluated when a dialog or a Mathematica session is terminated."
Epilog::usage = "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::usage = "lhs == rhs returns True if lhs and rhs are identical."
EquatedTo::usage = "EquatedTo is an option for Roots, which specifies an expression to use in place of the variable in the solution."
Erf::usage = "Erf[z] gives the error function erf(z). Erf[z0, z1] gives the generalized error function erf(z1) - erf(z0)."
Erfc::usage = "Erfc[z] gives the complementary error function erfc(z) == 1 - erf(z)."
Erfi::usage = "Erfi[z] gives the imaginary error function erfi(z) == -i erf(i z)."
EulerE::usage = "EulerE[n] gives the nth Euler number. EulerE[n, x] gives the nth Euler polynomial."
EulerGamma::usage = "EulerGamma is Euler's constant gamma, with numerical value 0.577216...."
EulerPhi::usage = "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::usage = "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."
EvenQ::usage = "EvenQ[expr] gives True if expr is an even integer, and False otherwise."
Exit::usage = "Exit[ ] terminates a Mathematica session."
Exp::usage = "Exp[z] is the exponential function."
Expand::usage = "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::usage = "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::usage = "ExpandDenominator[expr] expands out products and powers that appear as denominators in expr."
ExpandNumerator::usage = "ExpandNumerator[expr] expands out products and powers that appear in the numerator of expr."
ExpIntegralE::usage = "ExpIntegralE[n, z] gives the exponential integral function E(n,z)."
ExpIntegralEi::usage = "ExpIntegralEi[z] gives the exponential integral function Ei(z)."
Exponent::usage = "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::usage = "ExponentFunction is an option for NumberForm and related functions which determines the exponent to use in printing approximate real numbers."
ExponentStep::usage = "(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::usage = "Expression is a symbol that represents an ordinary Mathematica expression in Read and related functions."
ExtendedGCD::usage = "ExtendedGCD[n, m] gives the extended greatest common divisor of the integers n and m."
FaceForm::usage = "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::usage = "FaceGrids is an option for three-dimensional graphics functions that specifies grid lines to draw on the faces of the bounding box."
Factor::usage = "Factor[poly] factors a polynomial over the integers. Factor[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorComplete::usage = "FactorComplete is an option for FactorInteger which specifies whether complete factorization is to be performed."
Factorial::usage = "n! gives the factorial of n."
Factorial2::usage = "n!! gives the double factorial of n."
FactorInteger::usage = "FactorInteger[n] gives a list of the prime factors of the integer n, together with their exponents."
FactorList::usage = "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::usage = "FactorSquareFree[poly] writes a polynomial as a product of square-free factors. FactorSquareFree[poly, Modulus->p] factors a polynomial modulo a prime p."
FactorSquareFreeList::usage = "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::usage = "FactorTerms[poly] pulls out any overall numerical factor in poly."
FactorTermsList::usage = "FactorTermsList[poly] pulls out any overall numerical factor in poly and returns a list of factors."
Fail::usage = "Fail is a special symbol returned by evaluation of an obsolete use of Condition."
$Failed::usage = "$Failed is a special symbol returned by certain functions when they cannot do what they were asked to do."
$$Failure2::usage = "$$Failure2 is an internal symbol."
False::usage = "False is the symbol for the Boolean value false."
File::usage = "File is a possible value returned by FileType and related functions to indicate the type of a file."
FileByteCount::usage = "FileByteCount[\"file\"] gives the number of bytes in a file."
FileDate::usage = "FileDate[\"file\"] gives the date and time at which a file was last modified."
FileInformation::usage = "FileInformation[file] gives information about a file."
FileNames::usage = "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::usage = "FileType[\"file\"] gives the type of a file, typically File, Directory or None."
Find::usage = "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::usage = "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::usage = "FindMinimum[f, {x, x0}] searches for a local minimum in f, starting from the point x=x0."
FindRoot::usage = "FindRoot[lhs == rhs, {x, x0}] searches for a numerical solution to the equation lhs == rhs, starting with x == x0."
First::usage = "First[expr] gives the first element in expr."
Fit::usage = "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::usage = "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::usage = "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::usage = "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::usage = "Flatten[list] flattens out nested lists. Flatten[list, n] flattens to level n. Flatten[list, n, h] flattens subexpressions with head h."
FlattenAt::usage = "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::usage = "Floor[x] gives the greatest integer less than or equal to x."
Fold::usage = "Fold[f, x, list] gives the last element of FoldList[f, x, list]."
FoldList::usage = "FoldList[f, x, {a, b, ...}] gives {x, f[x, a], f[f[x, a], b], ...}."
Font::usage = "Font is an internal symbol used for formatting and printing."
FontForm::usage = "FontForm[expr, {\"font\", size}] specifies that expr should be printed in the specified font and size."
$$Fonts::usage = "$$Fonts is an internal symbol."
For::usage = "For[start, test, incr, body] executes start, then repeatedly evaluates body and incr until test fails to give True."
Format::usage = "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::usage = "FormatType is an option for output streams which specifies the default format type used when printing expressions."
FormatValues::usage = "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::usage = "FortranForm[expr] prints as a Fortran language version of expr."
Fourier::usage = "Fourier[list] finds the discrete Fourier transform of a list of complex numbers."
Frame::usage = "Frame is an option for two-dimensional graphics functions which specifies whether a frame should be drawn around the plot."
Framed::usage = "Framed is an obsolete graphics option, superseded by Frame."
FrameLabel::usage = "FrameLabel is an option for two-dimensional graphics functions that specifies labels to be placed on the edges of a frame around a plot."
FrameStyle::usage = "FrameStyle is an option for two-dimensional graphics functions that specifies how the edges of a frame should be rendered."
FrameTicks::usage = "FrameTicks is an option for two-dimensional graphics functions that specifies tick marks for the edges of a frame."
FreeQ::usage = "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::usage = "FresnelC[x] gives the Fresnel integral C[x] = Integrate[Cos[Pi t^2/2], {t, 0, x}]."
FresnelS::usage = "FresnelS[x] gives the Fresnel integral S[x] = Integrate[Sin[Pi t^2/2], {t, 0, x}]."
FromASCII::usage = "FromASCII is an obsolete function, superseded by FromCharacterCode.\n FromASCII[\"c\"] gives the ASCII integer code corresponding to the character c."
FromCharacterCode::usage = "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::usage = "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::usage = "FullAxes[graphics] returns the axes options of a graphics object."
FullDefinition::usage = "FullDefinition[s1, s2, ...] prints as the definitions given for the symbols si, and all symbols on which these depend."
FullForm::usage = "FullForm[expr] prints as the full form of expr, with no special syntax."
FullGraphics::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "GaussianIntegers is an option for FactorInteger, PrimeQ, Factor and related functions which specifies whether factorization should be done over Gaussian integers."
GaussKronrod::usage = "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::usage = "GaussPoints is an option for NIntegrate, which is used to specify the number of points in the Gaussian part of Gauss-Kronrod quadrature."
GCD::usage = "GCD[n1, n2, ...] gives the greatest common divisor of the integers ni."
GegenbauerC::usage = "GegenbauerC[n, m, x] gives the nth Gegenbauer polynomial."
General::usage = "General is a symbol to which general system messages are attached."
Generic::usage = "Generic is a setting for the Mode option of Solve and related functions."
Get::usage = "<<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::usage = "GetContext[\"context`\"] loads the file named by ContextToFilename[\"context`\"], which gives the conventional filename for a package that defines \"context`\"."
GoldenRatio::usage = "GoldenRatio is the golden ratio (1 + Sqrt[5])/2, with numerical value 1.61803...."
Goto::usage = "Goto[tag] scans the current compound expression for Label[tag], and transfers control to that point."
Gradient::usage = "Gradient is an option for FindMinimum, which can be used to specify the Gradient of the function whose minimum is being sought. "
Graphics::usage = "Graphics[primitives, options] represents a two-dimensional graphical image."
GraphicsArray::usage = "GraphicsArray[{g1, g2, ...}] represents a row of graphics objects. GraphicsArray[{{g11, g12, ...}, ...}] represents a two-dimensional array of graphics objects."
GraphicsSpacing::usage = "GraphicsSpacing is an option for GraphicsArray which specifies the spacing between elements in the array."
Graphics3D::usage = "Graphics3D[primitives, options] represents a three-dimensional graphical image."
GrayLevel::usage = "GrayLevel[level] is a graphics directive which specifies the gray-level intensity with which graphical objects that follow should be displayed."
Greater::usage = "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::usage = "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::usage = "GridLines is an option for two-dimensional graphics functions that specifies grid lines."
GroebnerBasis::usage = "GroebnerBasis[{poly1, poly2, ...}, {x1, x2, ...}] gives a list of polynomials which form a Groebner basis for the ideal generated by the polyi."
Hash::usage = "Hash[expr] gives an integer hash code for any expression expr."
HashTable::usage = "HashTable is a part of the object which is returned by Dispatch."
Head::usage = "Head[expr] gives the head of expr."
HeadCompose::usage = "HeadCompose[a, b, c, d] gives a[b][c][d]."
Headers::usage = "Headers specifies whether output on this channel should be preceded by notebook headers. "
Heads::usage = "Heads is an option for functions which use level specifications that specifies whether heads of expressions should be included."
HeldPart::usage = "HeldPart[expr, pos] extracts the part or parts specified by pos, and wraps each of them in Hold."
HermiteH::usage = "HermiteH[n, x] gives the nth Hermite polynomial."
HiddenSurface::usage = "HiddenSurface is an option for SurfaceGraphics which specifies whether hidden surfaces are to be eliminated."
Hold::usage = "Hold[expr] maintains expr in an unevaluated form."
HoldAll::usage = "HoldAll is an attribute which specifies that all arguments to a function are to be maintained in an unevaluated form."
HoldFirst::usage = "HoldFirst is an attribute which specifies that the first argument to a function is to be maintained in an unevaluated form."
HoldForm::usage = "HoldForm[expr] prints as the expression expr, with expr maintained in an unevaluated form."
HoldRest::usage = "HoldRest is an attribute which specifies that all but the first argument to a function are to be maintained in an unevaluated form."
HomeDirectory::usage = "HomeDirectory[ ] gives your \"home\" directory."
HorizontalForm::usage = "HorizontalForm is an internal symbol used for formatting and printing."
Hue::usage = "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::usage = "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::usage = "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::usage = "HypergeometricU[a, b, z] is the confluent hypergeometric function U(a, b, z)."
Hypergeometric0F1::usage = "Hypergeometric0F1[a, z] is the hypergeometric function 0F1(; a; z)."
Hypergeometric0F1Regularized::usage = "Hypergeometric0F1Regularized[a, z] is the hypergeometric function 0F1(; a; z)/Gamma(a)."
Hypergeometric1F1::usage = "Hypergeometric1F1[a, b, z] is the Kummer confluent hypergeometric function 1F1(a; b; z)."
Hypergeometric1F1Regularized::usage = "Hypergeometric1F1Regularized[a, b, z] is the Kummer confluent hypergeometric function 1F1(a; b; z)/Gamma(b)."
Hypergeometric2F1::usage = "Hypergeometric2F1[a, b, c, z] is the hypergeometric function 2F1(a, b; c; z)."
Hypergeometric2F1Regularized::usage = "Hypergeometric2F1Regularized[a, b, c, z] is the hypergeometric function 2F1(a, b; c; z)/Gamma(c)."
I::usage = "I represents the imaginary unit Sqrt[-1]."
Identity::usage = "Identity[expr] gives expr (the identity operation)."
IdentityMatrix::usage = "IdentityMatrix[n] gives the n X n identity matrix."
If::usage = "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::usage = "IgnoreCase is an option for string manipulation and searching functions which specifies whether lower- and upper-case letters should be treated as equivalent."
$IgnoreEOF::usage = "$IgnoreEOF specifies whether Mathematica should terminate when it receives an end-of-file character as input."
Im::usage = "Im[z] gives the imaginary part of the complex number z."
Implies::usage = "Implies[p, q] represents the logical implication p => q."
In::usage = "In[n] is a global object that is assigned to have a delayed value of the nth input line."
IncludeSingularTerm::usage = "IncludeSingularTerm is an option for LerchPhi and Zeta, which specifies whether terms of the form (k + a)^-s with k + a == 0 are to be included."
Increment::usage = "x++ increases the value of x by 1, returning the old value of x."
Indent::usage = "Indent[d] is printed as the indentation for a depth d subexpression."
Indeterminate::usage = "Indeterminate is a symbol that represents a numerical quantity whose magnitude cannot be determined."
Inequality::usage = "Inequality represents a sequence of relational statements."
Infinity::usage = "Infinity is a symbol that represents a positive infinite quantity."
Infix::usage = "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::usage = "Information[symbol] prints information about a symbol."
Inner::usage = "Inner[f, list1, list2, g] is a generalization of Dot in which f plays the role of multiplication and g of addition."
$Input::usage = "$Input is a global variable whose value is the name of the stream from which input to Mathematica is currently being sought."
Input::usage = "Input[ ] interactively reads in one Mathematica expression. Input[\"prompt\"] requests input, using the specified string as a prompt."
InputForm::usage = "InputForm[expr] prints as a version of expr suitable for input to Mathematica."
InputStream::usage = "InputStream[\"name\", n] is an object that represents an input stream for functions such as Read and Find."
InputString::usage = "InputString[ ] interactively reads in a character string. InputString[\"prompt\"] requests input, using the specified string as a prompt."
Insert::usage = "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::usage = "$Inspector is a global variable which gives a function to apply when the inspector is invoked from an interrupt menu."
Install::usage = "Install[\"command\"] starts an external program and installs Mathematica definitions to call functions in it."
InString::usage = "InString[n] is a global object that is assigned to be the text of the nth input line."
Integer::usage = "Integer is the head used for integers."
IntegerDigits::usage = "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 if n."
IntegerQ::usage = "IntegerQ[expr] gives True if expr is an integer, and False otherwise."
Integrate::usage = "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::usage = "InterpolatingFunction[range, table] represents an approximate function whose values are found by interpolation."
InterpolatingPolynomial::usage = "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::usage = "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::usage = "InterpolationOrder is an option to Interpolation that specifies the order of the fitting polynomial."
Interrupt::usage = "Interrupt[ ] generates an interrupt."
Intersection::usage = "Intersection[list1, list2, ...] gives a sorted list of the elements common to all the listi."
Inverse::usage = "Inverse[m] gives the inverse of a square matrix m."
InverseFourier::usage = "InverseFourier[list] finds the discrete inverse Fourier transform of a list of complex numbers."
InverseFunction::usage = "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::usage = "InverseFunctions is an option to Solve and related functions which specifies whether inverse functions should be used."
InverseJacobiCD::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "InverseWeierstrassP[{P, P'}, g2, g3] gives the 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::usage = "$IterationLimit gives the maximum length of evaluation chain used in trying to evaluate any expression."
JacobiAmplitude::usage = "JacobiAmplitude[u, m] gives the amplitude for Jacobi elliptic functions."
Jacobian::usage = "Jacobian is an option for FindRoot that can be used to specify the Jacobian of the system of functions whose root is being sought. "
JacobiCD::usage = "JacobiCD[u, m] gives the Jacobi elliptic function cd at u for the parameter m."
JacobiCN::usage = "JacobiCN[u, m] gives the Jacobi elliptic function cn at u for the parameter m."
JacobiCS::usage = "JacobiCS[u, m] gives the Jacobi elliptic function cs at u for the parameter m."
JacobiDC::usage = "JacobiDC[u, m] gives the Jacobi elliptic function dc at u for the parameter m."
JacobiDN::usage = "JacobiDN[u, m] gives the Jacobi elliptic function dn at u for the parameter m."
JacobiDS::usage = "JacobiDS[u, m] gives the Jacobi elliptic function ds at u for the parameter m."
JacobiNC::usage = "JacobiNC[u, m] gives the Jacobi elliptic function nc at u for the parameter m."
JacobiND::usage = "JacobiND[u, m] gives the Jacobi elliptic function nd at u for the parameter m."
JacobiNS::usage = "JacobiNS[u, m] gives the Jacobi elliptic function ns at u for the parameter m."
JacobiP::usage = "JacobiP[n, a, b, x] gives the nth Jacobi polynomial."
JacobiSC::usage = "JacobiSC[u, m] gives the Jacobi elliptic function sc at u for the parameter m."
JacobiSD::usage = "JacobiSD[u, m] gives the Jacobi elliptic function sd at u for the parameter m."
JacobiSN::usage = "JacobiSN[u, m] gives the Jacobi elliptic function sn at u for the parameter m."
JacobiSymbol::usage = "JacobiSymbol[n, m] gives the Jacobi symbol of n and m."
JacobiZeta::usage = "JacobiZeta[phi, m] gives Jacobi's Zeta function Z(phi|m)."
Join::usage = "Join[list1, list2, ...] concatenates lists together. Join can be used on any set of expressions that have the same head."
JordanForm::usage = "JordanForm[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::usage = "Label[tag] represents a point in a compound expression to which control can be transferred using Goto."
LaguerreL::usage = "LaguerreL[n, x] gives the nth Laguerre polynomial. LaguerreL[n, a, x] gives the nth generalized Laguerre polynomial."
$Language::usage = "$Language is a list of strings which give the names of languages to use for messages."
Last::usage = "Last[expr] gives the last element in expr."
LatticeReduce::usage = "LatticeReduce[{v1, v2, ...}] gives a reduced basis for the set of integer vectors vi."
LCM::usage = "LCM[n1, n2, ...] gives the least common multiple of the integers ni."
LeafCount::usage = "LeafCount[expr] gives the total number of indivisible subexpressions in expr."
Left::usage = "Left is used to specify alignment in printforms such as ColumnForm and TableForm."
LegendreP::usage = "LegendreP[n, x] gives the nth Legendre polynomial. LegendreP[n, m, x] gives the associated Legendre polynomial."
LegendreQ::usage = "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::usage = "LegendreType is an option for LegendreP and LegendreQ which specifies choices of branch cuts for Legendre functions in the complex plane."
Length::usage = "Length[expr] gives the number of elements in expr."
LerchPhi::usage = "LerchPhi[z, s, a] gives the Lerch transcendent Phi(z, s, a)."
Less::usage = "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::usage = "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::usage = "LetterQ[string] yields True if all the characters in the string are letters, and yields False otherwise."
$Letters::usage = "$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::usage = "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::usage = "Lighting is an option to Graphics3D and related functions that specifies whether to use simulated illumination in three-dimensional pictures."
LightSources::usage = "LightSources is an option to Graphics3D and related functions that specifies the properties of point light sources for simulated illumination."
Limit::usage = "Limit[expr, x->x0] finds the limiting value of expr when x approaches x0."
$Line::usage = "$Line is a global variable that specifies the number of the current input line."
Line::usage = "Line[{pt1, pt2, ...}] is a graphics primitive which represents a line joining a sequence of points."
LinearProgramming::usage = "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::usage = "LinearSolve[m, b] gives the vector x which solves the matrix equation m.x==b."
LineBreak::usage = "LineBreak[n] is output between the nth and (n+1)th lines in a multiline printed expression."
LineForm::usage = "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."
LinkBadInput::usage = "LinkBadInput[e] is called by Mathematica in packets mode when the expression e it has received from $ParentLink is not a legal packet."
LinkClose::usage = "LinkClose[link] closes a previously opened MathLink connection."
LinkConnectedQ::usage = "LinkConnectedQ[\"name\"] checks if a socket-based MathLink is connected to another process."
$Linked::usage = "$Linked is True if the Mathematica kernel is being run through MathLink."
LinkError::usage = "LinkError[link] returns error information for link in the form { errorNumber, errorExplanation }."
LinkInterrupt::usage = "LinkInterrupt[link] sends an interrupt signal to an external program over MathLink."
LinkObject::usage = "LinkObject[integer] represents a link to an external process started using LinkOpen."
LinkOpen::usage = "LinkOpen[\"command\"] returns a MathLink connection to the external program command."
LinkPatterns::usage = "LinkPatterns[link] gives the list of patterns defined in the external package which is accessed via the specified link."
LinkRead::usage = "LinkRead[link] reads an expression via LinkObject from link."
LinkReadHeld::usage = "LinkReadHeld[link] reads an expression via LinkObject from link and returns it wrapped in Hold."
LinkReadyQ::usage = "LinkReadyQ[link] returns True if the link has incoming data ready to be read by LinkRead."
Links::usage = "Links[] returns a list of all active MathLinks."
$LinkSupported::usage = "$LinkSupported is True if MathLink can be used in the version of Mathematica you are running, and is False otherwise."
LinkWrite::usage = "LinkWrite[link, expr, (flush:True)] writes expr via MathLink to link (synchronizing unless flush is False)."
LinkWriteHeld::usage = "LinkWriteHeld[link, Hold[expr], (flush:True)] writes expr (without the Hold) via MathLink to link (synchronizing unless flush if False)."
Listable::usage = "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::usage = "ListContourPlot[array] generates a contour plot from an array of height values."
ListDensityPlot::usage = "ListDensityPlot[array] generates a density plot from an array of height values."
ListPlay::usage = "ListPlay[{a1, a2, ...}] plays a sound whose amplitude is given by the sequence of levels ai."
ListPlot::usage = "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::usage = "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::usage = "ListQ[expr] gives True if expr is a list, and False otherwise."
Literal::usage = "Literal[expr] is equivalent to expr for pattern matching, but maintains expr in an unevaluated form."
Locked::usage = "Locked is an attribute which, once assigned, prevents modification of any attributes of a symbol."
Log::usage = "Log[z] gives the natural logarithm of z (logarithm to base E). Log[b, z] gives the logarithm to base b."
LogGamma::usage = "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::usage = "LogicalExpand[expr] expands out expressions containing logical connectives such as && and ||."
LogIntegral::usage = "LogIntegral[z] is the logarithmic integral function li(z)."
LowerCaseQ::usage = "LowerCaseQ[string] yields True if all the characters in the string are lower-case letters, and yields False otherwise."
$MachineEpsilon::usage = "$MachineEpsilon gives the smallest machine-precision number which can be added to 1.0 to give a result not equal to 1.0."
$MachineID::usage = "$MachineID is a string that gives, if possible, a unique identification code for the computer being used."
MachineID::usage = "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."
$MachineName::usage = "$MachineName is a string that gives the assigned name of the computer being used, if such a name is defined."
MachineName::usage = "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."
MachineNumberQ::usage = "MachineNumberQ[x] returns True if x is a machine floating point number, and returns False otherwise."
$MachinePrecision::usage = "$MachinePrecision gives the number of decimal digits of precision used for machine-precision numbers."
$MachineType::usage = "$MachineType is a string giving the general type of computer on which Mathematica is being run."
MainSolve::usage = "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::usage = "MakeRules is an option to Solve and related functions which specifies whether the result is to be presented as an AlgebraicRulesData object."
MantissaExponent::usage = "MantissaExponent[x] gives a list containing the mantissa and exponent of an approximate real number x."
Map::usage = "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::usage = "MapAll[f, expr] or f //@ expr applies f to every subexpression in expr."
MapAt::usage = "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::usage = "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::usage = "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::usage = "MatchBox is an internal symbol."
MatchLocalNameQ::usage = "MatchLocalNameQ is an internal symbol."
MatchLocalNames::usage = "MatchLocalNames is an option for Trace and related functions which specifies whether symbols such as x should match symbols with local names of the form x$nnn."
MatchQ::usage = "MatchQ[expr, form] returns True if the pattern form matches expr, and returns False otherwise."
MatrixExp::usage = "MatrixExp[mat] gives the matrix exponential of mat."
MatrixForm::usage = "MatrixForm[list] prints with the elements of list arranged in a regular array."
MatrixPower::usage = "MatrixPower[mat, n] gives the nth matrix power of mat."
MatrixQ::usage = "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::usage = "Max[x1, x2, ...] yields the numerically largest of the xi. Max[{x1, x2, ...}, {y1, ...}, ...] yields the largest element of any of the lists."
MaxBend::usage = "MaxBend is an option for Plot which measures the maximum bend angle between successive line segments on a curve."
MaxIterations::usage = "MaxIterations is an option for various functions that use an iterative algorithm and is used to specify the maximum number of iterations allowed."
$MaxMachineNumber::usage = "$MaxMachineNumber is the largest machine-precision number that can be used on a particular computer system."
MaxMemoryUsed::usage = "MaxMemoryUsed[ ] gives the maximum number of bytes used to store all data for the current Mathematica session."
$MaxNumber::usage = "$MaxNumber gives the largest representable number."
MaxRecursion::usage = "MaxRecursion is an option for various numerical functions that use a recursive algorithm and is used to specify the maximum depth to which recursion is allowed to go even if convergence is not yet achieved."
MaxSteps::usage = "MaxSteps is an option to NDSolve that determines the maximum number of steps to take."
$$Media::usage = "$$Media is an obsolete symbol, superseded by Streams[ ]."
MemberQ::usage = "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::usage = "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::usage = "MemoryInUse[ ] gives the number of bytes currently being used to store all data in the current Mathematica session."
Mesh::usage = "Mesh is an option for SurfaceGraphics and DensityGraphics that specifies whether an explicit x-y mesh should be drawn."
MeshRange::usage = "MeshRange is an option for ListPlot3D, SurfaceGraphics, ListContourPlot, ListDensityPlot and related functions which specifies the range of x and y coordinates that correspond to the array of z values given."
MeshStyle::usage = "MeshStyle is an option for Plot3D, ContourPlot, DensityPlot and related functions which specifies how mesh lines should be rendered."
Message::usage = "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::usage = "$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::usage = "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::usage = "symbol::tag (or MessageName[symbol, \"tag\"]) is a name for a message."
$MessagePrePrint::usage = "$MessagePrePrint is a global variable whose value, if set, is applied to expressions before they are included in the text of messages."
$Messages::usage = "$Messages gives the list of files and pipes to which message output is sent."
Messages::usage = "Messages[symbol] gives all the messages assigned to a particular symbol."
MetaCharacters::usage = "MetaCharacters is an option to StringPosition that determines which characters, if any, are to have special meanings."
Method::usage = "Method is an option to Solve, related functions, and various numerical functions, which specifies what algorithm to use in evaluating the result."
Min::usage = "Min[x1, x2, ...] yields the numerically smallest of the xi. Min[{x1, x2, ...}, {y1, ...}, ...] yields the smallest element of any of the lists."
$MinMachineNumber::usage = "$MinMachineNumber is the smallest positive machine-precision number that can be used on a particular computer system."
$MinNumber::usage = "$MinNumber gives the smallest (positive) representable number."
Minors::usage = "Minors[m, k] gives a matrix consisting of the determinants of all k X k submatrices of m."
MinRecursion::usage = "MinRecursion is an option for various numerical functions that use a recursive algorithm and is used to specify the minimum depth of recursion to be used before tests for convergence begin."
Minus::usage = "-x is the arithmetic negation of x."
Mod::usage = "Mod[m, n] gives the remainder on division of m by n. The result has the same sign as n."
Mode::usage = "Mode is an option to Solve and related functions that specifies in what sense the equations are to be solved. The valid choices for Mode are Generic, Modular, and Rational."
Modular::usage = "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::usage = "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::usage = "$ModuleNumber gives the current serial number to be used for local variables generated by Unique[ ] or Module[ ]."
Modulus::usage = "Modulus is an option that can be given to various mathematical operations. Modulus->n specifies that numbers should be treated modulo n."
MoebiusMu::usage = "MoebiusMu[n] gives the Moebius function mu(n)."
MultiDimensional::usage = "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::usage = "Multinomial[n1, n2, ...] gives the multinomial coefficient (n1+n2+...)!/(n1! n2! ...)."
Multiplicity::usage = "Multiplicity is an option to Roots that specifies the multiplicity of each of the roots in the final result."
N::usage = "N[expr] gives the numerical value of expr. N[expr, n] does computations to n-digit precision."
NameQ::usage = "NameQ[\"string\"] yields True if there are any symbols whose names match the string pattern given, and yields False otherwise."
Names::usage = "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::usage = "NBernoulliB[n] gives the numerical value of the nth Bernoulli number. NBernoulliB[n, d] gives the result to d-digit precision."
NDSolve::usage = "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."
Needs::usage = "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::usage = "Negative[x] gives True if x is a negative number."
Nest::usage = "Nest[f, expr, n] gives an expression with f applied n times to expr."
NestList::usage = "NestList[f, expr, n] gives a list of the results of applying f to expr 0 through n times."
$NewMessage::usage = "$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::usage = "$NewSymbol is a global variable which, if set, is applied to the name and context of each new symbol that Mathematica creates."
NIntegrate::usage = "NIntegrate[f, {x, xmin, xmax}] gives a numerical approximation to the integral of f with respect to x over the interval xmin to xmax."
NonAssociative::usage = "NonAssociative is a symbol that represents a non-associative operator in formatting functions."
NonCommutativeMultiply::usage = "a ** b ** c is a general associative, but non-commutative, form of multiplication."
NonConstants::usage = "NonConstants is an option for D which gives a list of objects to be taken to depend implicitly on the differentiation variables."
None::usage = "None is a setting used for certain options."
NonNegative::usage = "NonNegative[x] gives True if x is a non-negative number."
Normal::usage = "Normal[expr] converts expr to a normal expression, from a variety of special forms."
Not::usage = "!expr is the logical NOT function. It gives False if expr is True, and True if it is False."
$Notebooks::usage = "$Notebooks is True if Mathematica is being used with a notebook-based front end."
NProduct::usage = "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::usage = "NProductExtraFactors is an option for NProduct which gives the number of factors to be used in the extrapolation process. NProductExtraFactors must be greater than twice WynnDegree."
NProductFactors::usage = "NProductFactors is an option for NProduct that gives the number of factors to be explicitly included in the product before extrapolation."
NProtectedAll::usage = "NProtectedAll is an attribute that specifies that none of the arguments to a function will be modified by the application of N[ ]."
NProtectedFirst::usage = "NProtectedFirst is an attribute that specifies that the first argument to a function will not be modified by the application of N[ ]."
NProtectedRest::usage = "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::usage = "NRoots[lhs==rhs, var] gives a list of numerical approximations to the roots of a polynomial equation."
NSolve::usage = "NSolve[eqns, vars] attempts to solve numerically an equation or set of equations for the variables vars. NSolve[eqns, vars, elims] attempts to solve numerically the equations for vars, eliminating the variables elims."
NSum::usage = "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::usage = "NSumExtraTerms is an option for NSum that gives the number of terms to be used in the extrapolation process with the method SequenceLimit. NSumExtraTerms must be greater than twice WynnDegree."
NSumTerms::usage = "NSumTerms is an option for NSum which gives the number of terms to be explicitly included in the sum before extrapolation. "
Null::usage = "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::usage = "NullRecords is an option for Read and related functions which specifies whether null records should be taken to exist between repeated record separators."
NullSpace::usage = "NullSpace[m] gives a list of vectors that forms a basis for the null space of the matrix m."
NullWords::usage = "NullWords is an option for Read and related functions which specifies whether null words should be taken to exist between repeated word separators."
Number::usage = "Number represents an exact integer or an approximate real number in Read."
$NumberBits::usage = "$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::usage = "NumberForm[expr, n] prints with approximate real numbers in expr given to n-digit precision."
NumberFormat::usage = "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."
NumberPadding::usage = "NumberPadding is an option for NumberForm and related functions which gives strings to use as padding on the left- and right-hand sides of numbers."
NumberPoint::usage = "NumberPoint is an option for NumberForm and related functions which gives the string to use as a decimal point."
NumberQ::usage = "NumberQ[expr] gives True if expr is a number, and False otherwise."
NumberSeparator::usage = "NumberSeparator is an option for NumberForm and related functions which gives the string to insert at breaks between digits."
NumberSigns::usage = "NumberSigns is an option for NumberForm and related functions which gives strings to use as signs for negative and positive numbers."
Numerator::usage = "Numerator[expr] gives the numerator of expr."
NValues::usage = "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::usage = "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::usage = "OddQ[expr] gives True if expr is an odd integer, and False otherwise."
$Off::usage = "$Off is used to mark messages that have been turned off."
Off::usage = "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::usage = "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::usage = "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."
OpenAppend::usage = "OpenAppend[\"file\"] opens a file to append output to it, and returns an OutputStream object."
OpenRead::usage = "OpenRead[\"file\"] opens a file to read data from, and returns an InputStream object."
OpenTemporary::usage = "OpenTemporary[ ] opens a temporary file to which output can be written, and returns an OutputStream object."
OpenWrite::usage = "OpenWrite[\"file\"] opens a file to write output to it, and returns an OutputStream object."
Operate::usage = "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::usage = "$OperatingSystem is a string giving the type of operating system under which Mathematica is being run."
Optional::usage = "p:v is a pattern object which represents an expression of the form p, which, if omitted, should be replaced by v."
OptionQ::usage = "OptionQ[e] returns True if e can be considered an option or list of options, and False otherwise."
Options::usage = "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::usage = "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::usage = "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::usage = "OrderedQ[h[e1, e2, ...]] gives True if the ei are in canonical order, and False otherwise."
Orderless::usage = "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::usage = "%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::usage = "Outer[f, list1, list2, ...] gives the generalized outer product of the listi."
$Output::usage = "$Output gives the list of files and pipes to which standard output from Mathematica is sent."
OutputForm::usage = "OutputForm[expr] prints as the standard Mathematica output form for expr."
$OutputForms::usage = "$OutputForms is a list of the formatting functions that get stripped off when wrapped around the output."
OutputStream::usage = "OutputStream[\"name\", n] is an object that represents an output stream for functions such as Write."
Overflow::usage = "Overflow[] is the result of a numerical calculation whose result is too large to represent."
Overlaps::usage = "Overlaps is an option to StringPosition that determines whether substrings can overlap."
OwnValues::usage = "OwnValues[f] gives a list of transformation rules corresponding to all ownvalues (values for f itself) defined for the symbol f."
$Packages::usage = "$Packages gives a list of the contexts corresponding to all packages which have been loaded in your current Mathematica session."
PaddedForm::usage = "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::usage = "PageHeight is an option for output streams which specifies how many lines of text should be printed between page breaks."
PageWidth::usage = "PageWidth is an option which can be set for output streams to specify how wide each line of printed text should be."
ParametricPlot::usage = "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::usage = "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."
$$ParenForm::usage = "$$ParenForm is an internal symbol."
ParentDirectory::usage = "ParentDirectory[ ] gives the parent of the current working directory. ParentDirectory[\"dir\"] gives the parent of the directory dir."
$ParentLink::usage = "$ParentLink is the LinkObject through with Mathematica communicates with the frontend in packets 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::usage = "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::usage = "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::usage = "PartitionsP[n] gives the number p(n) of unrestricted partitions of the integer n."
PartitionsQ::usage = "PartitionsQ[n] gives the number q(n) of partitions of the integer n into distinct parts."
$Path::usage = "$Path gives a list of directories to search in attempting to find an external file."
$PathnameSeparator::usage = "$PathnameSeparator is a string that should separate the names of directories and files in pathnames used by this operating system."
Pattern::usage = "s:obj represents the pattern object obj, assigned the name s."
PatternTest::usage = "p?test is a pattern object that stands for any expression which matches p, and on which the application of test gives True."
Pause::usage = "Pause[n] pauses for at least n seconds."
Permutations::usage = "Permutations[list] generates a list of all possible permutations of the elements in list."
Pi::usage = "Pi is pi, with numerical value 3.14159...."
$PipeSupported::usage = "$PipeSupported is True if pipes can be used in the version of Mathematica you are running, and is False otherwise."
Pivoting::usage = "Pivoting is an option to matrix decomposition functions that specifies that column pivoting is to be carried out. The result is in the form { Q, R, P } where P is the permutation matrix such that M . P = Conjugate[Transpose[Q]] . R where M is the initial matrix."
Plain::usage = "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::usage = "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::usage = "PlayRange is an option for Play and related functions which specifies what range of sound amplitude levels should be included."
Plot::usage = "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::usage = "PlotColor is an obsolete graphics option, superseded by ColorOutput."
PlotDivision::usage = "PlotDivision is an option for Plot which specifies the maximum amount of subdivision to be used in attempting to generate a smooth curve."
PlotJoined::usage = "PlotJoined is an option for ListPlot that specifies whether the points plotted should be joined by a line."
PlotLabel::usage = "PlotLabel is an option for graphics functions that specifies an overall label for a plot."
PlotPoints::usage = "PlotPoints is an option for plotting functions that specifies how many sample points to use."
PlotRange::usage = "PlotRange is an option for graphics functions that specifies what points to include in a plot."
PlotRegion::usage = "PlotRegion is an option for graphics functions that specifies what region of the final display area a plot should fill."
PlotStyle::usage = "PlotStyle is an option for Plot and ListPlot that specifies the style of lines or points to be plotted."
Plot3D::usage = "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::usage = "Plot3Matrix is an option to Graphics3D and related functions that can be used to specify the explicit homogeneous perspective transformation matrix."
Plus::usage = "x + y + z represents a sum of terms."
Pochhammer::usage = "Pochhammer[a, n] gives the Pochhammer symbol."
Point::usage = "Point[coords] is a graphics primitive that represents a point."
PointForm::usage = "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::usage = "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::usage = "PolyGamma[z] gives the digamma function psi(z). PolyGamma[n, z] gives nth derivative of the digamma function."
Polygon::usage = "Polygon[{pt1, pt2, ...}] is a graphics primitive that represents a filled polygon."
PolygonIntersections::usage = "PolygonIntersections is an option for Graphics3D which specifies whether intersecting polygons should be left unchanged."
PolyLog::usage = "PolyLog[n, z] gives the nth polylogarithm function of z."
PolynomialDivision::usage = "PolynomialDivision[p, q, x] gives a list of the quotient and remainder obtained by division of the polynomials p and q in x."
PolynomialGCD::usage = "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::usage = "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::usage = "PolynomialMod[poly, m] gives the polynomial poly reduced modulo m. PolynomialMod[poly, {m1, m2, ...}] reduces modulo all of the mi."
PolynomialQ::usage = "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::usage = "PolynomialQuotient[p, q, x] gives the quotient of p and q, treated as polynomials in x, with any remainder dropped."
PolynomialRemainder::usage = "PolynomialRemainder[p, q, x] gives the remainder from dividing p by q, treated as polynomials in x."
Position::usage = "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::usage = "Positive[x] gives True if x is a positive number."
$Post::usage = "$Post is a global variable whose value, if set, is applied to every output expression."
Postfix::usage = "Postfix[f[expr]] prints with f[expr] given in default postfix form: expr // f. Postfix[f[expr], h] prints as exprh."
PostScript::usage = "PostScript[\"string1\", \"string2\", ...] is a graphics primitive which specifies PostScript code to include verbatim in graphics output."
Power::usage = "x^y gives x to the power y."
PowerExpand::usage = "PowerExpand[expr] expands nested powers, powers of products, logarithms of powers, and logarithms of products.  Use PowerExpand with caution because PowerExpand does not pay attention to branch cuts."
PowerMod::usage = "PowerMod[a, b, n] gives Mod[a^b, n]. For negative b, PowerMod[a, b, n] gives modular inverses."
$Pre::usage = "$Pre is a global variable whose value, if set, is applied to every input expression."
PrecedenceForm::usage = "PrecedenceForm[expr, prec] prints with expr parenthesized as it would be if it contained an operator with precedence prec."
Precision::usage = "Precision[x] gives the number of digits of precision in the number x."
PrecisionGoal::usage = "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."
PreDecrement::usage = "--x decreases the value of x by 1, returning the new value of x."
Prefix::usage = "Prefix[f[expr]] prints with f[expr] given in default prefix form: f @ expr. Prefix[f[expr], h] prints as hexpr."
PreIncrement::usage = "++x increases the value of x by 1, returning the new value of x."
Prepend::usage = "Prepend[expr, elem] gives expr with elem prepended."
PrependTo::usage = "PrependTo[s, elem] prepends elem to the value of s, and resets s to the result."
$PrePrint::usage = "$PrePrint is a global variable whose value, if set, is applied to every expression before it is printed."
$PreRead::usage = "$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::usage = "Prime[n] gives the nth prime number."
PrimePi::usage = "PrimePi[x] gives the number of primes less than or equal to x."
PrimeQ::usage = "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::usage = "Print[expr1, expr2, ...] prints the expri, followed by a newline (line feed)."
PrintForm::usage = "PrintForm[expr] returns the internal printform representation of expr."
$PrintForms::usage = "$PrintForms is the list of basic print forms. It is automatically updated when Format definitions using new printforms are made."
$PrintLiteral::usage = "$PrintLiteral is an internal symbol."
Product::usage = "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::usage = "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::usage = "PromptForm[prompt,expr] prints as an output prompt and expression."
Protect::usage = "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::usage = "Protected is an attribute which prevents any values associated with a symbol from being modified."
PseudoInverse::usage = "PseudoInverse[m] finds the pseudoinverse of a rectangular matrix."
PSPrint::usage = "PSPrint[-graphics-] sends graphics to a printer."
Put::usage = "expr >> filename writes expr to a file. Put[expr1, expr2, ..., \"filename\"] writes a sequence of expressions expri to a file."
PutAppend::usage = "expr >>> filename appends expr to a file. PutAppend[expr1, expr2, ..., \"filename\"] appends a sequence of expressions expri to a file."
QRDecomposition::usage = "QRDecomposition[m] yields the QR decomposition for a numerical matrix m. The result is a list {q, r}, where q is an orthogonal matrix and r is an upper triangular matrix."
Quartics::usage = "Quartics is an option for Roots and related functions which specifies whether explicit solutions should be generated for irreducible quartic equations."
Quit::usage = "Quit[ ] terminates a Mathematica session."
Quotient::usage = "Quotient[n, m] gives the integer quotient of n and m, defined as Floor[n/m]."
Random::usage = "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}."
Range::usage = "Range[imax] generates the list {1, 2, ..., imax}. Range[imin, imax] generates the list {imin, ..., imax}. Range[imin, imax, di] uses step di."
Raster::usage = "Raster[{{a11, a12, ...}, ...}] is a two-dimensional graphics primitive which represents a rectangular array of gray cells."
RasterArray::usage = "RasterArray[{{g11, g12, ...}, ...}] is a two-dimensional graphics primitive which represents a rectangular array of cells colored according to the graphics directives gij."
Rational::usage = "Rational is the head used for rational numbers."
Rationalize::usage = "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::usage = "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::usage = "RawMedium is an internal symbol."
Re::usage = "Re[z] gives the real part of the complex number z."
Read::usage = "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::usage = "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::usage = "ReadProtected is an attribute which prevents values associated with a symbol from being seen."
Real::usage = "Real is the head used for real (floating-point) numbers."
RealDigits::usage = "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::usage = "RealInterval[{min, max}] represents the range of values between min and max."
Record::usage = "Record represents a record in Read, Find and related functions."
RecordLists::usage = "RecordLists is an option for ReadList which specifies whether objects from separate records should be returned in separate sublists."
RecordSeparators::usage = "RecordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for records."
Rectangle::usage = "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::usage = "$RecursionLimit gives the current limit on the number of levels of recursion that Mathematica can use."
Reduce::usage = "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. Reduce[eqns, vars, elims] simplifies the equations, trying to eliminate the variables elims."
Reinstall::usage = "Reinstall[link] un-installs the specified external package and installs it again."
Release::usage = "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::usage = "ReleaseHold[expr] removes Hold and HoldForm in expr."
$ReleaseNumber::usage = "$ReleaseNumber is an integer which gives the current Mathematica kernel release number, and increases in successive releases."
$Remote::usage = "$Remote is True if Mathematica is being used in remote mode or with a front end, and is False otherwise."
Remove::usage = "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::usage = "Removed[string] is printed to indicated a symbol that has been removed."
RenameDirectory::usage = "RenameDirectory[\"dir1\", \"dir2\"] renames the directory dir1 to dir2."
RenameFile::usage = "RenameFile[\"file1\", \"file2\"] renames file1 to file2."
RenderAll::usage = "RenderAll is an option to Graphics3D which specifies whether or not PostScript should be generated for all polygons."
Repeated::usage = "p.. is a pattern object which represents a sequence of one or more expressions, each matching p."
RepeatedNull::usage = "p... is a pattern object which represents a sequence of zero or more expressions, each matching p."
RepeatedString::usage = "RepeatedString is an internal symbol used for formatting and printing."
Replace::usage = "Replace[expr, rules] applies a rule or list of rules in an attempt to transform the entire expression expr."
ReplaceAll::usage = "expr /. rules applies a rule or list of rules in an attempt to transform each subpart of an expression expr."
ReplaceHeldPart::usage = "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::usage = "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::usage = "expr //. rules repeatedly performs replacements until expr no longer changes."
ResetDirectory::usage = "ResetDirectory[ ] resets the current working directory to its previous value."
ResetMedium::usage = "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::usage = "Residue[expr, {x, x0}] finds the residue of expr at the point x = x0."
Rest::usage = "Rest[expr] gives expr with the first element removed."
Resultant::usage = "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."
Return::usage = "Return[expr] returns the value expr from a function. Return[ ] returns the value Null."
Reverse::usage = "Reverse[expr] reverses the order of the elements in expr."
RGBColor::usage = "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::usage = "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::usage = "RiemannSiegelZ[t] gives the function Exp[I RiemannSiegelTheta[t]] Zeta[1/2 + I t]."
Right::usage = "Right is used to specify alignment in printforms such as ColumnForm and TableForm."
Roots::usage = "Roots[lhs==rhs, var] yields a disjunction of equations which represent the roots of a polynomial equation."
RotateLabel::usage = "RotateLabel is an option for two-dimensional graphics functions which specifies whether labels on vertical frame axes should be rotated to be vertical."
RotateLeft::usage = "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::usage = "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::usage = "Round[x] gives the integer closest to x."
Row::usage = "Row is a setting for the TableDirections option of TableForm."
RowReduce::usage = "RowReduce[m] gives the row-reduced form of the matrix m."
Rule::usage = "lhs -> rhs represents a rule that transforms lhs to rhs."
RuleCondition::usage = "RuleCondition is an internal symbol."
RuleDelayed::usage = "lhs :> rhs represents a rule that transforms lhs to rhs, evaluating rhs only when the rule is used."
RuleForm::usage = "RuleForm is an internal symbol used for formatting and printing."
RuleTable::usage = "RuleTable is an internal symbol."
Run::usage = "Run[expr1, expr2, ...] generates the printed form of the expressions expri, separated by spaces, and runs it as an external, operating system, command."
RunThrough::usage = "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::usage = "lhs === rhs yields True if the expression lhs is identical to rhs, and yields False otherwise."
SameTest::usage = "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."
SampleDepth::usage = "SampleDepth is an option for sound primitives which specifies how many bits should be used to encode sound amplitude levels."
SampledSoundFunction::usage = "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::usage = "SampledSoundList[{a1, a2, ...}, r] is a sound primitive, which represents a sound whose amplitude has levels ai sampled r times a second."
SampleRate::usage = "SampleRate is an option for sound primitives which specifies the number of samples per second to generate for sounds."
Save::usage = "Save[\"filename\", symb1, symb2, ...] appends the definitions of the symbols symbi to a file."
Scaled::usage = "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::usage = "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::usage = "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::usage = "ScientificForm[expr] prints with all real numbers in expr given in scientific notation."
Sec::usage = "Sec[z] gives the secant of z."
Sech::usage = "Sech[z] gives the hyperbolic secant of z."
Second::usage = "Second is a unit of time used by functions such as Timing."
SeedRandom::usage = "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::usage = "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::usage = "Sequence[e1,e2,...] is a special form representing a sequence of arguments in an expression."
SequenceForm::usage = "SequenceForm[expr1, expr2, ...] prints as the textual concatenation of the printed forms of the expri."
SequenceLimit::usage = "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::usage = "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::usage = "SeriesCoefficient[s,n] returns the coefficient of the n-th power of the variable in the series s."
SeriesData::usage = "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::usage = "$SessionID is a number set up to be unique to a particular Mathematica session."
SessionTime::usage = "SessionTime[ ] gives the total number of seconds of real time that have elapsed since the beginning of your Mathematica session."
Set::usage = "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::usage = "SetAccuracy[expr, n] yields a version of expr in which all numbers have been set to have an accuracy of n digits."
SetAttributes::usage = "SetAttributes[s, attr] adds attr to the list of attributes of the symbol s."
SetDelayed::usage = "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::usage = "SetDirectory[\"dir\"] sets the current working directory."
SetFileDate::usage = "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::usage = "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."
SetPrecision::usage = "SetPrecision[expr, n] yields a version of expr in which all numbers have been set to have a precision of n digits."
SetStreamPosition::usage = "SetStreamPosition[stream, n] sets the current point in an open stream."
Shading::usage = "Shading is an option for SurfaceGraphics that specifies whether the surfaces should be shaded."
Shallow::usage = "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::usage = "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::usage = "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::usage = "Show[graphics, options] displays two- and three-dimensional graphics, using the options specified. Show[g1, g2, ...] shows several plots combined."
Sign::usage = "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::usage = "Signature[list] gives the signature of the permutation needed to place the elements of list in canonical order."
SignPadding::usage = "SignPadding is an option for NumberForm and related functions which specifies whether padding should be inserted after signs."
Simplify::usage = "Simplify[expr] performs a sequence of algebraic transformations on expr, and returns the simplest form it finds."
Sin::usage = "Sin[z] gives the sine of z."
SingularityDepth::usage = "SingularityDepth is an option for NIntegrate which is used to specify how deep recursion is allowed to go before a change of variable is used at the endpoints of the interval of integration."
SingularValues::usage = "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::usage = "Sinh[z] gives the hyperbolic sine of z."
SinhIntegral::usage = "SinhIntegral[x] gives the hyperbolic sine integral Integrate[Sinh[t]/t, {t, 0, x}]."
SinIntegral::usage = "SinIntegral[x] gives the sine integral Integrate[Sin[t]/t, {t, 0, x}]."
SixJSymbol::usage = "The SixJSymbol[{a,b,e},{d,e,f}] returns the value of the 6-j symbol."
Skeleton::usage = "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::usage = "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::usage = "# represents the first argument supplied to a pure function. #n represents the nth argument."
SlotSequence::usage = "## 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::usage = "Socket is a possible value returned by FileType and related functions."
SolutionOf::usage = "SolutionOf is an internal symbol."
Solve::usage = "Solve[eqns, vars] attempts to solve an equation or set of equations for the variables vars. Solve[eqns, vars, elims] attempts to solve the equations for vars, eliminating the variables elims."
SolveAlways::usage = "SolveAlways[eqns, vars] gives the values of parameters that make the equations eqns valid for all values of the variables vars."
Sort::usage = "Sort[list] sorts the elements of list into canonical order. Sort[list, p] sorts using the ordering function p."
Sound::usage = "Sound[primitives] represents a sound."
$SoundDisplayFunction::usage = "$SoundDisplayFunction gives the default setting for the option DisplayFunction in sound functions."
Space::usage = "Space is a string consisting of a space."
SpaceForm::usage = "SpaceForm[n] prints as n spaces."
SpellingCorrection::usage = "SpellingCorrection is an option for StringMatchQ, Names and related functions which specifies whether strings should be considered to match even when a small fraction of the characters in them are different."
SphericalHarmonicY::usage = "SphericalHarmonicY[l, m, theta, phi] gives the spherical harmonic Ylm(theta, phi)."
SphericalRegion::usage = "SphericalRegion is an option for three-dimensional graphics functions which specifies whether the final image should be scaled so that a sphere drawn around the three-dimensional bounding box would fit in the display area specified."
Splice::usage = "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::usage = "Sqrt[z] gives the square root of z."
Stack::usage = "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::usage = "StackBegin[expr] evaluates expr, starting a fresh evaluation stack."
StackComplete::usage = "StackComplete[expr] evaluates expr with intermediate expressions in evaluation chains included on the stack."
StackInhibit::usage = "StackInhibit[expr] evaluates expr without modifying the evaluation stack."
StartingStepSize::usage = "StartingStepSize is an option to NDSolve that determines the initial step size to be used."
StartProcess::usage = "StartProcess[\"command\"] starts up an external process in which functions can be called from Mathematica. (StartProcess has been superseded by MathLink operations.)"
StieltjesGamma::usage = "StieltjesGamma[n] is the nth Stieltjes constant and is related to the Laurent series expansion of Zeta[s] about s == 1."
StirlingS1::usage = "StirlingS1[n, m] gives the Stirling number of the first kind."
StirlingS2::usage = "StirlingS2[n, m] gives the Stirling number of the second kind."
StreamPosition::usage = "StreamPosition[stream] returns an integer which specifies the position of the current point in an open stream."
Streams::usage = "Streams[ ] gives a list of all streams that are currently open. Streams[\"name\"] lists only streams with the specified name."
StringBreak::usage = "StringBreak[n] is output at the end of the nth line where a string is broken."
StringByteCount::usage = "StringByteCount[\"string\"] gives the total number of bytes used to store the characters in a string."
$StringConversion::usage = "$StringConversion gives the default setting for the option StringConversion in output functions."
StringConversion::usage = "StringConversion is an option for output functions which specifies how strings containing special characters should be output."
StringDrop::usage = "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::usage = "StringForm[\"controlstring\", expr1, ...] prints as the text of the controlstring, with the printed forms of the expri embedded."
StringInsert::usage = "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::usage = "\"s1\" <> \"s2\" <> ..., StringJoin[\"s1\", \"s2\", ...] or StringJoin[{\"s1\", \"s2\", ...}] yields a string consisting of a concatenation of the si."
StringLength::usage = "StringLength[\"string\"] gives the number of characters in a string."
StringMatchQ::usage = "StringMatchQ[\"string\", \"pattern\"] yields True if \"string\" matches the specified string pattern, and yields False otherwise."
$StringOrder::usage = "$StringOrder gives the ordering of characters to be used in sorting strings and symbol names."
StringPosition::usage = "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::usage = "StringQ[expr] gives True if expr is a string, and False otherwise."
StringReplace::usage = "StringReplace[\"string\", \"s1\" -> \"sp1\"] or StringReplace[\"string\", {\"s1\" -> \"sp1\", \"s2\" -> \"sp2\", ...}] replaces the \"si\" by \"spi\" whenever they appear as substrings of \"string\"."
StringReverse::usage = "StringReverse[\"string\"] reverses the order of the characters in \"string\"."
StringSkeleton::usage = "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::usage = "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::usage = "StringToStream[\"string\"] opens an input stream for reading from a string."
Stub::usage = "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::usage = "Subscript[expr] prints expr as a subscript."
Subscripted::usage = "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::usage = "x - y is equivalent to x + (-1 * y)."
SubtractFrom::usage = "x -= dx subtracts dx from x and returns the new value of x."
SubValues::usage = "SubValues[f] gives a list of transformation rules corresponding to all subvalues (values for f[x,..][..], etc.) defined for the symbol f."
Sum::usage = "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::usage = "Superscript[expr] prints expr as a superscript."
$SuppressInputFormHeads::usage = "$SuppressInputFormHeads is a list of the heads of expressions whose InputForm should not be sent automatically to front ends."
SurfaceColor::usage = "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::usage = "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."
Switch::usage = "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."
$SyntaxHandler::usage = "$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::usage = "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::usage = "SyntaxQ[\"string\"] returns True if the string corresponds to syntactically correct input for a single Mathematica expression, and returns False otherwise."
$System::usage = "$System is a string specifying the type of computer system used."
Tab::usage = "Tab is a string consisting of a tab character."
Table::usage = "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::usage = "TableAlignments is an option for TableForm and MatrixForm which specifies how entries in each dimension should be aligned."
TableDepth::usage = "TableDepth is an option for TableForm and MatrixForm which specifies the maximum number of levels to be printed in tabular or matrix format."
TableDirections::usage = "TableDirections is an option for TableForm and MatrixForm which specifies whether successive dimensions should be arranged as rows or columns."
TableForm::usage = "TableForm[list] prints with the elements of list arranged in an array of rectangular cells."
TableHeadings::usage = "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."
TableSpacing::usage = "TableSpacing is an option for TableForm and MatrixForm which specifies how many spaces should be left between each successive row or column."
TagSet::usage = "f/: lhs = rhs assigns rhs to be the value of lhs, and associates the assignment with the symbol f."
TagSetDelayed::usage = "f/: lhs := rhs assigns rhs to be the delayed value of lhs, and associates the assignment with the symbol f."
TagUnset::usage = "f/: lhs =. removes any rules defined for lhs, associated with the symbol f."
Take::usage = "Take[list, n] gives the first n elements of list. Take[list, -n] gives the last n elements of list. Take[list, {m, n}] elements m through n of list."
Tan::usage = "Tan[z] gives the tangent of z."
Tanh::usage = "Tanh[z] gives the hyperbolic tangent of z."
TargetFunctions::usage = "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::usage = "Temporary is an attribute assigned to symbols which are created as local variables by Module."
$TemporaryPrefix::usage = "$TemporaryPrefix forms the initial part of filenames returned by OpenTemporary[]."
TensorRank::usage = "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::usage = "TeXForm[expr] prints as a TeX language version of expr."
Text::usage = "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::usage = "TextForm[expr] prints as a textual form of expr."
TextRendering::usage = "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::usage = "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."
ThisLink::usage = "ThisLink is used in patterns for external packages to distinguish between several instances of the same package."
Thread::usage = "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::usage = "ThreeJSymbol[{j1,m1},{j2,m2},{j3,m3}] evaluates the 3-j symbol.  The ji may be symbolic and must satisfy triangularity conditions. Also note that m1+m2+m3 = 0."
Through::usage = "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::usage = "$Throw is an internal symbol."
Throw::usage = "Throw[expr] exits from nested control structures, returning the value expr to the nearest enclosing Catch."
Ticks::usage = "Ticks is an option for graphics functions that specifies tick marks for axes."
TimeConstrained::usage = "TimeConstrained[expr, t] evaluates expr, stopping after t seconds. TimeConstrained[expr, t, failexpr] returns failexpr if the time constraint is not met."
Times::usage = "x*y*z or x y z represents a product of terms."
TimesBy::usage = "x *= c multiplies x by c and returns the new value of x."
$TimeUnit::usage = "$TimeUnit gives the minimum time interval in seconds recorded on your computer system."
TimeUsed::usage = "TimeUsed[ ] yields the total number of seconds of CPU time used so far in the current Mathematica session."
TimeZone::usage = "TimeZone[ ] gives the time zone set for your computer system."
Timing::usage = "Timing[expr] evaluates expr, and returns a list of time used, together with the result obtained."
ToASCII::usage = "ToASCII is an obsolete function, superseded by ToCharacterCode.\n ToASCII[\"c\"] gives the ASCII integer code corresponding to the character c."
ToCharacterCode::usage = "ToCharacterCode[\"string\"] gives a list of the integer codes corresponding to the characters in a string."
ToColor::usage = "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::usage = "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::usage = "ToExpression[\"string\"] gives the expression obtained by taking string as Mathematica input."
Together::usage = "Together[expr] puts terms in a sum over a common denominator, and cancels factors in the result."
ToHeldExpression::usage = "ToHeldExpression[\"string\"] gives the expression obtained by taking string as Mathematica input, enclosed in Hold[]."
TokenWords::usage = "TokenWords is an option for Read and related functions which gives a list of token words to be used to delimit words."
Tolerance::usage = "Tolerance is an option to certain functions that specifies the numerical tolerance under which the calculation is to be effected."
ToLowerCase::usage = "ToLowerCase[string] yields a string in which all letters have been converted to lower case."
TooBig::usage = "TooBig is an internal symbol."
Top::usage = "Top is a setting for the TableAlignments option of TableForm."
ToRules::usage = "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::usage = "ToString[expr] gives a string corresponding to the printed form of expr. Options set the line width, format type, etc."
TotalHeight::usage = "TotalHeight is an option for output streams which specifies the maximum number of lines of text that 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."
TotalWidth::usage = "TotalWidth is an option which can be set for output streams to specify the maximum total number of characters of text that should be printed for each output expression. Short forms of expressions are given if the number of characters needed to print the whole expression is too large."
ToUpperCase::usage = "ToUpperCase[string] yields a string in which all letters have been converted to upper case."
Trace::usage = "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::usage = "TraceAbove is an option for Trace and related functions which specifies whether to include evaluation chains which contain the evaluation chain containing the pattern form sought."
TraceAction::usage = "TraceAction is an option for TracePrint and TraceDialog that specifies the function to be applied to each expression they trace."
TraceBackward::usage = "TraceBackward is an option for Trace and related functions which specifies whether to include preceding expressions on the evaluation chain that contains the pattern form sought."
TraceDepth::usage = "TraceDepth is an option for Trace and related functions which specifies the maximum nesting of evaluation chains that are to be included."
TraceDialog::usage = "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::usage = "TraceForward is an option for Trace and related functions which specifies whether to include later expressions on the evaluation chain that contains the pattern form sought."
TraceInternal::usage = "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::usage = "Whenever Trace[] or a related function is being evaluated, TraceLevel[] returns the level of its output currently being filled."
$TraceOff::usage = "$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::usage = "TraceOff is an option for Trace and related functions which specifies forms inside which tracing should be switched off."
$TraceOn::usage = "$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::usage = "TraceOn is an option for Trace and related functions which specifies when tracing should be switched on."
TraceOriginal::usage = "TraceOriginal is an option for Trace and related functions which specifies whether to test the form of each expression before its head and arguments are evaluated."
$TracePattern::usage = "$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::usage = "$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::usage = "$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::usage = "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::usage = "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::usage = "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::usage = "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::usage = "TreeForm[expr] prints with different levels in expr shown at different depths."
Trig::usage = "Trig is an option for algebraic manipulation functions which specifies whether trigonometric functions should be treated as rational functions of exponentials."
True::usage = "True is the symbol for the Boolean value true."
TrueQ::usage = "TrueQ[expr] yields True if expr is True, and yields False otherwise."
Underflow::usage = "Underflow[] is the result of a numerical calculation whose result is too small to represent."
Unequal::usage = "lhs != rhs returns False if lhs and rhs are identical."
Unevaluated::usage = "Unevaluated[expr] represents the unevaluated form of expr when it appears as the argument to a function."
Uninstall::usage = "Uninstall[link] terminates an external program started by Install, and removes Mathematica definitions set up by it."
Union::usage = "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::usage = "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::usage = "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::usage = "lhs =!= rhs yields True if the expression lhs is not identical to rhs, and yields False otherwise."
$Unset::usage = "$Unset is an internal symbol."
Unset::usage = "lhs =. removes any rules defined for lhs."
Update::usage = "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::usage = "UpperCaseQ[string] yields True if all the characters in the string are upper-case letters, and yields False otherwise."
UpSet::usage = "lhs^=rhs assigns rhs to be the value of lhs, and associates the assignment with symbols that occur at level one in lhs."
UpSetDelayed::usage = "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::usage = "UpValues[f] gives a list of transformation rules corresponding to all upvalues defined for the symbol f."
$Urgent::usage = "$Urgent gives the list of files and pipes to which urgent output from Mathematica is sent."
Using::usage = "Using is an option to Roots that specifies any subsidiary equations that are to be used."
ValueForm::usage = "ValueForm is an internal symbol."
ValueList::usage = "ValueList is an internal symbol."
ValueQ::usage = "ValueQ[expr] gives True if a value has been defined for expr, and gives False otherwise."
ValueTable::usage = "ValueTable is an internal symbol."
Variables::usage = "Variables[expr] gives a list of all independent variables in a polynomial."
VectorQ::usage = "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::usage = "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::usage = "VerifySolutions is an option to Solve and related functions that specifies whether the solutions are to be verified and extraneous solutions eliminated. Note that only those solutions that are obviously extraneous are eliminated."
$Version::usage = "$Version is a string that represents the version of Mathematica you are running."
$VersionNumber::usage = "$VersionNumber is a real number which gives the current Mathematica kernel version number, and increases in successive versions."
VerticalForm::usage = "VerticalForm is an internal symbol used for formatting and printing."
ViewCenter::usage = "ViewCenter is an option for Graphics3D and SurfaceGraphics which gives the scaled coordinates of the point which appears at the center of the display area in the final plot."
ViewPoint::usage = "ViewPoint is an option for Graphics3D and SurfaceGraphics which gives the point in space from which the objects plotted are to be viewed."
ViewVertical::usage = "ViewVertical is an option for Graphics3D and SurfaceGraphics which specifies what direction in scaled coordinates should be vertical in the final image."
WeierstrassP::usage = "WeierstrassP[u, g2, g3] gives the Weierstrass elliptic function P."
WeierstrassPPrime::usage = "WeierstrassPPrime[u, g2, g3] gives the derivative with respect to u of the Weierstrass elliptic function P'."
Which::usage = "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::usage = "While[test, body] evaluates test, then body, repetitively, until test first fails to give True."
With::usage = "With[{x = x0, y = y0, ...}, expr] specifies that in expr occurrences of the symbols x, y, ... should be replaced by x0, y0, ...."
Word::usage = "Word represents a word in Read, Find and related functions."
WordSearch::usage = "WordSearch is an option for Find and FindList which specifies whether the text searched for must appear as a word."
WordSeparators::usage = "WordSeparators is an option for Read, Find and related functions which specifies the list of strings to be taken as delimiters for words."
WorkingPrecision::usage = "WorkingPrecision is an option for various numerical operations which specifies how many digits of precision should be maintained in internal computations."
Write::usage = "Write[channel, expr1, expr2, ...] writes the expressions expri in sequence, followed by a newline, to the specified output channel."
WriteString::usage = "WriteString[channel, expr1, expr2, ...] converts the expri to strings, and then writes them in sequence to the specified output channel."
WynnDegree::usage = "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::usage = "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::usage = "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::usage = "Zeta[s] gives the Riemann zeta function zeta(s). Zeta[s, a] gives the generalized Riemann zeta function."
