Mathomatic User's Manual

decoration

Introduction

Mathomatic is a symbolic interpreter that can:

Mathomatic was originally written in Microsoft C for MS-DOS and released as shareware. It was made a better product under the GNU/Linux operating system, using only the GCC C compiler. The C source code is highly portable and will compile and run correctly under any operating system.


Startup

SYNOPSIS
mathomatic [-chqtuv] [-m number] [input_files]

To start the Mathomatic interpreter, type "mathomatic" at the shell prompt.

Color mode is toggled by the "-c" option. ANSI color mode outputs ANSI escape sequences to make each level of parentheses a different color, to improve readability.

The other options are described in the man page.

After any options, file names may be specified on the command line that will be read in with the "read" command.


Equations and Expressions

Mathematical equations and expressions are entered into equation spaces. The number of available equation spaces is displayed every time Mathomatic starts up.

The Mathomatic prompt contains the number of the current equation space (origin 1).

To enter an equation into the first available equation space, simply type the equation at the prompt. Equations consist of a Left Hand Side (LHS) and a Right Hand Side (RHS). The equation sides are separated by one, and only one, equals sign (=). An equation side consists of an algebraic mathematical expression, which is a mix of variables, constants, and operators, mostly in infix notation. Parentheses are used to override operator precedence and group things together.

Shown below is a valid equation with its parts labeled:

        equation
-----------------------
| variables   constant|
|--------------     | |
||     |      |     | |
 a  =  b  -  (c  +  2)
| |   |   |      |    |
| |   |   --------    |
| |   |   operators   |
---   -----------------
LHS          RHS

In the above equation, the variable a is called the dependent variable because its value depends on the variables b and c. b and c are called independent variables. In Mathomatic, any variable can be made the dependent variable by simply typing the variable name in at the prompt. This will solve the equation for that variable and, if successful, make that variable the LHS.

Here is the above equation entered into Mathomatic and solved for b:

1-> a=b-(c+2)

#1: a = b - c - 2

1-> b

#1: b = 2 + c + a

1-> 

Constants

Constants are IEEE 64-bit (8 bytes) double precision (14 decimal digits) floating point numbers. They may be entered in normal, scientific, or hexadecimal notation. They are displayed in decimal (12 digits) in normal or scientific notation, whichever is shortest. Accuracy varies due to floating point inexactness, but Mathomatic results are usually accurate to 12 digits.

To enter a constant in hexadecimal, prepend it with "0x".

Examples of equivalent constants follow:

Normal Notation Scientific Notation Hexadecimal Notation
10 1e1 (1.0 times 101) 0xa
.125 1.25e-1 (1.25 times 10-1) 0x.2
255 2.55e2 (2.55 times 102) 0xff

The infinity constant is entered by typing "inf".

Variables

Variables are what Mathomatic is all about. That is where the term "symbolic" comes from, because variables are symbolic in nature. They can represent known or unknown values, or any expression.

Variables consist of any combination of letters, digits, underscores (_), and backslashes (\). They never start with a digit.

The following variables are predefined and are not normal variables:

e# - the universal constant e (2.718281828...).
pi - the universal constant pi (3.1415926...).
i# - imaginary number (square root of -1).
sign, sign1, sign2, sign3, ... - may be +1 or -1.
integer - may be any integer.

By default, letters in variable names are case sensitive.

To automatically enter a unique sign variable, precede any expression with "+/-".

Operators

Operators have precedence decreasing as indicated:

- negate                               (unary prefix operator)
! factorial (gamma function)           (unary postfix operator)
** or ^ power (exponentiation)         (binary infix operator)
* multiply    / divide      % modulus  (binary infix operators)
+ add         - subtract               (binary infix operators)
= equate                               (signifies equivalence)

Operators in the same precedence level are evaluated left to right.

The negate operator (-) may precede any expression. The negate operator has the highest precedence of all operators. This is different from many math programs, where negate has been erroneously given the same precedence as times/divide. So things like -2^x will give the expected -2 to the power of x, and not -1*(2^x), which are completely different.

The default operator for variables and constants is multiply (*). If a variable or constant is entered when an operator is expected, a multiply operator is automatically inserted.

The modulus operator a % b gives the remainder of the division a / b.

Factorials (x!) use the gamma function (gamma(x+1)), so that they work with any real number, not just the positive integers.

Standard absolute value notation is allowed, |x| is converted to (x^2)^.5. This doesn't always work as expected, but works enough to be useful.

The following example shows why operator precedence is important. Given the expression:

64/-2^4 + 6*(3+1)

Mathomatic will first parenthesize the highest precedence operator (power) and then the lower precedence operators (times and divide). Addition and subtraction are the lowest precedence, so no need to parenthesize them. The result will be:

(64/(-2^4)) + (6*(3+1))

Mathomatic will evaluate this by combining constants from left to right on the same level of parentheses, deepest levels first. So the calculations are performed in the following order:

(64/16) + (6*4)   Combine deepest level parentheses first.
4 + 24            Divided 64 by 16 and then multiplied 6 by 4.
28                Added 24 to 4.

If the calculations were performed in a different order, the result would be different.

Complex Numbers

Mathomatic can perform complex number addition, subtraction, multiplication, and division. It can also do roots and powers of complex numbers.

Complex numbers are in the form:

a + b*i#

where a is the "real part" and b is the "imaginary part". a and b may be constants, variables, or expressions. i# represents the square root of -1 (-1^.5 in Mathomatic notation).

The imaginary number i# may appear anywhere within an expression, as many times as you want. Mathomatic will handle it properly.

Conjugation is accomplished by typing the following command:

replace i# with -i#

Commands

Please consult the Mathomatic Command Reference, for detailed information on commands. It is available in the file "am.html".


Copyright © 2006 George Gesslein II


Mathomatic Home Page