# Mathomatic Command Reference

### Commands

 Approximate Calculate Clear Code Compare Copy Derivative Display Divide Echo Edit Eliminate Extrema Factor For Fraction Help Imaginary Integrate Laplace Limit List NIntegrate Optimize Pause Plot Product Push Quit Read Real Repeat Replace Roots Save Set Simplify Solve Sum Tally Taylor Unfactor Variables Version

## Introduction

LHS is shorthand for the Left-Hand Side of an equation. Similarly, RHS used here always means the Right-Hand Side.

In this document, text enclosed by straight brackets [like this] means it is optional and may be omitted. The word "expression" (without double quotes) always means a mathematical expression or formula.

At the Mathomatic main prompt, you may enter:

• A numerical expression, which is stored, then instantly approximated, evaluated, and displayed with the calculate command; this is the autocalc option. To skip running the calculate command on the numerical input, just set it equal to any normal variable.
• A new algebraic expression or equation, which is stored and made the current equation.
• A new expression followed by an equals sign, to set the current non-equation equal to, making it an equation, or to store the new expression as an equation set equal to zero.
• A variable to automatically solve the current equation for (autosolve).
• An operator (not factorial) followed by an equals sign (=) and an expression, which is applied to both sides of the current equation or to the current non-equation.
• An equation number to select as the current equation (autoselect).
• A slash (/) or pound sign (#) followed by a variable name to search all equations spaces forward or backward for, respectively.
• A Mathomatic command (listed in this document).
• A question mark (?) followed by a topic, for quick, short help (same as the help command).
• A semicolon (;) followed by a line comment; everything on a line after a semicolon is ignored. A semicolon that does not start a line comment may be entered by preceding it with a backslash (\).
• An exclamation point (!) followed by a shell or system command. "!" by itself invokes the default shell. "!" is also the factorial operator.

If a colon (:) starts the line, preceding any of the above input to the main prompt, it will always return with successful status, preventing any current read command operations from aborting.

## Entering Commands

Mathomatic has about 43 commands that may be typed at the main prompt. Most commands operate on the current expression or equation by default. Commands are simple English words and are described below, in alphabetical order. If the command name is longer than 4 letters, you only need to type in the first 4 letters for Mathomatic to recognize the command. Option words and arguments for commands follow the command name and are separated by spaces. Commands are not executed until you press the Enter key, and any missing command-line arguments that don't have a default are prompted for. For example, the Mathomatic command

```help calculate
```

gives short help and usage information for the calculate command. "help" is the command, "calculate" is the argument (which is also a command, in this case).

Many commands have an optional equation number range argument, which specifies the equation spaces that the command is to operate on. An equation number range may be a single equation number, or a range of equation numbers separated by a dash (like "2-7", which means every equation space between and including equations 2 and 7), or the word "all", which specifies all equation spaces. If omitted, or a dash ("-") by itself is entered, the current expression or equation is assumed. If pluralized as "equation-number-ranges" in the command syntax, that means multiple equation numbers and ranges may be specified for that command, separated by spaces.

A greater-than character (>) may be appended to the end of any command-line, followed by a file name. This will redirect the output of the command to that file. If the file already exists, it will be overwritten without asking. Note that any debugging output will be redirected, too. Two greater-than characters (>>) next to each other will append command output to a file, like the Unix shell does. For example, the Mathomatic command

```list export all >filename
```

will output all stored expressions and equations to a file in exportable, single-line per equation format, so they can be read in by a different math program. "list" is the command, "export" is the option word, and "all" is the equation number range.

Command option words, such as "export" in the above list command-line, always come immediately after the command name and before anything else on the command-line. These words direct the command to do a different, but related, task.

If Mathomatic becomes unresponsive (a rare occurrence), pressing Control-C once will usually safely abort the current operation and return you to the main prompt. If not, pressing Control-C three times in a row will exit Mathomatic, with a warning displayed the second time.

## Selecting Expressions

Syntax: #["+" or "−"]equation-number [new-expression]

To change the current equation at the main prompt and display it or replace it, type a pound sign (#) followed by the equation space number you wish to select, possibly followed by a new expression to replace it with. The equation number may be preceded by plus (+) or minus (), to select an equation relative to the current equation, instead of an absolute equation number. This syntax also works when prompted for an expression, the RHS or the expression at that equation number is substituted every place #equation-number is entered.

Autoselect feature: Selecting an equation space to make it the current equation is now conveniently done by typing only the equation number at the main prompt. This is called the "set autoselect" option.

## Solving Equations

Syntax: variable or "0"

Mathomatic can solve symbolic equations for any variable or for zero. Solving is accomplished internally by applying identical mathematical operations to both sides of the equation and simplifying, or by plugging the general coefficients of the solve variable into the quadratic formula. The Mathomatic solve algorithm is the best possible for general algebra, however the result is not checked by plugging the solutions into the original equation unless the "solve verify" command is used for solving. To require confirmed correctness of the solutions in this way, use the "solve verifiable" command.

To automatically solve the current equation for a variable, type the variable name at the main prompt. Mathomatic will proceed to manipulate the current equation until all of the solutions for the specified variable are determined. If successful, the current equation is replaced with the solutions and then displayed.

Automatic cubic (third degree), quintic (fifth degree), and higher degree polynomial equation solving is not supported. Some cubic and quartic polynomial equations can be manually solved with the general equations in files "tests/cubic.in" and "tests/quartic.in". Quartic (fourth degree) polynomial equations can be automatically solved if they are biquadratic; that is, containing only degree four, degree two, and degree zero terms of the solve variable. Biquadratic polynomial equations of any degree can be generally solved by Mathomatic because they can be plugged into the quadratic formula.

Note that running the simplify command is a good idea after solving. The solve routine only unfactors the equation as needed to solve it and the result is not completely simplified.

To solve for zero, type in "0" at the main prompt. Zero solving is a special solve that will always be successful and will transform most divide operators into mathematically equivalent multiplications and subtractions, so that the result will more likely be a valid polynomial equation:

```1—> a=b+1/b ; This is actually a quadratic equation.

1
#1: a = b + -
b

1—> 0 ; Solve for the constant zero.

#1: 0 = (b*(b - a)) + 1

1—> unfactor ; Expand, showing this is a quadratic polynomial equation in "b".

#1: 0 = (b^2) - (b*a) + 1

1—> b ; Solve for variable "b".

1
(((((a^2) - 4)^-)*sign1) + a)
2
#1: b = -----------------------------
2

1—> a ; Solve back for variable "a", to check the answer.
Raising both sides to the power of 2 and unfactoring...

((b^2) + 1)
#1: a = -----------
b

1—> simplify

1
#1: a = b + -
b

1—>
```

You can prefix the solve variable name with "=" to solve and swap equation sides, putting the solve variable on the Right-Hand Side. Typing "=" by itself will only swap sides of the current equation and display.

If the current expression is a non-equation, then prefixing or suffixing an expression with "=" will add that expression as the other equation side, conveniently making it an equation you can solve:

```1−> x^2+x ; Entering a simple quadratic polynomial non-equation.

#1: x^2 + x

1−> 0= ; Setting it equal to zero as an afterthought.
Combining to make an equation out of the current non-equation.

#1: 0 = x^2 + x

1−> =0 ; Current equation is an equation now, so zero solve, flipping sides.
Solve successful:

#1: x·(x + 1) = 0

1−> 0= ; Solve for 0 again, flipping equation sides.  Don't need "=" with autosolve.
Solve successful:

#1: 0 = x·(x + 1)

1−> unfactor ; Expand to show nothing has changed.

#1: 0 = x^2 + x

1−> = ; Demonstrating "=" by itself.
Swapping both sides of the current equation...

#1: x^2 + x = 0

1−> x ; Solve for variable x.
Equation is a degree 2 polynomial equation in x.
Equation was solved with the quadratic formula.
Solve successful:

(sign − 1)
#1: x = ––––––––––
2

1−> calculate
There are 2 solutions.

Solution number 1 with sign = 1:
x = 0

Solution number 2 with sign = -1:
x = -1
1−>
```

A manual solve operation can be done too, for educational purposes. To apply an expression to both sides of an equation, just type the operator, followed by "=", then the expression to apply. For example:

```1−> a=b/c ; We want to solve this simple equation manually for "c":

b
#1: a = –
c

1−> *=c ; Multiply both equation sides by "c".

#1: a·c = b

1−> /=a ; Divide both sides by "a", now manually solved for "c":

b
#1: c = –
a

1−>
```

The above syntax works for non-equations, too.

To see all of the steps performed during an automated solve operation, type "set debug 1" (or "set debug 2" for more details) before solving:

```1−> x=(a+1)*(b+2)

#1: x = (a + 1)·(b + 2)

1−> set debug 1
Success.
1−> b ; Solve for variable "b".
level 1: x = (a + 1)*(b + 2)
Subtracting "(a + 1)*(b + 2)" from both sides of the equation:
level 1: x - ((a + 1)*(b + 2)) = 0
Subtracting "x" from both sides of the equation:
level 1: -1*(a + 1)*(b + 2) = -1*x
Dividing both sides of the equation by "-1":
level 1: (a + 1)*(b + 2) = x
Dividing both sides of the equation by "a + 1":
level 1: b + 2 = x/(a + 1)
Subtracting "2" from both sides of the equation:
level 1: b = (x/(a + 1)) - 2
Solve completed:
level 1: b = (x/(a + 1)) - 2
Solve successful:

x
#1: b = ––––––– − 2
(a + 1)

1−>
```

## Approximate command

Syntax: approximate [equation-number-ranges]

This command approximates all real and complex number constants in the current or specified equation spaces. It substitutes the special universal constants pi and e with their respective double precision floating point values, and approximates all real and imaginary constants, roots, and surds to be of double precision size. This allows them to combine with other double precision floating point constants through standard or complex number arithmetic and may help with simplification and comparisons.

The result may contain fractions, unless "set no fractions" was entered previously.

"repeat approximate" approximates and simplifies even more, as much as the calculate command does.

## Calculate command

Syntax: calculate ["factor"] [equation-number-range] [feedback-variable number-of-iterations]

This is the formula calculator command that prompts for the value of each normal variable in the RHS of the current or specified equations or in the current or specified expressions, temporarily substituting any entered values, when not in test or demo mode. Test and demo modes allow for no user intervention. This calculate command approximates, simplifies, and substitutes all "sign" variables with all possible combinations of values (+1 and -1), approximating/simplifying again and displaying each solution as it does so. If all variables are supplied with constant values, then each solution will be a constant, otherwise the result will contain the variables you didn't enter values for. Nothing is modified by this command.

This command is used to temporarily plug in values and approximate/simplify expressions and expand "sign" variables. When an expression with only numbers is entered at the main prompt, this calculate command is automatically invoked on it (autocalc), displaying the calculated result. This occurs only when "set autocalc" is on, which it is by default.

If there are any simple numerical fractions in the result, those are displayed alongside any short result.

To only simplify and expand "sign" variables in stored expressions without approximating, use the "simplify sign" command instead.

If a feedback variable and number of iterations are specified on the calculate command-line, you will be prompted for the initial value of the feedback variable, and the calculation will be iterated, with the simplified result repeatedly plugged back into the feedback variable. This will be done until convergence (the output equals the input) or when the specified number of iterations have been performed (if non-zero), whichever comes first. To see all of the intermediate values, type "set debug 1" before this.

"calculate factor" factorizes all integers and variables before display.

Examples of using the calculate command:

```1—> y=x^2+x

#1: y = (x^2) + x

1—> x ; solve for x
Equation is a degree 2 polynomial in x.

1
-1·(1 + (((1 + (4·y))^—)·sign))
2
#1: x = ———————————————————————————————
2

1—> calculate
Enter y: 0
There are 2 solutions.

Solution number 1 with sign = 1:
x = -1

Solution number 2 with sign = -1:
x = 0

1—>
```

An example of iteration:

```1—> x_new=(x_old+(y/x_old))/2 ; iterative formula for calculating the square root of y

y
(x_old + -----)
x_old
#2: x_new = ---------------
2

2—> calculate x_old 1000 ; iterate up to 1000 times to calculate the square root of 100
Enter y: 100
Enter initial x_old: 1
Convergence reached after 9 iterations.

x_new = 10

2—>
```

Note that the Mathomatic Symbolic Math Library does not support use of the calculate command at this time.

## Clear command

Syntax: clear [equation-number-ranges]

This command clears the specified equation spaces so that they are empty and can be reused. They are deleted from RAM only.

"clear all" quickly clears all equation spaces and restarts Mathomatic, resetting internal memory and deleting all expressions stored in RAM, without losing your settings.

## Code command

Syntax: code ["c" or "java" or "python" or "integer"] [equation-number-ranges]

This command outputs the current or specified equations as floating point or integer assignment statements in C, Java, or Python programming language code. The default is C double precision floating point code. The output from this command should compile correctly and emulate the equation from Mathomatic, if no warnings are given.

With "code integer", integer arithmetic is assumed, otherwise double precision floating point arithmetic is assumed. "code integer" is more generic and should work with any language.

To represent factorials, the user supplied function `factorial()` is called, since there is no equivalent function or operator in these languages. `factorial()` functions for several languages are supplied in the directory examples in the Mathomatic source distribution.

For the most efficient code, use the simplify and optimize commands on your equations before running this code command.

The C and Java languages require that all variables be defined before use. The variables command is provided for this. The output of the variables command should be put before the output of the code command when compiling.

## Compare command

Syntax: compare ["symbolic"] ["approximate"] equation-number ["with" equation-number]

This command compares two equation spaces to see if they are mathematically the same (equal). If only one equation number is supplied, the comparison is between the current equation and the specified equation. The comparison will be faster and more accurate if both equations are previously solved for the same variable.

The simplify command is automatically used on both expressions if needed. If this compare command says the equations or expressions are identical, then they are definitely identical. If this command says the equations or expressions differ, then they might be identical if they are too hard for Mathomatic to simplify completely.

The "symbolic" option uses the "simplify symbolic" option when simplifying. This option sometimes simplifies more, but is not 100% mathematically correct.

The "approximate" option runs the approximate command on both expressions or equations. This makes the compare command more likely to succeed.

"repeat compare" simplifies fully instead of just once, making the compare more likely to succeed too.

Another way of comparing expressions by simply setting them equal is a convenient way of checking validity too, with Mathomatic. Just solve for any variable to see if it is an identity, or typing "solve verify 0" works too. If it is an identity, it will say so, meaning both equations sides are mathematically equivalent and identical.

## Copy command

Syntax: copy ["select"] [equation-number-ranges]

This command simply duplicates the current or specified equation spaces. The new, duplicated expressions are stored in the next available equation spaces and displayed, along with their new equation numbers.

If the "select" option is given, make the current equation the first expression created by this copy command, otherwise the current equation remains unchanged after this copy command.

## Derivative command

Syntax: derivative ["nosimplify"] variable or "all" [order]
Alternate command name: differentiate

This command computes the exact symbolic derivative of a function with respect to the specified variable, using the current expression or RHS of the current equation as the function. It does this by recursively applying the proper rule of differentiation for each operator encountered. The result is "quick" simplified with the "simplify quick" command, unless the "nosimplify" option is specified. If successful, the derivative is placed in the next available equation space, displayed, and becomes the current equation. The original equation is not modified.

Specifying "all" computes the derivative of the current expression with respect to all normal variables. It is equivalent to adding together the derivatives with respect to each normal variable.

Specifying the order allows you to repeatedly differentiate and simplify. The default is to differentiate once (order=1).

If differentiation fails, it is probably because symbolic logarithms are required. Symbolic logarithms are not implemented in Mathomatic, yet. Also, the factorial, modulus, and integral divide operators cannot be differentiated if they contain the specified variable. Because this command handles almost everything, a numerical differentiation command is not needed.

Some examples:

```1—> x^3+x^2+x+1

#1: (x^3) + (x^2) + x + 1

1—> derivative ; no need to specify the variable if there is only one
Differentiating with respect to (x) and simplifying...

#2: (3*(x^2)) + (2*x) + 1

2—> a*x^n

#3: a*(x^n) ; show a general rule of differentiation

3—> derivative x
Differentiating with respect to (x) and simplifying...

#4: a*n*(x^(n - 1))

4—> integrate x ; undo the differentiation

#5: a*(x^n)

5—>
```

## Display command

Syntax: display ["factor"] ["simple" or "mixed"] [equation-number-ranges]

This command displays stored expressions in nice looking multi-line 2D (two-dimensional) fraction format, where division is displayed as a numerator over a fractional line (made up of dashes) over a denominator. If the width (number of columns) required for this 2D display exceeds the screen width, the expression is displayed instead in single-line (one-dimensional) format by the list command. The screen width is set automatically on startup, or by the "set columns" option.

Non-integer constants are converted to reduced fractions, if they are exactly equal to a simple fraction and it would improve readability.

The "factor" option causes all integers, less than or equal to 15 decimal digits long, to be factorized into their prime factors before display, including the numerator and denominator of fractions. To always factorize integers like this before display, use the "set factor_integers" option.

The "mixed" option displays mixed fractions when possible. A mixed fraction is an expression like (2+(1/4)), rather than the simple fraction 9/4. To always display mixed fractions, use the "set fractions mixed" option. Displaying "simple" fractions when not the default is possible now, too.

## Divide command

Syntax: divide [base-variable] [dividend divisor]

This command is for conveniently doing and experimenting with polynomial and numerical division and Greatest Common Divisors (GCDs). It simply prompts for two expressions: the dividend and the divisor (if not specified on the command-line), and divides them, displaying the result and the GCD. If the base variable name and/or two expressions are specified on the command-line, they must be separated by space or comma characters.

Mathomatic has a powerful, general, multivariate polynomial division routine, and univariate polynomial GCD routines, used by the simplify command, which this divide command calls without any other processing if two polynomials are entered.

This command prompts for the dividend (the main polynomial) and then the divisor (what you want to divide the main polynomial by). The polynomial quotient, remainder, and GCD are displayed. The power of the highest power term in the dividend must be greater than or equal to the power of the highest power term in the divisor, otherwise the polynomial division will fail (as it should). In other words, the degree of the divisor polynomial must be less than or equal to the degree of the dividend polynomial.

A base variable name may be specified first on the command-line as the base variable of the two polynomials, but is usually not necessary because a good base variable is automatically selected that works for the division.

If two numbers are entered instead of polynomials, the result of the numerical division, the GCD, and the Least Common Multiple (LCM) are displayed. The LCM of two numbers is the smallest positive number that can be evenly divided by both numbers separately, without remainder. The LCM is the same as the Lowest Common Denominator (LCD) of two fractions and is the two numbers multiplied together, divided by the GCD.

The Greatest Common Divisor of a and b is defined as the greatest positive number or polynomial that evenly divides both a and b without remainder. In Mathomatic, the GCD is not necessarily integer, unless both a and b are integers. The Euclidean GCD algorithm is used by Mathomatic to compute the GCD for numbers and polynomials.

The GCD is the best way to reduce any fraction to its simplest form. Just divide the numerator and denominator by their GCD, and replace each of them with their quotients (there will be no remainder); the result is a completely reduced, equivalent fraction. The polynomial GCD is used when reducing algebraic fractions, factoring polynomials, and for simplifying.

The Euclidean GCD algorithm of successive divides is the best way to compute the GCD for numbers and polynomials. Multivariate polynomial GCD computation usually requires recursion of the GCD algorithm or other methods. Currently the polynomial GCD routine in Mathomatic is not recursive, making it univariate and simpler. Because it is univariate, Mathomatic might be unable to find the GCD of polynomials with many variables. Finding the GCD of large polynomials will probably not succeed anyways with floating point arithmetic, because of accumulated round-off error.

The polynomial division algorithm in Mathomatic is generalized and able to handle any number of variables (multivariate), and division is always done with one selected base variable to be proper polynomial division. Being generalized, the coefficients of the polynomials may be any mathematical expression not containing the base variable.

An example of polynomial division:

```1—> divide
Enter dividend: (x^4) - (7*(x^3)) + (18*(x^2)) - (22*x) + 12
Enter divisor: (x^2) - (2*x) + 2

Polynomial division successful using variable (x).
The quotient is:
6 + (x^2) - (5*x)

The remainder is:
0

Polynomial Greatest Common Divisor (iterations = 1):
(x^2) - (2*x) + 2
1—>
```

The number of iterations displayed is the number of polynomial divides done to compute the GCD with the Euclidean algorithm.

"repeat divide" repeatedly prompts for all input, performing its function again and again, until empty lines are given.

## Echo command

Syntax: echo [text]

By default, this command outputs a line of text, followed by a newline.

```repeat echo -
```

outputs a line of dashes.

```repeat echo
```

clears the screen.

## Edit command

Syntax: edit [file-name]

This command invokes the ASCII text editor specified by the EDITOR environment variable. By default, all equation spaces are edited. Access to shell (/bin/sh) is required for this command to work.

Type "edit" at the Mathomatic prompt to edit all expressions and equations you have entered for the current session. When you are done editing Mathomatic expressions and commands, save and exit the editor to have them automatically read in by Mathomatic. If Mathomatic gets an error reading in its new input, observe where the error is and continue, to automatically re-enter the editor.

To edit an existing file and have it read in, specify the file name on the edit command-line.

## Eliminate command

Syntax: eliminate variables or "all" ["using" equation-number]

This command is used to combine simultaneous equations, by automatically substituting variables in the current equation. It will scan the command-line from left to right, replacing all occurrences of the specified variables in the current equation with the RHS of solved equations. The equation to solve can be specified with the "using" argument. If "using" is not specified, Mathomatic will search backwards, starting at the current equation minus one, for the first equation that contains the specified variable. The equation to solve is solved for the specified variable, then the RHS is inserted at every occurrence of the specified variable in the current equation. That effectively eliminates the specified variable from the current equation, resulting in one less unknown.

There is an advantage to eliminating multiple variables in one command: each equation will be used only once. If the same equation is solved and substituted into the current equation more than once, it will cancel out.

"eliminate all" is shorthand for specifying all normal variables on the command-line. "repeat eliminate all" will eliminate all variables repeatedly until nothing more can be substituted, using each equation only once.

Here is a simple example of combining two equations:

```1—> ; This arrives at the distance between two points in 3D space from the
1—> ; Pythagorean theorem (distance between two points on a 2D plane).
1—> ; The coordinate of point 1, 2D: (x1, y1), 3D: (x1, y1, z1).
1—> ; The coordinate of point 2, 2D: (x2, y2), 3D: (x2, y2, z2).
1—>
1—> L^2=(x1-x2)^2+(y1-y2)^2 ; Distance formula for a 2D Cartesian plane.

#1: L^2 = ((x1 − x2)^2) + ((y1 − y2)^2)

1—> distance^2=L^2+(z1-z2)^2 ; Add another leg.

#2: distance^2 = (L^2) + ((z1 − z2)^2)

2—> eliminate L ; Combine the two equations.
Solving equation #1 for (L) and substituting into the current equation...

#2: distance^2 = ((x1 − x2)^2) + ((y1 − y2)^2) + ((z1 − z2)^2)

2—> distance ; Solve to get the distance formula for 3D space.

1
#2: distance = ((((x1 − x2)^2) + ((y1 − y2)^2) + ((z1 − z2)^2))^—)·sign2
2

2—>
```

## Extrema command

Syntax: extrema [variable] [order]

This command computes possible extrema (the minimums and maximums) of the current expression by default, or possible inflection points when order is 2. The result is placed in the next available equation space, displayed, and becomes the current equation. The original expression is not modified.

By default (order=1) this command computes stationary points. The stationary points of function f(x) are the values of x when the slope (derivative) equals zero. Stationary points are likely the local minimums and maximums of the function, unless the point is determined to be an inflection point.

For y=f(x), where f(x) is the RHS and x is the specified variable, this command gives the values of x that make the minimums and maximums of y. This is computed by taking the derivative of f(x), setting it equal to zero, and then solving for x.

The number of derivatives to take before solving can be specified by the order argument (default is 1). When order is 2, possible points of inflection are determined. A point of inflection is a point on a curve at which the second derivative changes sign from positive to negative or negative to positive.

```1—> y=x^2

#1: y = x^2

1—> extrema x

#2: x = 0

2—>
```

This function is a parabola, with the minimum at x=0.

## Factor command

Syntax: factor ["number" [integers]] or ["power"] [equation-number-range] [variables]
Alternate command name: collect

This command will factorize manually entered integers, displaying all prime factors, when "numbers" is specified on the factor command-line. Otherwise this command will factor variables in expressions in the specified equation spaces, and factor out the GCD of rational constant coefficients, resulting in smaller integer coefficients. This is a very handy command for your algebraic manipulation toolbox.

This command does not factor polynomials. To factor polynomials with repeated or symbolic factors, use the simplify or fraction commands. To factorize integers in equation spaces and display, use the "display factor" command or "set factor_integers" command to always do this.

"factor number" will prompt for integers to factorize, which may be up to 15 decimal digits. Preceding this command with "repeat" or using the plural "factor numbers" will repeatedly prompt for integers to factorize, until an empty line is given. Multiple integers, integer ranges (two integers separated with a dash "-"), or multiple expressions that evaluate to integers, can be specified on the same line and should be separated with spaces or commas.

Without the "number" option, this command will factor out repeated sub-expressions and repeated integer factors (the GCDs) in equation spaces. When factoring expressions, this command does some basic simplification and factors out any common (mathematically equal) sub-expressions it can, unless variables are specified on the command-line, in which case only common sub-expressions containing those variables are factored out. This collects together terms involving those variables.

For example, with the following expression:

```(b*c) + (b*d)
```

variable b factors out and the result of this command is:

```b*(c + d)
```

If no variables are specified on the command-line, this command factors even more: the bases of common (mathematically equal) bases raised to any power are factored out. This is called Horner factoring or Horner's rule.

For example:

```1—> (2+3x)^2*(x+y)

#1: ((2 + (3·x))^2)·(x + y)

1—> unfactor ; expand

#1: (4·x) + (12·(x^2)) + (9·(x^3)) + (4·y) + (12·x·y) + (9·(x^2)·y)

1—> factor x ; collect terms containing x

#1: (x·(4 + (12·y))) + ((x^2)·(12 + (9·y))) + (9·(x^3)) + (4·y)

1—> x^3+2x^2+3x+4 ; enter another expression

#2: (x^3) + (2·(x^2)) + (3·x) + 4

2—> factor ; Horner factoring

#2: (x·((x·(x + 2)) + 3)) + 4

2—>
```

"factor power" does only power operator collecting; that is, (a^n)*(a^m)*(b^n)*(b^m) is transformed to (a*b)^(n+m). With this option, variables cannot be specified.

To undo any kind of factoring in selected equation spaces, use the unfactor command.

## For command

Syntax: for variable start end [step-size]
Alternate syntax: for variable "=" start "to" end ["step" step-size]

This command is good for testing an expression with many sequential input values. It quickly evaluates (approximates/simplifies) and displays the current expression for each value of the index variable as the index variable goes from start to end in steps of step-size (default 1). Nothing is modified.

The syntax of this command is the same as the sum and product commands. This command is not a programming construct, and only allows automatically plugging in sequential values of a variable into the current expression, approximating and simplifying, then displaying the results in single-line format.

## Fraction command

Syntax: fraction ["numerator"] ["denominator"] [equation-number-range]

This command reduces and converts expressions with any algebraic fractions in them into a single simple algebraic fraction (usually the ratio of two polynomials), similar to what Maxima's `rat()` and `ratsimp()` functions do. It does this by combining all terms added together with like and unlike denominators to a single simple fraction with a like denominator. Unlike denominators are combined by converting the terms to what they would be over like (common) denominators. Fractions are reduced by cancelling out the Greatest Common Divisor (GCD) of the numerator and denominator.

The result of this command is mathematically equivalent to the original expression, unless the "numerator" or "denominator" option is specified, in which case the result is the numerator or denominator of the original expression. If both the "numerator" and "denominator" options are specified at once, this command will return with failure if the result is not a fraction, otherwise the entire fraction is returned.

Note that algebraic fractions added together with like denominators are automatically combined by almost any Mathomatic command. Polynomial factoring is only done by the simplify command and this fraction command, to improve simplification.

Example:

```1—> 1/x+1/y+1/z

1   1   1
#1: — + — + —
x   y   z

1—> fraction

(((y + x)·z) + (x·y))
#1: —————————————————————
(x·y·z)

1—> unfactor

((y·z) + (x·z) + (x·y))
#1: ———————————————————————
(x·y·z)

1—> unfactor fraction

1   1   1
#1: — + — + —
x   y   z

1—>
```

"repeat fraction" repeatedly runs the fraction command until the result stabilizes to the smallest size simple algebraic fraction.

If more simplification is needed, try the "simplify fraction" command instead, though the result is not always a single simple fraction with the simplify command.

## Help command

Syntax: help [topics or command-names]
Alternate command name: ?

This command is provided as a quick reference while running Mathomatic. If the argument is a command name, a one line description and one line syntax (usage info) of that command are displayed, possibly followed by one more line of additional information about that command. Command names and topics may be abbreviated, for example "help r" will display all commands that start with the letter "r".

Entering this command by itself will display a list of available topics and commands. "help license" will display the copyright and license notice for the currently running version of Mathomatic.

To create a quick reference text file of all Mathomatic commands, type:

```help all >quickref.txt
```

## Imaginary command

Syntax: imaginary [variable]

This command copies the imaginary part of a complex number expression to the next available equation space. First it fully expands the current equation space with imaginary number simplification. Then if the current expression or RHS of the current equation is not complex, the warning message "Expression is not a mix" will be displayed. A complex number expression contains both imaginary and real number parts. To copy only the real number part, see the real command.

The separation variable may be specified on the command-line, the default is the imaginary unit i. i is really a mathematical constant equal to the square root of -1, but it can often be specified where variables are required in Mathomatic.

If successful, the result may contain the imaginary unit i or the specified separation variable.

```1—> (a+b*i)/(c+d*i)

(a + (b·i))
#1: –––––––––––
(c + (d·i))

1—> imaginary

i·((b·c) − (a·d))
#2: –––––––––––––––––
(c^2 + d^2)

2—>
```

To remove i from the result, type:

```replace i with 1
```

## Integrate command

Syntax: integrate ["constant" or "definite"] variable [order [lower and upper-bounds]]
Alternate command name: integral

This command computes the exact symbolic integral of a polynomial function with respect to the specified variable, using the current expression or RHS of the current equation as the function. If successful, the simplified integral is placed in the next available equation space, displayed, and becomes the current equation.

The default is to compute and display the indefinite integral, also known as the antiderivative or primitive. The antiderivative is the inverse transformation of the derivative.

"integrate constant" simply adds a sequentially named constant of integration ("C_1", "C_2", etc.) to each integration result. The constants of integration here are actually variables that may be set to any constant.

"integrate definite" also integrates, but prompts you for the lower and upper bounds for definite integration. The bounds may also be specified on the end of the command-line. If g(x) is the indefinite integral (antiderivative) of f(x), the definite integral is:

```g(upper_bound) − g(lower_bound)
```

Specifying the order allows you to repeatedly integrate. The default is to integrate once (order=1).

This command is only capable of integrating polynomials.

```1—> x^3+x^2+x+1

#1: (x^3) + (x^2) + x + 1

1—> integrate x

(x^4)   (x^3)   (x^2)
#2: ----- + ----- + ----- + x
4       3       2

2—> derivative x ; check the result
Differentiating with respect to (x) and simplifying...

#3: (x^3) + (x^2) + x + 1

3—> compare 1
Comparing #1 with #3...
Expressions are identical.
3—>
```

## Laplace command

Syntax: laplace ["inverse"] variable

This command computes the Laplace transform of a polynomial function of the specified variable, using the current expression or RHS of the current equation as the function. If successful, the transformed function is placed in the next available equation space, displayed, and becomes the current equation.

This command only works with polynomials.

A Laplace transform can be undone by applying the inverse Laplace transform. That is accomplished by specifying the "inverse" option to this command.

```1—> y=1

#1: y = 1

1—> laplace x ; compute the Laplace transform of 1

1
#2: y = -
x

2—> a*x^n ; a general polynomial term

#3: a*(x^n)

3—> laplace x

a*(n!)
#4: -----------
(x^(n + 1))

4—> laplace inverse x

#5: a*(x^n)

5—>
```

## Limit command

Syntax: limit variable expression

This command takes the limit of the current expression as variable goes to the specified expression. The result is always an equation and placed in the next available equation space and displayed.

L'Hopital's rule for taking limits is not used by this command. Instead the limit is taken by simplifying, solving, and substituting. This command is experimental and does not know about negative infinity and occasionally gives a wrong answer when dealing with infinities.

```1—> 2x/(x+1)

2·x
#1: ———————
(x + 1)

1—> limit x inf ; take the limit as x goes to infinity
Solving...

#2: limit = 2

1—>
```

This command is experimental in that it tests the effectiveness of solving the equation for the limit variable and simplifying, replacing the limit variable with the "goes to" value or expression, then solving back for the original solve variable and simplifying.

## List command

Syntax: list ["export" or "maxima" or "gnuplot" or "hex" or "primes"] [equation-number-ranges]

This command displays stored expressions in single-line (one-dimensional) format. A single formatting option may be specified. With no option specified, expressions are displayed in decimal, Mathomatic format; The text result can then be entered or read back into Mathomatic.

### Formatting options:

"list export" outputs expressions in a generally exportable, single-line text format. You can cut-and-paste the expressions or redirect them to a file, so they can be read in with a different math program.

"list maxima" is for making expression output compatible with the free computer algebra system Maxima.

"list gnuplot" is for making expression output that is compatible with the free graphing utility gnuplot.

"list hex" displays as normal (without these options), except constants are displayed as hexadecimal values in binary exponential notation, where no precision is lost by display rounding. Display rounding of constants happens only to the displayed value (not the stored value) and only if a floating point value is converted to decimal for display, so just displaying decimal constants does not ever change their value internally, unless they are read back in. Expressions that are displayed by this hex option have done no display rounding, and can be read back into Mathomatic exactly as they were. But the hex format used here is very ugly and not the hexadecimal you would expect, due to the binary exponent. The standard C math libraries provide no better hexadecimal or other base output. They were meant for decimal display only.

"list primes" runs the "matho-primes" utility, if available and security is off. The matho-primes command-line is specified, instead of equation-number-ranges. "list primes all" will continually output consecutive primes. The matho-primes output can be redirected.

This list command simply outputs expressions and equations as stored internally by Mathomatic, translating them to the requested output format. There is no simplification and nothing more is done. "list primes" performs a different function and is just short-hand for typing "matho-primes" at the shell prompt.

To pretty-print and display equation spaces in better looking multi-line fraction format, use the display command.

## NIntegrate command

Syntax: nintegrate ["trapezoid"] variable [partitions [lower and upper-bounds]]

This is a numerical integrate command that will work with almost any expression and will not generally compute the exact symbolic integral except for the simplest of expressions. This command will prompt you for the lower and upper bounds to perform numerical definite integration on the current expression or the RHS of the current equation, with respect to the specified variable. These bounds may be any expression not containing infinity, and may be entered at the end of the command-line following partitions, separated by spaces or commas.

This command uses Simpson's rule to do the approximation. Accuracy varies widely, depending on the expression integrated, the interval between the lower and upper bounds, and the number of partitions. The default is to split the interval into 1000 partitions. Setting the number of partitions greater than 10000 seldom is helpful, because of accumulated floating point round-off error.

If "trapezoid" is specified on the command-line, the trapezoid method is used instead, which is usually less accurate than Simpson's rule. The way the trapezoid method works is: the interval from the lower bound to the upper bound is divided into 1000 partitions to produce 1000 trapezoids, then the area of each trapezoid is added together to produce the result. This means that the accuracy usually decreases as the interval increases. Simpson's rule uses the same method, with quadratic curves bounding the top of each trapezoid, instead of straight lines, so that curves are approximated better.

If the integration fails, chances of success are greater if you reduce the number of variables involved in the integration.

If there are any singularities, such as division by zero, between the bounds of integration, the computed result will be wrong.

Here is an example of successful numerical integration:

```1—> y=x^0.5/(1-x^3)

1
(x^–)
2
#1: y = –––––––––
(1 − x^3)

1—> nintegrate x
Warning: Singularity detected, result of numerical integration might be wrong.
Enter lower bound: 2
Enter upper bound: 4
Approximating the definite integral of the RHS
using Simpson's rule (1000 partitions)...
Numerical integration successful:

#2: y = -0.16256117185712

1—>
```

This example avoids the singularity at x=1 and is accurate to 12 digits.

## Optimize command

Syntax: optimize [equation-number-range]

This command splits the specified equations into smaller, more efficient equations with no repeated expressions. Each repeated sub-expression becomes a new equation solved for a temporary variable (named "temp").

Note that the resulting assignment statements may be in the wrong order for inclusion in a computer program with the code command; the order and generated code should be visually checked before using. The source code statements may need to be manually put in the right order to work properly.

```1—> y = (a+b+c+d)^(a+b+c+d)

#1: y = (a + b + c + d)^(a + b + c + d)

1—> optimize

#2: temp = a + b + c + d

#1: y = temp^temp

1—> eliminate temp ; undo the optimization
Solving equation #2 for (temp)...

#1: y = (a + b + c + d)^(a + b + c + d)

1—>
```

## Pause command

Syntax: pause [text]

This command waits for the user to press the Enter key. It is useful in text files (scripts) that are read in to Mathomatic. Optionally, a one line text message may be displayed.

Typing "quit" or "exit" before pressing the Enter key will fail this command and abort the current script.

This command is ignored during test and demo modes.

## Plot command

Syntax: plot [equation-number-ranges] [xyz-ranges] [gnuplot-expressions,]

This command automatically plots multiple solved mathematical equations or expressions in 2D or 3D with the free graphing utility gnuplot. The specified equation spaces are plotted at once, along with any comma separated gnuplot expressions on the command-line. Each expression should contain the variable x to be successfully plotted. If it also contains the variable y, a 3D surface plot is performed in Cartesian space, with the x, y, and z axes projected on your 2D display. z (in a 3D plot) or y (in a 2D plot) are the variables the plot expressions are supposedly solved for, though they need not be included.

A gnuplot X range, Y range, and even a Z range may be specified on the plot command-line. For example, "plot [-128:128]" will make the X axis go from -128 to 128, and "plot [-128:128] [-1:1]" will also make the Y axis go from -1 to 1. A pair of straight brackets [] must surround each range.

Plotting of an equation space with the imaginary number i in it is allowed, however plots are always plotted on real Cartesian space, showing only real number points. If there are no real number points, the plot will fail. The imaginary unit, i, is not understood by gnuplot.

Gnuplot must be installed and accessible from shell by typing "gnuplot" for this command to work. All functions and operators of gnuplot can be used in the gnuplot expressions. If gnuplot fails, the gnuplot command-line is displayed to show what failed. To always show the gnuplot command-line, enter "set debug 1" beforehand, to set debug level 1 for the current session.

Plots may be customized. Typing "set plot_prefix" at the Mathomatic main prompt, followed by a string of 8-bit characters, will prepend the string to the gnuplot plot string, when using the Mathomatic plot command. For example, if you type "set plot set polar\;" at the Mathomatic main prompt, 2D polar plots will be performed instead, with subsequent plot commands using variable "t" instead of "x".

## Product command

Syntax: product variable start end [step-size]
Alternate syntax: product variable "=" start "to" end ["step" step-size]

This command performs a mathematical product () of the current expression or the RHS of the current equation as the index variable goes from start to end in steps of step-size (default 1). The result is approximated/simplified, stored, and displayed. The current equation is not changed.

```1—> y=a*x

#1: y = a*x

1—> product
Enter variable: x
x = 1
To: 10

#2: y = 3628800*(a^10)

1—> 10!
1—>
```

To see all of the intermediate results, type "set debug 1" before this.

## Push command

Syntax: push [equation-number-ranges or text-to-push]

This command pushes the current or specified equation spaces into the readline history, for easy editing and re-entry by using the cursor keys. The equation spaces are not modified. After this command, the pushed expressions are accessed by pressing the cursor UP (up arrow) key.

If any one of the arguments is not a valid equation number range, the text string containing all arguments is pushed into the readline history.

This command only exists if Mathomatic was compiled with readline support.

## Quit command

Syntax: quit [exit-value]
Alternate command name: exit

Type in this command to exit Mathomatic. All expressions in memory are discarded. To save all your expressions stored in equation spaces, use the save command before quitting.

The optional decimal exit value argument is the exit status returned to the operating system. The default is 0, meaning OK.

Another way to quickly exit Mathomatic is to enter your operating system's End-Of-File (EOF) character at the beginning of an input line. The EOF character for Unix-like operating systems is Control-D.

This command reads in a text file as if you typed the text of the file in at the main prompt. The text file (also known as a script) should contain Mathomatic expressions and commands. Read commands may be nested; that is, the file read in may contain further read commands. If any command or operation returns with an error, all current read operations are aborted; this can be prevented by starting the line that returns with error with a colon (:) character.

If any command in the text file prompts for input, it will not read the input from the text file, instead it will prompt the user for the input.

Expressions saved with the save command are restored using this read command.

This command is automatically executed when you start up Mathomatic with file names on the shell command-line. The file name may be a directory name, in which case, the current directory is changed to that directory.

The default file name extension (suffix) for Mathomatic input files is ".in". A file name extension is not required.

This command may be preceded with "repeat", which repeatedly reads a script until it fails or is aborted.

Without any arguments, this command does an "ls -C" command in Unix/Linux, or "dir /W/P" under MS-Windows, listing the current directory contents.

## Real command

Syntax: real [variable]

This command copies the real part of a complex number expression to the next available equation space. First it fully expands the current equation space with imaginary number simplification. Then if the current expression or RHS of the current equation is not complex, the warning message "Expression is not a mix" will be displayed. A complex number expression contains both imaginary and real number parts. To copy only the imaginary number part, see the imaginary command.

The separation variable may be specified on the command-line, the default is the imaginary unit i.

There will be no imaginary numbers in the result.

```1—> (a+b*i)/(c+d*i)

(a + (b·i))
#1: –––––––––––
(c + (d·i))

1—> real

((a·c) + (b·d))
#2: –––––––––––––––
(c^2 + d^2)

2—>
```

## Repeat command

Syntax: repeat command arguments

Any command may be preceded by "repeat", which sets the repeat flag for that command. Many commands ignore the repeat flag, if repeating them doesn't make sense. Sometimes repeating means do a full simplify when simplifying, for example in the simplify, compare, derivative, extrema, and taylor commands, etc.

Currently the approximate, calculate, compare, derivative, divide, echo, eliminate, extrema, fraction, read, replace, roots, simplify, and taylor commands all use the repeat flag.

## Replace command

Syntax: replace [variables ["with" expression]]

By default, this command prompts you for a replacement expression for each variable in the current expression or equation. If an empty line is entered for a variable, that variable remains unchanged. The result is placed in the current expression or equation and displayed.

This command is very useful for renaming or substituting variables. It is smart enough to do variable interchange. With the handy "repeat" option, you are repeatedly prompted for values of the variables, the result is simplified, checked for being an identity, and displayed. Nothing is changed with the repeat option.

If variables are specified on the command-line, you will be prompted for those variables only and all other variables will be left unchanged.

If "with" is specified, the repeat option is ignored, you won't be prompted, and all variables specified will be replaced with the expression that follows.

## Roots command

Syntax: roots root real-part imaginary-part

This command displays all complex number roots of a given positive integer root of a complex number. The number of the root equals the number of correct solutions. For example, "3" would give the 3 roots of the cube root. This command will also convert rectangular coordinates to polar coordinates.

The floating point real part (X coordinate) and imaginary part (Y coordinate) of the complex number are prompted for. Just enter an empty line if the value is zero. The polar coordinates of the given complex number are displayed first, which consist of an amplitude (distance from the origin) and an angle (direction). Then each root is calculated and displayed, along with an "Inverse check" value if debugging is enabled, which should equal the original complex number. The "Inverse check" is calculated by repeated complex number multiplication of the root times itself.

Since double precision floating point is used, the results are only accurate from 10 to 12 decimal digits.

```1—> roots
Enter root (positive integer): 3
Enter real part (X): 8
Enter imaginary part (Y):

The polar coordinates before root taking are:
8 amplitude and 0 radians (0 degrees).

The 3 roots of (8)^(1/3) are:

2
Inverse check: 8

-1 +1.73205080757*i
Inverse check: 8

-1 -1.73205080757*i
Inverse check: 8

1—>
```

"repeat roots" repeatedly prompts for all input, performing its function again and again, until empty lines are given.

## Save command

Syntax: save file-name

This command saves all expressions in all equation spaces into the specified text file. If the file exists, Mathomatic will ask you if you want to overwrite it. The saved expressions and equations can be reloaded (restored) at a later time by using the read command. You can edit the saved expressions with your favorite ASCII text editor.

Another way to save all equation spaces exactly as they are is to enter:

```list hex all >filename
```

into the main Mathomatic prompt, however this saves all constants in hexadecimal and it always overwrites "filename". Because internally constants are binary, hexadecimal can represent them exactly. Reading in the result of this "list hex" command should result in exactly the same expressions in the same numbered equation spaces.

The save command does not save the associated equation number, it only saves all of your equations and expressions. It is much easier to read and edit than "list hex". If you have done anything you want to keep, be sure and "save" it before quitting.

## Set command

Syntax: set [["no"] option [value]] …

This command sets various options listed below, for the current session. They remain in effect until you exit Mathomatic. Typing "set" without arguments shows all current option settings.

The specified option is turned on, unless it is preceded by "no", which turns it off. Some options can be followed by a number and some options can be followed by text, setting that option to the following value.

To permanently change the default settings of Mathomatic, set options can be put in the file ~/.mathomaticrc (for Microsoft Windows: mathomatic.rc in the same directory as the Mathomatic executable or in the \$HOME directory). It should be a text file with one or more set options per line. That file is loaded every time Mathomatic starts up, when not in test, demo, or high security mode. The command "set save" conveniently saves all current session options in that file, making them permanent. "set no save" removes that file, so then Mathomatic will start up with all options set to the program defaults. "set save string" saves only the specified literal ASCII string in that file, for only permanently setting a few options, without using your text editor. Each "set save" command overwrites the previously saved settings. "set load" loads the startup set options file once again, displaying each line before it is processed. If the startup file doesn't exist, or something is wrong, then an error message is displayed and this set command returns with failure.

### Options:

"set precision" followed by an integer less than or equal to 15 sets the display precision in number of decimal digits for most numerical output. All arithmetic in Mathomatic is double precision floating point, so it is not useful to set this higher than 15 digits. Display output is rounded to the precision set by this option, though internally all constants are rounded to fit in a double precision float data type of about 15 decimal digits precision. The default for this display "precision" set variable is 14 digits.

"set no autosolve" will turn off solving by typing the solve variable at the main prompt, unless an equals sign (=) is included. This allows entry of single variable expressions into equation spaces. Solving is always allowed using the solve command.

"set no autocalc" will turn off automatic approximation and display with the calculate command of purely numerical input entered at the main prompt. Numerical expressions are simply entered as is when this option is turned off. When autocalc is on, the current calculation is deleted when the next calculation is entered, if "set autodelete" is specified, otherwise it remains in memory for later use. The default is no autodelete, so to be helpful, all old numeric calculations are automatically deleted from memory if memory ever becomes exhausted. Note that the Mathomatic Symbolic Math Library does not support use of the calculate command at this time.

"set no autoselect" will turn off selecting of equation spaces by just typing in the equation number. Selecting is still possible using the # operator.

"set auto" and "set no auto" turn on and off all three of the above auto options at once. If turned off, all expressions entered at the main prompt will be entered into equation spaces, so they can be operated on by Mathomatic commands.

"set debug" followed by an integer sets the debug level number. The initial debug level is 0, for no debugging. If the level number is 2 ("set debug=2"), Mathomatic will show you how it solves equations. Level 4 debugs the simplify command and its polynomial routines. Levels 5 and 6 show all intermediate expressions. Set the debug level to −1 for suppression of helpful messages, or set the debug level to −2 to even suppress warnings.

"set case_sensitive" will set alphabetic case sensitive mode, while "set no case" will set case insensitive mode (all alphabetic characters will be converted to lower case). "set case" is the default.

"set color" enables color mode, which is the default. When color mode is on, ANSI color escape sequences are output to make expressions easier to read. Requires a terminal emulator that supports ANSI color escape sequences. Enter "set save no color" to always startup Mathomatic with color mode disabled, unless the -c or -b option is given. Use "set color 0" to display normal text as all green, as it was for many years. The default for normal text is no color, but if "color" is followed by a number, the normal text color is set to that number.

"set bold" enables highlighting in color mode. It makes all output brighter. Use this if any colors are difficult to see. The -b option also sets this and color mode on.

"set html" (same as the -x option) enables HTML mode for all standard output. "set html all" enables HTML mode for all output, even redirected output. HTML mode is very useful by itself, or with color mode. With color mode, ANSI color will be turned off and HTML color will be turned on. Even "bold colors" makes a difference here, allowing easier viewing on a dim background.

"set alternative" (same as the -a option) switches color mode to its alternative color mode, if any. So far, only the MinGW version uses this option for switching to ANSI color mode when using Cygwin.

"set columns" followed by a positive integer sets the expected number of character columns (width) on a terminal screen with line wrap. When an expression is to be displayed in multi-line fraction format (two-dimensional) and it is wider than this number of screen columns, single-line format is used instead, because otherwise the expression would not display properly due to wrap-around. "set no columns" or "set columns=0" does no checking for screen size and always displays in fraction format, which is useful for a terminal that doesn't wrap lines. In most cases, this value is set automatically to be the correct width on startup, or by typing "set columns". This value only affects 2D expression output.

"set wide" sets the number of screen columns (like "set columns=0" above does) and screen rows to 0, so that no checking for screen size is done, forcing 2D display of expressions that are too wide to display properly on a terminal with line wrap. Setting this option is useful if output is going to a file.

"set no display2d" will set the expression display mode to single-line format (one-dimensional) using the list command, instead of the default fraction format (two-dimensional) using the display command. Single-line format is useful when feeding Mathomatic output into another program.

fractions_display_mode is a new set option that allows controlling whether or not to display numerical fractions. It also can set the preference of "simple" or "mixed" fractions. The Mathomatic default is to display simple fractions. "set no fractions_display" sets the mode to 0, disabling the automatic conversion of non-integer constants like .5 to 1/2 for display. "set fractions=simple" means display some constants like .5 and 2.25 as their simple fraction equivalents: 1/2 and 9/4. "set fractions=mixed" means display some constants as mixed or simple fractions, for example, 9/4 is displayed as (2+(1/4)), which is a mixed fraction (also called a mixed number).

"set no prompt" turns off Mathomatic prompt output, exactly like the -q (quiet mode) option does.

"set rationalize" will set the "rationalize_denominators" option, which attempts to move radicals from the denominator of fractions to the numerator during simplification. This is the default.

"set modulus_mode" should be followed by an integer from 0 to 2, or a language name: C, Java, Python, or positive. When a modulus operation (%) is done on two constants: dividend % divisor, mode 0 is a type of remainder modulus, that returns a result that is the same sign as the dividend (same as C and Java's % operator give); mode 1 returns a result that is the same sign as the divisor (same as Python's % operator gives); and mode 2 returns an always positive or zero result. Mode 2 is the default and is 100% mathematically correct and the type of modulus operation that can be generally simplified always and be correct. Other types (modes) of modulus operations will be simplified the same way, and the result will be correct as long as they remain positive or zero. Setting the modulus mode only affects modulus operator (%) numeric calculations. All modulus simplification rules are enabled, regardless of the modulus mode. Modulus simplification for integer modulus expressions is always accomplished by using integer variables (variable names that start with "integer") and constants, and no non-integer division. Modulus simplification with integer variables and expressions will almost always simplify more than with normal variables and non-integer expressions. Most modulus simplification is done by the simplify command only.

"set fixed_point" sets finance, fixed point, or integer display. Finance mode (set with no arguments or an argument of "2") displays all constants with 2 digits after the decimal point (for example: "2.00") and negative numbers are always parenthesized (for example: "(−2.00)"). Displayed constants are rounded to the nearest cent, though internally there is no loss of accuracy until more than 15 digits have been used. The number of digits to display after the decimal point may be specified with "set fixed_point=number". This is not truly fixed point arithmetic, it is floating point displayed as fixed point. With double precision floating point, only the most significant 15 decimal digits will ever be correct. "set fixed_point=0" sets rounded, integer-only output, with no decimal points; this might be useful for something. The default is floating point display and no fixed point display ("set no fixed_point").

"set factor_integers" sets automatic factoring of integers for all displayed expressions. When set, all integers of up to 15 decimal digits are factorized into their prime factors before the result of any command is displayed. This command can be shortened to "set factor".

"set right_associative_power" associates power operators from right to left in the absence of parentheses, so that x^a^b is interpreted as x^(a^b). Other math programs typically associate power operators from right to left. The default is "set no right", which associates power operators the same as all other operators in Mathomatic, from left to right, resulting in (x^a)^b.

"set plot_prefix" followed by a string of 8-bit characters will prepend the string to the gnuplot plot string, when using the Mathomatic plot command. For example, "set plot set polar\;" typed at the Mathomatic main prompt will allow 2D polar plots with subsequent plot commands, using variable "t" instead of "x".

"set special_variable_characters" followed by a string of 8-bit characters will allow Mathomatic to use those characters in variable names, in addition to the normal variable name characters, which are the alphanumeric characters and underline (_). For example, "set special \$" will allow variable names like "\$a" and "a\$", and "set special []" will allow entry of array elements like "a[3]" for simulated array arithmetic. Most non-alphanumeric characters in variable names are converted to underline characters (_) when exporting to a programming language or to a different program.

"set directory" followed by a directory name will change the current working directory to that directory. Not specifying a directory name defaults to your home directory. This command can be shortened to "set dir".

## Simplify command

Syntax: simplify ["sign"] ["symbolic"] ["quick[est]"] ["fraction"] [equation-number-ranges]

This command fully simplifies (reduces) expressions in selected equation spaces. The result is usually the smallest possible, easily readable expression, that is mathematically equivalent to the original expression.

Use this command whenever you think an expression is not completely simplified or if you don't like the way an expression is factored. Sometimes simplifying more than once or using the "symbolic" option simplifies even more. This command always tries to factor polynomials, if it will make the expression smaller, unless the "quickest" option is given.

More than one option may be specified at a time.

### Options:

"simplify sign" conveniently expands all "sign" variables by substituting them with all possible combinations of values (+1 and -1), storing the unique results into new equation spaces and simplifying. This will effectively create one simplified equation for each solution.

The "symbolic" option indicates (a^n)^m should always be reduced to a^(n*m). This often simplifies more and removes any absolute value operations: ((a^2)^.5 = a^(2*.5) = a^1 = a). Try this "symbolic" option if the simplify command doesn't simplify well, it often helps with powers raised to powers, though it is sometimes not 100% mathematically correct.

The "quick" option skips expanding sums raised to the power of 2 or higher, like (x+1)^5. Also, algebraic fractions might be simpler with this option, and unlike denominators are not combined at all. This option often simplifies the best, unless expanding sums raised to an integer power is needed.

The "quickest" option very basically simplifies without any unfactoring nor factoring. Running the simplify command with this option makes it complete almost instantaneously.

"simplify fraction" usually simplifies any expression with division in it down to the ratio of two polynomials or expressions, like Maxima's `ratsimp()` function does, though sometimes the fraction command works better because it always reduces to a simple fraction, the difference here being the simplify command result will be completely simplified. This is accomplished by simplification without doing "unfactor fraction" and without doing polynomial or smart (algebraic) division on the divide operators.

This simplify command applies many algebraic transformations and their inverses (for example, unfactor and then factor) and then tries to combine and reduce algebraic fractions and rationalize their denominators. Complex fractions are converted to simple fractions by making the denominators of fractions added together the same, combining and simplifying. Polynomials with repeated or symbolic factors are factored next. Then smart (heuristic) division and polynomial division are tried on any algebraic divides, possibly making complex fractions if it reduces the expression size. Lastly, the expressions are nicely factored and displayed.

Smart division is a symbolic division like polynomial division, but it tries every term in the dividend, instead of only the term with the base variable raised to the highest power, to make the expression smaller.

"repeat simplify" repeatedly runs the simplify command until the result stabilizes to the smallest size expression. In other computer algebra systems, this is called full simplification.

## Solve command

Syntax: solve ["verify" or "verifiable"] [equation-number-range] ["for"] expression

This command automatically solves the specified equations for the specified expression, which may be a variable or zero. For each successful solve operation, the equation solved is replaced with the solution, becomes the current equation and is displayed. See the section on Solving Equations for more information on solving with Mathomatic.

Solving for variable^2 or 0^2 will isolate the square root of the largest expression containing the specified variable, and then square both sides of the equation. This is a new feature for properly squaring, cubing, etc. both sides of an equation, and it works for any power and variable with any equation with roots.

The "verify" and "verifiable" options check the result of solving for a variable by plugging all solutions into the original equation and then simplifying and comparing. If the resulting equation sides are identical (an identity), a "Solutions verified" message is displayed, meaning that all of the solutions are correct. Otherwise "Solution may be incorrect" is displayed, meaning at least one of the solutions is incorrect or unverifiable, causing the "verifiable" option to return with failure, and the "verify" option to return with 2. Use the "verifiable" option if verification is required, otherwise use the "verify" option.

The verify options work when solving for a single variable, and indicate if the solve result can be trusted. If the verify options are used when solving for zero, they only check if the result of the zero solve is an identity. The "simplify quick" command is automatically used after every successful solve operation when using the verify options.

The "for" option has no additional effect and is to make entering this solve command more natural.

## Sum command

Syntax: sum variable start end [step-size]
Alternate syntax: sum variable "=" start "to" end ["step" step-size]

This command performs a mathematical summation () of the current expression or the RHS of the current equation as the index variable goes from start to end in steps of step-size (default 1). The result is approximated/simplified, stored, and displayed. The current equation is not changed.

```1—> y=a*x

#1: y = a*x

1—> sum
Enter variable: x
x = 1
To: 10

#2: y = 55*a

1—>
```

To see all of the intermediate results, type "set debug 1" before this.

## Tally command

Syntax: tally ["average"] [equation-number-ranges]

This command prompts for a value, adds it to a running (grand) total, approximates/simplifies and displays the running total and optional average, and repeats. The average is the arithmetic mean, that is the running total divided by the number of entries ("count"). When finished, the ending total is returned in the next available equation space, displayed, and made the current equation.

It is a convenient way of adding, subtracting, and averaging many numbers and/or variables. Enter a minus sign (−) before each value you wish to subtract. Enter an empty line to end.

The grand total may be set at the start by specifying equation spaces on the command-line to add the expressions or Right-Hand Sides contained therein together. Type "tally -" to resume where you left off last time, if the current equation hasn't changed. This works because the final result of the last tally session is saved in the next available equation space and made the current equation.

## Taylor command

Syntax: taylor ["nosimplify"] variable order point

This command computes the Taylor series expansion of the current expression or RHS of the current equation, with respect to the specified variable. The Taylor series uses differentiation and is often used to approximate expressions near the specified point.

The Taylor series of f(x) at point a is the power series:

```                                     2                  3
f'(a) (x - a)   f''(a) (x - a)    f'''(a) (x - a)
f(a) + ------------- + --------------- + ---------------- + …
1!               2!                 3!
```

where f'(x) is the first derivative of f(x) with respect to x, f''(x) is the second derivative, etc.

This command prompts you for the point of expansion, which is usually a variable or 0, but may be any expression. Typically 0 is used to generate Maclaurin polynomials.

Then it prompts you for the order of the series, which is an integer indicating how many derivatives to take in the expansion. The default is a large number, stopping when the derivative reaches 0.

The result is simplified unless the "nosimplify" option is specified, and placed in the next available equation space, displayed, and becomes the current equation. The original expression is not modified.

```1—> e^x

#1: e^x

1—> taylor x
Taylor series expansion around x = point.
Enter point: 0
Enter order (number of derivatives to take): 8
Computing the Taylor series and simplifying...
8 derivatives applied.

x^2   x^3   x^4   x^5   x^6   x^7     x^8
#2: 1 + x + ––– + ––– + ––– + ––– + ––– + –––– + –––––
2     6    24    120   720   5040   40320

2—>
```

## Unfactor command

Syntax: unfactor ["count"] ["fraction"] ["quick"] ["power"] [equation-number-range]
Alternate command name: expand

This command algebraically expands expressions in selected equation spaces by multiplying out products of sums and exponentiated sums and then simplifying a little, displaying the results. One or more options may be specified, like "count", which also displays the number of additive terms.

To illustrate what unfactoring does (more often known as "expanding"), suppose you have the following equations:

```1—> a=b*(c+d)

#1: a = b*(c + d)

1—> z=(x+y)^2

#2: z = (x + y)^2

2—> unfactor all

#1: a = (b*c) + (b*d)

#2: z = (x^2) + (2*x*y) + (y^2)

2—>
```

(x+y)^2 is called an exponentiated sum and is converted to (x+y)*(x+y) and then multiplied out, unless the "quick" option is given. Because this is a general but inefficient expansion method, exponentiated sums usually fail expansion when the power is greater than 10, growing larger than will fit in an equation space. It is also CPU time-consuming, so "unfactor quick" and "simplify quick" were created to only expand products of sums, and not exponentiated sums.

The opposite of unfactoring is factoring. Careful and neat factoring is always done by the simplify command.

"unfactor fraction" by itself expands algebraic fractions by also expanding division of sums, multiplying out each fraction with a sum in the numerator into the sum of smaller fractions with the same denominator for each term in numerator. See the example under the fraction command.

"unfactor power" does only power operator expansion; that is, (a*b)^(n+m) is transformed to (a^n)*(a^m)*(b^n)*(b^m).

## Variables command

Syntax: variables ["c" "java" "integer" "count"] [equation-number-ranges]

Show or define all variable names used within the specified expressions, from most frequent to least frequently occurring. The programming language options output the variable definitions required to make code from the specified equations. This does not initialize any variables, it only defines them as needed for a C or Java compiler. This command is not necessary for generating Python code.

The "count" option displays the total counts of each variable in a comment, for the specified expressions. The count means the number of times the variable occurs.

This command returns false, with failure and an error message, if no variables were found. This may be useful for determining whether an expression is numeric or symbolic.

## Version command

Syntax: version ["status"]

Shows the version number of Mathomatic.

If the "status" option is given, also displays the last main prompt return value, the C compile-time definitions used and other useful C compiler information, the expression array size, the maximum possible memory usage, the invoked security level, and readline status for the currently running version of Mathomatic.

The maximum memory usage displayed is the amount of RAM used when all equation spaces have been filled. It does not include stack size (which varies) or executable (code) size. The Unix/Linux "size" command gives all the other sizes when run as "size mathomatic", like "text" size, which is really code size. Adding together all size values will probably give a close approximation of the total amount of free RAM required by Mathomatic. Define "HANDHELD=1" when compiling to reduce this.