|Entering Characters||Two-Dimensional Input Forms|
|Types of Input Syntax||Input of Boxes|
|Character Strings||The Extent of Input Expressions|
|Symbol Names and Contexts||Special Input|
|Numbers||Front End Files|
|• Enter it directly (e.g. )|
|• Enter it by full name (e.g. )|
|• Enter it by alias (e.g. EscaEsc) (notebook front end only)|
|• Enter it by choosing from a palette (notebook front end only)|
|• Enter it by character code (e.g. )|
All printable ASCII characters can be entered directly. Those that are not alphanumeric are assigned explicit names in Mathematica, allowing them to be entered even on keyboards where they do not explicitly appear.
All characters which are entered into the Mathematica kernel are interpreted according to the setting for the CharacterEncoding option for the stream from which they came.
|\[Name]||a character with the specified full name|
|\nnn||a character with octal code nnn|
|\.nn||a character with hexadecimal code nn|
|\:nnnn||a character with hexadecimal code nnnn|
Codes for characters can be generated using ToCharacterCode. The Unicode standard is followed, with various extensions.
8-bit characters have codes less than 256; 16-bit characters have codes between 256 and 65535. Approximately 900 characters are assigned explicit names in Mathematica. Other characters must be entered using their character codes.
|\\||single backslash (decimal code 92)|
|\||single space (decimal code 32)|
|\"||double quote (decimal code 34)|
|\b||backspace or Ctrl+H (decimal code 8)|
|\t||tab or Ctrl+I (decimal code 9)|
|\n||newline or Ctrl+J (decimal code 10; full name )|
|\f||form feed or Ctrl+L (decimal code 12)|
|\r||carriage return or Ctrl+M (decimal code 13)|
|\000||null byte (code 0)|
In general, what input syntax does is to determine how a particular string or collection of boxes should be interpreted as an expression. When boxes are set up, say with the notebook front end, there can be hidden InterpretationBox or TagBox objects which modify the interpretation of the boxes.
|a character string|
|a literal in a character string|
|a literal in a character string|
|(at end of line)||ignore the following newline|
|a substring representing two-dimensional boxes|
StringExpression objects can be used to represent strings that contain symbolic constructs, such as pattern elements.
|`name||symbol name in current context|
|context`name||symbol name in specified context|
|context1`context2`||compound context name|
|`context`||context relative to the current context|
Symbol names and contexts can contain any characters that are treated by Mathematica as letters or letter-like forms. They can contain digits but cannot start with them. Contexts must end in a backquote .
|base^^digits||integer in specified base|
|base^^digits.digits||approximate number in specified base|
|mantissa*^n||scientific notation (mantissa×)|
|base^^mantissa*^n||scientific notation in specified base (mantissa×)|
|number`||machine-precision approximate number|
|number`s||arbitrary-precision number with precision|
|number``s||arbitrary-precision number with accuracy|
Numbers can be entered with the notation in any base from to . The base itself is given in decimal. For bases larger than , additional digits are chosen from the letters - or -. Upper- and lower-case letters are equivalent for these purposes. Floating-point numbers can be specified by including in the digits sequence.
An approximate number is taken to be machine precision if the number of digits given in it is Ceiling[$MachinePrecision]+1 or less. If more digits are given, then is taken to be an arbitrary-precision number. The accuracy of is taken to be the number of digits that appear to the right of the decimal point, while its precision is taken to be Log[10, Abs[x]]+Accuracy[x].
|\(input\)||input or grouping of boxes|
is List, a list with zero elements.
is used to enter boxes using one-dimensional strings. Note that within the outermost in a piece of input the syntax used is slightly different from outside, as described in "Input of Boxes".
The precedence of is high enough that is interpreted as Not[h[e]]. However, is interpreted as .
There is no issue of precedence for forms such as and in which operands are effectively spanned by the operator. For forms such as and a left precedence does need to be specified, so such forms are included in the main table of precedences above.
|Ctrl+2 or Ctrl+@||square root|
|Ctrl+5 or Ctrl+%||switch to alternate position (e.g. subscript to superscript)|
|Ctrl+6 or Ctrl+^||superscript|
|Ctrl+7 or Ctrl+&||overscript|
|Ctrl+9 or Ctrl+(||begin a new cell within an existing cell|
|Ctrl+0 or Ctrl+)||end a new cell within an existing cell|
|Ctrl+- or Ctrl+_||subscript|
|Ctrl+4 or Ctrl+$||underscript|
|Ctrl+Enter||create a new row in a table|
|Ctrl+,||create a new column in a table|
|Ctrl+.||expand current selection|
|Ctrl+Space||return from current position or state|
|Ctrl+, Ctrl+, Ctrl+, Ctrl+||move an object by minimal increments on the screen|
When textual input that you give is used to construct boxes, as in StandardForm or TraditionalForm cells in a notebook, the input is handled slightly differently from when it is fed directly to the kernel.
|• symbol name (e.g. )|
|• number (e.g. )|
|• operator (e.g. )|
|• spacing (e.g. )|
|• character string (e.g. )|
Any textual input that you give between and is taken to specify boxes to construct. The boxes are only interpreted if you specify with that this should be done. Otherwise is left for example as SuperscriptBox[x, y], and is not converted to Power[x, y].
Within the outermost , further specify grouping and lead to the insertion of RowBox objects.
|\*input||construct box by interpreting input|
|\||insert a space|
|\n||insert a newline|
|\t||indent at the beginning of a line|
In string-based input between and spaces, tabs and newlines are discarded. can be used to insert a single space. Special spacing characters such as \[ThinSpace], \[ThickSpace], or \[NegativeThinSpace] are not discarded.
When you input typesetting forms into a string, the internal representation of the string uses the above forms. The front end displays the typeset form, but uses the notation when saving the content to a file or when sending the string to the kernel for evaluation.
Mathematica allows a single expression to continue for several lines. In general, it treats the input that you give on successive lines as belonging to the same expression whenever no complete expression would be formed without doing this.
Thus, for example, if one line ends with , then Mathematica will assume that the expression must continue on the next line. It will do the same if for example parentheses or other matchfix operators remain open at the end of the line.
You can however explicitly tell Mathematica that a particular expression is incomplete by putting a or a (\[Continuation]) at the end of the line. Mathematica will then include the next line in the same expression, discarding any spaces or tabs that occur at the beginning of that line.
|??symbol||get more information|
|?s1s2...||get information on several objects|
|!command||execute an external command (text-based interface only)|
|!!file||display the contents of an external file (text-based interface only)|