Executable or Nonexecutable Math

All Products Maple MapleSim

Home : Support : Online Help : Getting Started : Menus : Document Menu Bar : Edit Menu : Executable or Nonexecutable Math

Entering 2-D Math

2-D math entry allows you to enter mathematical expressions in standard form as found in papers and books.

This document discusses general entry and entry for specific classes of expressions using 2-D math.

To interact with the examples on this page, open it as worksheet and execute the steps.

Note for non-Windows users: The keystrokes given in this document are for Windows. There will be differences for other platforms. For instance, for Mac users, replace Ctrl with Command to follow the examples. For more keyboard shortcuts for your platform, see Shortcut Keys.

Standard Entry

Executable and Nonexecutable Math

Multiplication

2-D Operators

Separators while Programming in 2-D Math

Derivative Notation and Implied Dependency

Vector Calculus

Special Functions

Generalized Operators and Equations

Tolerances/Optional Forms

Logic

Atomic Variables (Literal Names)

Standard Entry

Much of the standard entry is covered on the 2-D Math Shortcut Keys help page, including how to navigate 2-D expressions and how to escape characters that are shortcut keys.

For more introductory information, see the basic Overview of 2-D Math and the material found under Getting Started in the Maple Help System.

This page covers some further details and demonstrates a few nuances using some helpful examples.

Executable and Nonexecutable Math

2-D math expressions are by default executable.

To evaluate an expression and display the result on a new line, press:

•	Enter, Windows and Linux

•	Return, Mac

To evaluate an expression and display the result inline, press:

•	Alt + Enter, or Ctrl + =, Windows and Linux

•	Alt + Return, or Command + =, Mac

You can toggle a 2-D math expression to nonexecutable math. Use nonexecutable math for expressions that are intended only for display.

When you are editing a 2-D math expression, the background color indicates if the math is executable (blue background) or nonexecutable (gray background).

Executable Math	Nonexecutable Math

To toggle between executable and nonexecutable math, click an expression and use the shortcut key Shift + F5. Alternatively, under the Edit menu, clear the check box beside Executable Math.

Tip: If an expression is executed accidentally, it can lead to error messages (if it is not valid Maple syntax) or unwanted output. If this happens, toggling the expression to nonexecutable math removes the error message or output and changes the math to nonexecutable.

Top of the Page

Multiplication

In general, you can use * or a space to imply multiplication. In 2-D math, * appears as a center dot ( $\cdot$ ).

>	$2 \cdot a \cdot a^{3}$

$2 a^{4}$

(3.1)

>	$expand ((x + a) \cdot (x + b))$

$a b + a x + x b + x^{2}$

(3.2)

2-D math input allows for some implicit multiplication, that is, writing a multiplication operation without requiring a multiplication sign. For example, a space is used between x and x to mean multiplication: $x x$ = $x^{2}$

Tip: Troubleshooting your mathematics is easier if you use explicit multiplication symbols.

Exceptions to this rule include cases where it is clear that only multiplication can be implied. Then a space is not necessary:

>	$\frac{2 x}{2}$

$x$

(3.3)

>	$expand ((x + 1) x)$

$x^{2} + x$

(3.4)

Note: For a product containing integers and decimals, implicit multiplication can be used only if the number occurs in the left-most position in the product. For products of numbers, use explicit multiplication (*). However, you can use implicit multiplication for products containing fractions.

Valid

$2 x$ = $2 x$

Not valid

$2 3$

Error, missing operation

$2.3 5.3333333333$

Error, missing operation

Valid

$2 \cdot 3$ = $6$

$2.3 \cdot 5.3333333333$ = $12.26666667$

Valid

$\frac{2}{3} \frac{5}{3}$ = $\frac{10}{9}$

To avoid common errors in entering expressions in 2-D math, Maple automatically inserts an explicit multiplication symbol in certain cases. You can control this feature. For details, see the Convert Space to Explicit Multiplication Operator section of the Options Dialog.

Using space to imply multiplication

Expression and result

Space between x and x

$x x$ = $x^{2}$

Space between x and (x+1)

Space between f and (x+1)

When you type a space between x and (x+1), Maple automatically inserts an explicit multiplication symbol to indicate multiplication.

$expand (x \cdot (x + 1))$ = $x^{2} + x$

$expand (f \cdot (x + 1))$ = $f x + f$

No space between f and x

The expression parses differently than

$expand (f \cdot (x + 1))$ = $f x + f$

because without the space it means function application.

$expand (f (x + 1))$ = $f (x + 1)$

Caution: Do not put a space between a function name and its arguments. This will be interpreted as multiplication.

This results in the incorrect result see here, because a space between cos and (a) is multiplication!

With no space, this is the cos function applied to a, and the result is 1, as expected.

$a ≔ 0 &colon;$

$\cos \cdot (a)$ = $0$

$\cos (a)$ = $1$

In addition, by default, expressions like $2 (x)$ and $2.1667 (y)$ parse to products instead of operators (the latter being the default in 1-D math).
This behavior can be changed using the Typesetting Rule Assistant, or by adjusting Typesetting settings as follows:

>	$Typesetting :- Settings (numberfunctions = true) &colon;$

$2 (x)$

$2$

(3.5)

>	$Typesetting :- Settings (numberfunctions = false) &colon;$

$2 (x)$

$2 x$

(3.6)

Top of the Page

2-D Operators

The 2-D math mode allows direct entry of 2-D mathematical objects, such as integrals, sums, products, and limits.

Command-Symbol Completion Keys

Esc, Mac, Windows, and Linux

Ctrl + Space, Windows

Ctrl + Shift + Space, Linux

These are also available on the Expression and Calculus palettes.

Examples

Steps

Definite sum:

$\sum_{i = 1}^{n} i$ = $\frac{{(n + 1)}^{2}}{2} - \frac{n}{2} - \frac{1}{2}$

1.	Type $sum$ and use command completion to select $\sum$

2.	Press Ctrl + ' and type $i = 1$

3.	Use Right Arrow key to exit subscript

4.	Press Ctrl + Shift + " and type $n$

5.	Use Right Arrow key to exit superscript

Type $i$

Alternatively:

1.	Type $sum$ and use command completion to select $\sum_{l}^{r} f$

2.	Press Tab to move between placeholders and replace:

•	$l$ with $i = 1$

•	$r$ with $n$

•	$f$ with $i$

Directional limit:

$\lim_{x \to 0 +} \frac{1}{x}$ = $\infty$

1.	Type $\lim$ or $limit$ , press Ctrl + ' , type $x$ -> $0 +$

2.	Press Right Arrow key

3.	Type $\frac{1}{x}$

Alternatively:

1.	Type $\lim$ and use command completion to select $lim_{x \to a} f$

2.	Press Tab to move between placeholders and replace:

•	$x$ with $x$

•	$a$ with $0 +$

•	$f$ with $\frac{1}{x}$

Directional limit:

$\underset{x \to 0 -}{limit} \frac{1}{x}$ = $- \infty$

1.	Type $\lim$ or $limit$ , press Ctrl + ' , type $x$ -> $0 -$

2.	Press Right Arrow key

3.	Type $\frac{1}{x}$

Integrals require a special character for the 'd' prefix of the integration variable (DifferentialD):

$\int_{0}^{10} x &DifferentialD; x$ = $50$

1.	Type $int$ and use command completion to select $\int$

2.	Press Ctrl + Shift + _ and type $0$ .

3.	Press Right Arrow key

4.	Press Shift + ^ and type $10$

5.	Press Right Arrow key

6.	Type $x d$ and use command completion to select the Differential'd'

Type $x$

The integration limits can also be entered over and under the integral sign:

$\int_{0}^{10} x &DifferentialD; x$ = $50$

1.	Type $int$ and use command completion to select $\int$

2.	Press Ctrl + ' and type $0$

3.	Press Right Arrow key

4.	Press Ctrl + Shift + " and type $10$

5.	Press Right Arrow key

6.	Type $x d$ and use command completion to select the Differential'd'

Type $x$

In addition, many formatted 2-D notations are directly available in the command-symbol completion mechanism. This alternative entry technique is demonstrated here:

$\int_{0}^{10} x &DifferentialD; x$ = $50$

1.	Type $int$ and use command completion to select $\int_{a}^{b} f &DifferentialD; x$

2.	Press Tab to move between placeholders and replace:

•	$a$ with $0$

•	$b$ with $10$

•	$f$ with $x$

•	$x$ with $x$

Inert Functions
Inert functions are used to delay evaluation. That is, during computations, the operation they represent remains unperformed.

Inert versions of the int, sum, and limit functions are denoted by the symbols appearing gray in color, the inert version of eval has the evaluation bar in gray, and the inert diff function has the differentiation symbols in gray.

You can enter these functions in 2-D math in two ways:

Example: $\int x &DifferentialD; x$ = $\int x &DifferentialD; x$

Steps

Using command-symbol completion:

The inert functions can be entered with command-symbol completion using the inert versions of the function names, such as Int and Sum.

1.	Type $Int$ and use command completion to select $\int f &DifferentialD; x$

2.	Press Tab to replace the placeholders $f$ and $x$ with $x$

Using palettes:

The active (noninert) functions can be entered from the palettes. You can then convert the expression to its inert form.

1.	From the Expression or Calculus palette, select the template $\int f &DifferentialD; x$ .

2.	Press Tab to replace the placeholders $f$ and $x$ with $x$

3.	From the Context Panel for the expression, select 2-D Math > Convert To > Inert Form. (The $\int$ and $&DifferentialD;$ turns gray in color.)

Top of the page

Separators while Programming in 2-D Math

In general, 2-D math statements do not need to be terminated with a semicolon. However, a statement separator (semicolon or colon) is necessary between two statements in one input region. Otherwise, there will be ambiguity when Maple parses multiple statements.

In the following example, an error occurs because a separator has been omitted between the two statements entered between the use and end use keywords.

$use LinearAlgebra in y ≔ a z ≔ a end use$

Error, unterminated 'use'

This issue can be resolved by adding a semicolon after the first statement.

$use LinearAlgebra in y ≔ a &semi; z ≔ a end use$

$z ≔ a$

(5.1)

To suppress the output, use a colon after the end use statement:

$use LinearAlgebra in y ≔ a &semi; z ≔ a end use &colon;$

Derivative Notation and Implied Dependency

Many standard derivative notations are supported for 2-D math entry methods, including prime notation, dot notation, Leibniz notation, and repeated index notation, but there are a number of settings that you must be aware of when using these. Display in output can be controlled as well.

$restart$

Prime Notation

Prime notation, by default, uses the variable $x$ . When entering a derivative in prime notation, if no dependency is present, then the function is assumed to be a function of $x$ . For example:

$f''$

$\frac{{&DifferentialD;}^{2}}{&DifferentialD; x^{2}} f (x)$

(6.1.1)

>	$y' + 3 y = 0$

$\frac{&DifferentialD;}{&DifferentialD; x} y (x) + 3 y (x) = 0$

(6.1.2)

If an explicit dependency is present, the function is assumed to be the derivative of a function of $x$ evaluated at that value. If the dependent variable is not assigned, or is a known function (like sin), then D notation is used:

>	$f''' (0)$

$D^{(3)} (f) (0)$

(6.1.3)

To enter the prime notation:

1.	Type the expression in math mode, or

2.	From the Calculus palette, select the appropriate template. To fill in the content, navigate through the placeholders using the Tab key.

If the dependent variable is assigned, and is not a known function, then eval/diff notation is used:

>	$q ≔ proc (x)' procname' (x) &semi; end proc &colon;$

$q'' (0)$

$\binom{(\frac{{&DifferentialD;}^{2}}{&DifferentialD; x^{2}} q (x))}{} | \binom{}{\{x = 0\}}$

(6.1.4)

To enter the prime notation:

3.	Type the expression in math mode, or

4.	From the Calculus palette, select the appropriate template. To fill in the content, navigate through the placeholders using the Tab key.

The variable becomes more important when prime is applied to an expression, as follows:

>	$(x^{2} + x)'$

$2 x + 1$

(6.1.5)

Dot Notation

Dot notation, by default, uses the variable $t$ , so names with a dot and no dependencies explicitly listed are assumed to depend on $t$ :

>	$\overset{..}{f}$

$\frac{{&DifferentialD;}^{2}}{&DifferentialD; t^{2}} f (t)$

(6.2.1)

>	$\overset{&period;}{y} + 3 y = 0$

$\frac{&DifferentialD;}{&DifferentialD; t} y (t) + 3 y (t) = 0$

(6.2.2)

The dot notation can be entered in one of the following ways:

Using keyboard shortcuts

Using palette templates

Type $f$

2.	Press Ctrl + Shift + "

Type $..$

4.	Use the Right Arrow key to leave the superscript position

1.	Select $\overset{..}{A}$ from the Calculus palette

2.	Replace $\overset{}{A}$ with $f$

Just as for primes, the use of dot with an explicit dependency different from the dot variable is assumed to be the derivative of a function of $t$ evaluated at that value:

>	$\overset{..}{f} (0)$

$D^{(2)} (f) (0)$

(6.2.3)

To enter the dot notation:

Type $f$

4.	Press Ctrl + Shift + "

Type $..$

6.	Use the Right Arrow key to leave the superscript position

7.	Type $(0)$

Prime or Dot Notation in Output Display

The output display can be modified to use prime and/or dot notation in the interactive Typesetting Rule Assistant, or by using the Typesetting package Settings command.

For example, use dot notation in typeset derivatives in place of $\frac{&DifferentialD;}{&DifferentialD; t}$ notation:

>	$Typesetting :- Settings (typesetdot = true) &colon;$

>	$\overset{..}{f}$

$\overset{..}{f} (t)$

(6.3.1)

>	$\overset{&period;}{y} + 3 y = 0$

$\dot{y} (t) + 3 y (t) = 0$

(6.3.2)

Leibniz Notation

Leibniz notation can be used to specify derivatives and partial derivatives. Short-form use for partial derivatives requires that the function dependencies be suppressed. Function dependency suppression can be enabled in the interactive Typesetting Rule Assistant, or by using the Typesetting package Suppress command.

Univariate examples:

>	$\frac{&DifferentialD;}{&DifferentialD; x} (x^{2} + x)$

$2 x + 1$

(6.4.1)

>	$\frac{{&DifferentialD;}^{2}}{{&DifferentialD;}^{} x^{2}} (x^{2} + x)$

$2$

(6.4.2)

To enter the Leibniz notation for univariate differentiation, select $\frac{&DifferentialD;}{&DifferentialD; x} f$ and $\frac{{&DifferentialD;}^{2}}{{&DifferentialD;}^{} x^{2}} f$ , respectively, from the Calculus palette and press Tab to fill in the contents.

Multivariate examples:

>	$\frac{\partial}{\partial x} x^{2} y$

$2 x y$

(6.4.3)

>	$\frac{\partial^{2}}{\partial x \partial y} x^{2} + y^{2} + z^{2}$

$y^{2} + z^{2}$

(6.4.4)

To enter the Leibniz notation for multivariate differentiation, select $\frac{\partial}{\partial x} f$ and $\frac{\partial^{2}}{\partial x \partial y} f$ , respectively, from the Calculus palette and press Tab to fill in the contents.

Short form of Leibniz notation:

You can use Typesetting:-Suppress to evaluate the derivative as follows:

>	$Typesetting :- Suppress (f (x, y))$

>	$\frac{\partial}{\partial x} f$

$\frac{\partial f}{\partial x}$

(6.4.5)

This typeset enables short-form entry of function names as well:

$f$

(6.4.6)

To enable repeated index notation for partial derivatives, use the following command:

>	$Typesetting :- Settings (userep = true) &colon;$

>	$f_{x, x, y}$

$f_{x, x, y}$

(6.4.7)

Top of the page

Vector Calculus

In addition to standard matrix and vector-style entry, 2-D math also supports vector and vector calculus operations in standard syntax through the VectorCalculus package.

Command-Symbol Completion Keys

Esc, Mac, Windows, and Linux

Ctrl + Space, Windows

Ctrl + Shift + Space, Linux

Dot Product

Type <1,2>.<0,1>:

>	$⟨1, 2⟩ &period; ⟨0, 1⟩$

$2$

(7.1.1)

Cross Product

>	$with (VectorCalculus) &colon;$

Type &x as cross-product operator:

>	$⟨1, 2, 3⟩ &x ⟨7, 8, 0⟩$

Or, use × from the Common Symbols palette:

>	$⟨1, 2, 3⟩ \times ⟨7, 8, 0⟩$

In the following example, note the change in display of output for $⟨1, 2, 3⟩ \times ⟨7, 8, 0⟩$ after unloading the package.

>	$unwith (VectorCalculus) &colon;$

>	$⟨1, 2, 3⟩ \times ⟨7, 8, 0⟩$

$[\begin{array}{c} −24 \\ 21 \\ −6 \end{array}]$

(7.2.1)

Gradient

$restart$

>	$with (VectorCalculus) &colon;$

The coordinate system can be specified within individual calls:

>	$Gradient (x^{2} + y^{2} + z^{2}, [x, y, z])$

Or, set coordinate system as follows:

>	$SetCoordinates (' cartesian' [x, y, z]) &colon;$

Choose from one of the following input style:

>	$Nabla (x^{2} + y^{2} + z^{2})$

>	$Del (x^{2} + y^{2} + z^{2})$

>	$Gradient (x^{2} + y^{2} + z^{2})$

From the Common Symbols palette, select ∇, or type $nabla$ and use command completion to select ∇.
Alternatively, type $Gradient$ , select $\nabla x$ and enter the vector field.

>	$\nabla (x^{2} + y^{2} + z^{2})$

Note: For computation using other coordinate systems, see VectorCalculus[Coordinates].

Divergence

$restart$

>	$with (VectorCalculus) &colon;$

>	$SetCoordinates (' cartesian' [x, y, z]) &colon;$

Use one of the following methods:

>	$Nabla &period; ⟨x^{2}, y^{2}, z^{2}⟩$

$2 x + 2 y + 2 z$

(7.4.1)

>	$Del &period; VectorField (⟨x^{2}, y^{2}, z^{2}⟩)$

$2 x + 2 y + 2 z$

(7.4.2)

The vector field can be assigned separately as well:

>	$V ≔ VectorField (⟨x^{2}, y^{2}, z^{2}⟩)$

>	$\nabla &period; V$

$2 x + 2 y + 2 z$

(7.4.3)

>	$Divergence (V)$

$2 x + 2 y + 2 z$

(7.4.4)

From the Common Symbols palette, select ∇ followed by · .
Alternatively, type $Del$ or $Nabla$ to enter the Del operator, or type $Divergence$ , select $\nabla \cdot x$ and enter the vector field.

>	$\nabla \cdot ⟨x^{2}, y^{2}, z^{2}⟩$

Note: For computation using other coordinate systems, see VectorCalculus/Coordinates.

$2 x + 2 y + 2 z$

(7.4.5)

Curl

$restart$

>	$with (VectorCalculus) &colon;$

>	$SetCoordinates (' cartesian' [x, y, z]) &colon;$

Use one of the following methods:

>	$Nabla &x VectorField (⟨x y, y, z^{}⟩)$

>	$Del &x VectorField (⟨x y, y, z^{}⟩)$

>	$Curl (VectorField (⟨x y, y, z^{}⟩))$

Create the vector field separately:

>	$C ≔ VectorField (⟨x y, y, z^{}⟩)$

>	$Curl (C)$

From the Common Symbols palette, select ∇ followed by × . Or, type $Del$ or $Nabla$ to enter the Del operator, or type $Curl$ , select $\nabla \times x$ and enter the vector field.

>	$\nabla \times ⟨x y, y, z⟩$

Note: For computation using other coordinate systems, see VectorCalculus/Coordinates.

Laplacian

$restart$

>	$with (VectorCalculus) &colon;$

>	$SetCoordinates (' cartesian' [x, y, z]) &colon;$

1.	Laplacian in Cartesian coordinates:

>	$Laplacian (x^{2} + y^{2} + z^{2})$

$6$

(7.6.1)

2.	Laplacian using polar coordinates:

>	$Laplacian (r + θ,' polar' [r, θ])$

$\frac{1}{r}$

(7.6.2)

3.	Laplacian using cylindrical coordinates:

>	$Laplacian (r + \cos (θ) + z,' cylindrical' [r, θ, z])$

$\frac{1 - \frac{\cos (θ)}{r}}{r}$

(7.6.3)

Use expressions of the form (Del . Del)(f), Del . (Del(f)), or Del . Del(f):

>	$\nabla \cdot \nabla (x^{2} + y^{2} + z^{2})$

$6$

(7.6.4)

>	$(\nabla \cdot \nabla) (x^{2} + y^{2} + z^{2})$

$6$

(7.6.5)

>	$\nabla \cdot (\nabla (x^{2} + y^{2} + z^{2}))$

$6$

(7.6.6)

5.	Type $Del$ or $Nabla$ to enter the Del operator, or type $Laplacian$ , select $\nabla^{2} x$ and enter the vector field. Alternatively, press Shift + ^ to enter 2 as exponent of Del. Use right arrow key to leave exponent.

6.	From the Expression palette, select $a^{b}$ . Use the Tab key to move between placeholders and replace $a$ with ∇ (available in the Common Symbols palette) and $b$ with $2$ .

>	$\nabla^{2} (x^{2} + x^{2} + x^{2})$

$6$

(7.6.7)

Top of the page

Special Functions

For convenience and control you can customize 2-D math typesetting of special functions. There are three ways to input special functions: by calling sequence, by command completion, or by enabling parsing rules. You can control the output display of special functions as well.

Special Functions Entry in Input

You can enter special functions in Maple using their calling sequences, for example, BesselJ(v,x) is the Bessel function of the first kind.

You can also use the command completion mechanism to enter special functions in a typeset mathematical notation (textbook notation).

Command-Symbol Completion Keys

Esc, Mac, Windows, and Linux

Ctrl + Space, Windows

Ctrl + Shift + Space, Linux

For example,type $BesselJ$ , use command completion to select $J_{v} (x)$ , and press Tab to replace $v$ with $v$ and $x$ with $x$ .
Similarly, enter the BesselI function.

>	$expr ≔ J_{v} (x) + I_{v} (x)$

$expr ≔ BesselJ (v, x) + BesselI (v, x)$

(8.1.1)

In addition, the completion of functions where the mathematical notation is based on an alphanumeric character is available by using command-symbol completion on that character. For example, to enter the BesselI function using command completion, type $I$ and select $I_{v} (x)$ .

The final option is to enable parsing rules so you can enter, for example, J with a subscript and have it parsed as the BesselJ function. In most cases, the rules for 2-D math entry must be enabled using the Typesetting Rule Assistant or from the command line using the Typesetting[EnableParseRule] function.

Enable the parse rules for Bessel functions.

>	$Typesetting [EnableParseRule] (\{BesselJ, BesselY, BesselI, BesselK\}) &colon;$

Now you can enter Bessel functions in standard notation.
Type input as shown:

>	$expr ≔ J_{v} (x) + I_{v} (x)$

$expr ≔ J_{v} (x) + I_{v} (x)$

(8.1.2)

Special Function Display in Output

You can change the display of special functions in the output using the Typesetting:-EnableTypesetRule command.

>	$Typesetting [EnableTypesetRule] (Typesetting [SpecialFunctionRules]) &colon;$

$expr$

$J_{v} (x) + I_{v} (x)$

(8.2.1)

Note: Under standard typesetting mode, the option for typeset display of special functions has no effect:

>	$interface (typesetting = standard) &colon;$

$expr$

$BesselJ (v, x) + BesselI (v, x)$

(8.2.2)

>	$interface (typesetting = extended) &colon;$

You can also control the typeset display for individual special functions through the Typesetting Rule Assistant.

Top of the page

Generalized Operators and Equations

MathML operators available within Maple parse, by default, to binary operators using the same name as the normalized entity name.

Note: The precedence of these operators is the same as for '=' for any operators in the Arrows, Relational, Relational Round, and Negated palettes, and the same as neutral operators '&...' for all other operators.

Example

Steps

>	$expr ≔ a ≪ b &semi;$

$expr ≔ a ≪ b$

(9.1)

expr is actually stored as a function with function name `&ll;`. If you enter the following:

>	$op (0, expr)$

$≪$

(9.2)

>	$eval (expr, ≪ = ((a, b) \to a + b))$

$a + b$

(9.3)

Enter the much less than operator from the Relational palette.

>	$a \leq x \leq b$

$a \leq x \leq b$

(9.4)

The $\leq$ operator can be entered in one of the following ways:

Type <=

2.	Type $leq$ and use the command completion method

3.	Select the operator from the Relational palette

Following is an example which demonstrates that any non-equivalence operators have higher precedence than multiplication:

>	$\frac{a \cdot b ⊠ c \cdot d}{a \cdot d}$

$b ⊠ c$

(9.5)

Now, compare this result to the the following:

>	$\frac{a \cdot b + c \cdot d}{a \cdot d}$

$\frac{a b + c d}{a d}$

(9.6)

Here the multiplication operator has higher precedence.

For the first example:

4.	Select the $\frac{a}{b}$ template from the Expression palette

Type a*b

6.	To enter the boxtimes operator, type $boxtimes$ and use the command completion method.

Type c*d

8.	Press Tab to enter a*d as denominator

Top of the page

Tolerances/Optional Forms

The $\pm$ and $\mp$ operators have special precedence rules that enable them to be used in two forms.

The default is to treat them with the same precedence as addition, in which case they can be used to describe an expression with two optional values, one choosing the upper operator, and the other choosing the lower operator. In this case, these operators are internally represented as unary operators.

>	$whichval ≔' whichval' &colon;$

>	$&+− := a \to if (whichval = 1, a, if (whichval = 2, &uminus0;a,' &+−' (a))) &colon;$

>	$&−+ := a \to if (whichval = 1, - a, if (whichval = 2, a,' &−+' (a))) &colon;$

An optional equation using $\pm$ and/or $\mp$ :

>	$ans := \frac{x^{2} \pm x + 1}{x \mp 2} &colon;$

At this point, the value of 'whichval' lets you change the value of the expression:

>	$whichval ≔ 1 &colon;$

$ans$

$\frac{x^{2} + x + 1}{x - 2}$

(10.1)

>	$whichval ≔ 2 &colon;$

$ans$

$\frac{x^{2} - x + 1}{x + 2}$

(10.2)

Alternatively, the $\pm$ symbol can be used as a binary operator to describe a tolerance from the Tolerances package.
The meaning of the symbol can be switched from use for optional values to tolerances in either the Typesetting Rule Assistant, by the command line Typesetting:-Settings command, or simply by loading the Tolerances package:

>	$with (Tolerances) &colon;$

>	$5 \pm 0.3$

$5.00 \pm 0.300$

(10.3)

>	$1 \pm 0.1 \cdot 2 \pm 0.1$

$2.01 \pm 0.300$

(10.4)

Top of the page

Logic

Available logical (boolean) operators in 2-D math include nand, nor, and iff, defined in terms of the existing logic operations not, and, or, xor, and implies. Each boolean operation has a symbolic counterpart.

Each logic operation, the MathML symbol used, and the symbolic form are demonstrated in the following table:

Operation	Standard Form	Symbol	Symbol Form
not	$not a$ = $not a$	not	$\neg a$ = $not a$
nand	$a nand b$ = $not (a and b)$	uarr	$a ↑ b$ = $not (a and b)$
and	$a and b$ = $a and b$	and	$a \land b$ = $a and b$
nor	$a nor b$ = $not (a or b)$	darr	$a ↓ b$ = $not (a or b)$
or	$a or b$ = $a or b$	or	$a \lor b$ = $a or b$
xor	$a xor b$ = $a xor b$	veebar	$a ⊻ b$ = $a xor b$
implies	$a implies b$ = $a \Rightarrow b$	Implies	$a \Rightarrow b$ = $a \Rightarrow b$
iff	$a iff b$ = $(a \Rightarrow b) and (b \Rightarrow a)$	iff	$a \Leftrightarrow b$ = $(a \Rightarrow b) and (b \Rightarrow a)$

As an additional convenience, the nand, nor, xor, and implies operations have completion shortcuts available for their corresponding symbols (as their MathML entity names are quite different).

For example:

•	Type $a implies$

•	Use command completion to enter $\Rightarrow$

•	Type $b$ and press Enter to evaluate

>	$a \Rightarrow b$

$a \Rightarrow b$

(11.1)

When the Logic package is loaded, the logic expressions, in both symbolic and verbal form, parse to Logic package operations. Note: While the outputs display similarly, there are differences between the underlying implementation of the Logic package operators and the top-level logical operators. For more information, see the help pages boolean, Logic, and Logic Package Operators.

Note: When the Logic package is loaded, the standard logic operations are still available in prefix form.

$not (a)$

$not a$

(11.2)

>	$and (a, b)$

$a and b$

(11.3)

>	$or (a, b)$

$a or b$

(11.4)

Top of the page

Atomic Variables (Literal Names)

Maple can work with composite or colored objects that are to be considered distinct from the components making up the objects or the object without the same color attributes. These objects are called atomic objects.

If you want to display a single Maple expression as an atomic object, select the expression, and then in the Format>Convert to menu, select the Atomic Variable check box. This can also be accessed through the Context Panel for the expression: 2-D math>Convert To>Atomic Variable. Alternatively, press Ctrl + Shift + A (Windows and Linux) or Command + Shift + A (Mac).

In simple cases where a script object is composed with a base and one or more scripts of a simple type (identifier, operator, or number), which otherwise has no meaning in Maple, these objects become atomic automatically.

Example

Steps

>	$var ≔ \tilde{x} &colon;$

1.	Press Ctrl + Shift + " to enter the overscript for $x$

2.	Use one of the following methods to enter tilde:

•	Press Shift + ~

•	Select ~ from the Common Symbols palette

•	Type $tilde$ and use command completion method

3.	Use Right Arrow key to leave overscript

This name assigned to $var$ is different from $x$ , and in fact has no relation to $x$ , as it is $x tilde$ .

>	$x ≔ 1 &colon;$

$var$

$\tilde{x}$

(12.1)

Assigning the value of $x$ does not affect this name.

Furthermore, $x tilde$ is treated as any other name in Maple.

>	$diff (f (var), var)$

$\frac{&DifferentialD;}{&DifferentialD; \tilde{x}} f (\tilde{x})$

(12.2)

For this reason, in some cases where a parse error would result, the expression is instead assumed to be of atomic type, and is treated as such. For example, the following three values would result in parse errors, but since they are simple objects, are instead identified as atomic objects.

Example

Steps

>	$[x^{&commat;}, x^{&}, x^{&period;}]$

$[x^{@}, x^{&}, x^{.}]$

(12.3)

To enter the superscript for $x$ press Shift + ^ . Use Right Arrow key to leave superscript.

The internal representations of these atomic variables are composed of MathML construct, which can be displayed in the following manner:

>	$sprintf (\tilde{x})$

$#mover(mi("x"),mo("˜"))$

(12.4)

If this automatic behavior is not desired, it can be disabled through the Typesetting Settings command or through the Typesetting Rule Assistant:

>	$Typesetting :- Settings (autoatomic = false) &colon;$

>	$x^{&commat;}$

Error, invalid power

Expressions that would normally parse as Maple objects can be converted to atomic objects using the context menu. For example, $x$ with a subscript of $1$ is normally interpreted as a table reference:

$x_{1}$

$1_{1}$

(12.5)

Note that this returns '1' subscripted by '1' because $x$ was assigned to 1 earlier.

To work with this notation as a name, different from $x$ , enter the expression, select it, then from the Context Panel select 2-D math>Convert To>Atomic Variable and evaluate.

$x__1$

(12.6)

Alternately, in this specific case, you can use two underscores (Shift + _ _) to create a subscripted name called a literal subscript.

$x__1$

(12.7)

Note that the atomic variable x is different from the indexed one.

Again, note the following example with Array:

>	$A ≔ [0, 1, 3, 4]$

$A ≔ [0, 1, 3, 4]$

(12.8)

The following indexed subscript returns the element in the first position of Array $A$ (equivalent to A[1]):

$A_{1}$

$0$

(12.9)

However, once $A$ subscript $1$ is converted to an atomic variable, it evaluates in this manner:

$A__1$

(12.10)

This is equivalent to calling A__1.

In addition to the ability to compose objects to construct semantically different objects, you can also use color. When an automatic atomic object contains colors different from the default, these become part of the atomic object. If the View>Atomic Variable option is set, then all atomic variables, including ones with non-default colors, are shown in magenta. It is recommended that you avoid using the default input and output colors (black and blue) to distinguish objects.

For example, you can construct the name $green x$ that is different from $x$ by changing the color of an $x$ to $green$ . Select the $x$ . From the Context Panel select 2-D Math>Format>Color. Select green, and click OK. To make it atomic, select the green $x$ , and from the Context Panel select 2-D Math>Convert To>Atomic Variable.

$x$

And as an example of using green $x$ in a for loop:

>	$for x to 5 do print (x, x) &semi; end do$

$1, 1$

$2, 1$

$3, 1$

$4, 1$

$5, 1$

(12.11)

Top of the page

Maple

Maple Add-Ons

MapleSim

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim

Maple

Powerful math software that is easy to use

Maple Add-Ons

MapleSim

Advanced System Level Modeling

MapleSim Add-Ons

Systems Engineering

Consulting Services

Maple T.A. and Möbius

Education

Industries

Automotive and Aerospace

Robotics

Machine Design & Industrial Automation

Other

Application Areas

Product Pricing

Purchasing

Institutional Student Licensing

Maplesoft Elite Maintenance (EMP)

Support

Product Training

Online Product Help

Webinars & Events

Publications

Content Hubs

Examples & Applications

Community

About Maplesoft

Media Center

User Community

Contact

Online Help

All Products Maple MapleSim