        SymbMath: A Symbolic Calculator with Learning
			(Version 1.4)

		Copyright (C) 1990-1991

			by Dr. Weiguang HUANG
	5/6 Cara Road, Geelong, Vic. 3216, Australia

	This manual is uncomplete at the moment (November 1, 1991) as 
SymbMath is growing. It is welcome to report any error or suggestion 
in this manual to the author.


			Contents

1. Introduction
2. Capabilities
3. Keywords
4. Symbolic, Help, Write, and Print Modes
	4.1 Symbolic Mode
	4.2 Help Mode
	4.3 Write Mode
	4.4 Print Mode
5. Data Type
	5.1 Numbers 
	5.2 Constants and Built-in Constants
	5.3 Variables
	5.4 Functions
		5.4.1 Built-in Standard Functions
		5.4.2 Calculus and Transformation Functions
		5.4.3 User-defined Functions
	5.5 Equatios
	5.6 Lists, Arrays, Vectors and Matrices
6. Operators
7. Expressions
8. Input and Output
9. Commands
10. Switches
11. Separators
12. Programming
13. Library
14. Learning from Human
15. Examples
	15.1 Declaration and Simplification
	15.2 Calculation
	15.3 User-defined Function and Evaluation
	15.4 Limits
	15.5 Differentiation
	15.6 Integration
	15.7 Algebraic Equations
	15.8 Differential and Integral Equations
	15.9 Sums and Products
	15.10 Power Serires
	15.11 Lists, Arrays, Vectors and Matrices
	15.12 Complex Functions
	15.13 Transformation and Pieces of Expressions
	15.14 Chemical Calculation
	15.15 Chemical Reactions
16. Interface with Other Software
17. Inside SymbMath
18. System Limits
19. Future
20. References


		1.	 Introduction
	SymbMath, (an abbreviation for Symbolic Mathematics), is not
only a symbolic calculator but also an expert system that can solve 
symbolically mathematical problems. SymbMath performs symbolic formula, 
as well as exact numeric computation. It can manipulate complicated 
formulas and return answers in terms of symbols, formulas and exact 
numbers, not just floating-point numbers. Symbolic mathematics is also 
called Computer Algebra, Symbolic Manipulation, Algebraic Manipulation, 
Symbolic Computation, or Algebraic Computation. 
	There are a number of software packages for symbolic 
computation, e.g. MACSYMA, Reduce, MAPLE, Mathematica, MicroCalc, etc. 
However, most of them require large memory, e.g. Mathematica requires 
at least 4 MBytes of RAM. MicroCalc is available for small IBM PC. 
MicroCalc provides graphical or numerical answers, and recognizes 
special symbols as constants and variables, but outputs formula only 
for derivatives.
	SymbMath is different from most of other software. (1) It 
only require 640 KBytes RAM, so it can run on small IBM PC under 
MS-DOS. (2) It is able to learn from human as machine learning. If 
users only show it one thing (e.g. one integral) without writing any 
line of program, it will learn many relative knowledges (e.g. many 
integrals) although it has no these predefined knowledges before. (3) 
Users easily edit the library (e.g. integral tables) in the formula 
format. (4) It can do something that other software cannot do.


                  2.	 Capabilities
	Its capabilities include facilities to provide analytical and 
numerical answers for:
	1. Differentiation: derivatives, higher order derivatives, 
partial derivatives, mixed derivatives, total derivatives, implicit
differentiation.
	2. Integration: indefinite integration, definite integration, 
multiple integration, infinite integration, parametric integration, 
iterated integration, line integration, surface integration, 
discontinuous integration, implicit integration.
	3. Solution of equations: polynomial equations, algebraic 
equations, systems of equations, differential and integral equations.
	4. Manipulation of expressions: simplification, factorisation, 
expansion, substitution, evaluation, user-defined functions, built-in 
standard functions (including the error function).
	5. Calculation: exact and floating-point numerical computation 
of integer, rational, real and complex numbers in the range from 
-infinity to infinity, even with different units.
	6. Limits: real limits, complex limits, one-sided limits, 
including the indeterminate forms, (e.g. 0/0, infinity/infinity, etc.).
	7. Chemical calculation: the molecular weights, atomic weights, 
and concentrations, by entering the symbols of the chemical elements.
	8. Chemical reactions: inorganic and organic chemical reactions.
	9. Others such as extrema, Taylor series, lists, arrays, vectors,
matrices, sum, product, etc.
	Its features also include:
	1. Programming as an interpreter.
	2. Interface with other software (e.g. with PlotData for graph).
        3. Outputting two-dimentional displays, and the BASIC format.
	4. On-line help, on-line manual.
	5. Syntax check and the line editor for input.
	Shareware version of SymbMath, SM14A.ZIP, is available from 
the Calculator directory in SIMTEL20 on anonymous FTP sites.
        SymbMath is growing though it has limited features at the moment.


			3.	 Keywords
	The following special symbols (about 100 words) are reserved:

		Keywords in alphabetical order
----------------------------------------------------------------------
abs, acos, asin, atan, 
ClearAll, coef, Constant, cos, cosh, cot, coth, csc, csch, 
d, defined, Direction, done, DOS,
e, E, end, endwrite, erf, exit, exp, expand, 
factor, from,
i, im, inf, inte,
last, Left, lim, list, ln,
Numerical, NumIntegrate,
Off, On, Output, OneDim, to,
pi, prod,
re, read, Right, 
sec, sech, ShowAll, sgn, sin, sinh, solve, sqrt, sum, step, subs,
table, tan, tanh, TwoDim,
undefined,
write,
zero,
+, -, *, /, ^, (), [], =, ==, >, >=, <, <=, <>, !, ?, ,
-----------------------------------------------------------------------


		Keywords in functional order
---------------------------------------------------------
1. Built-in constants: i, e, pi, inf, zero. 
2. Negative and positive: -, +.
3. Algebraic operators:	+, -, *, /, ^, (), =, ==.
4. Logic operators: ==, >, >=, <, <=, <>.
5. Algebraic functions: -x, sqrt(x), sgn(x), abs(x), n!.
6. Exponential functions: exp(x), ln(x), erf(x).
7. Trigonometric functions: sin(x), cos(x), tan(x), csc(x), sec(x), 
	cot(x), asin(x), acos(x), atan(x).
8. Hyperbolic functions: sinh(x), cosh(x), tanh(x), csch(x), sech(x), 
	coth(x).
9. Complex functios: re(x), im(x).
10. User-defined functions: f(x), f(x,y).
11. Calculus functions: d((y)/d(x)), inte((y)*d(x)), subs(x=a to y), 
	lim(x=a, y).
12. Transformation functions: list(), sum(), prod(), expand(), factor(),
	solve(), table(), coef().
13. List: [a, b], f[1].
14. Switches: =, Numerical, NumIntegrate, Output, On, Off, OneDim, 
	TwoDim, Direction, Left, Right.
15. Commands: ?, exit, DOS, DOS(), last, ClearAll, ShowAll, read, end,
	write, endwrite, <Esc>, <Ctrl>, <Alt>, <F8>, <F5>.
16. Separators: "," , from, to, step.
17. Other: undefined, defined, done, Constant.
--------------------------------------------------------------------

Note:	Upper and lower case letters are different in SymbMath.


		4. Symbolic, Help, Write, and Print Modes
	SymbMath has four modes: Symbolic, Help, Write, and Print. 
When usrs start SymbMath, it goes to the Symbolic Mode.

		4.1 Symbolic Mode
	Users do symbolic computation in the Symbolic Mode. It is in the
Symbolic Mode window.

		4.2. Help Mode
	A quation mark "?" will go into the HELP Mode for on-line help.
The Help Mode is in another Help Mode window. The on-line help file is 
a text file. 


-------------------------------------------------------------------
Commands	Action

<F5>	 	zoom HELP Mode window, <F5> again resize
<Esc>		exit HLPE Mode
<F10>		exit HELP Mode
<PgUp>		page up
<PgDn>		page down
<F2>		go to nth line, end by <F2> instead of <Enter>
<F3>		search for the special word, end by <F3> instead of 
		<Enter>
<Shift><F10>	resize window, end by <Shift><F10> instead of <Enter>
-------------------------------------------------------------------

			4.3 Write Mode
	Users go to the Write Mode by the command write. All output is 
written to a disk file (default fileanme is SymbMath.Out) instead of
the screen. Users return the Symbolic Mode by the command endwrite.
The Write Mode is in the same window as the Symbolic Mode window.

			4.4. Print Mode
	Users go to the Print Mode by <Alt>P, and set Printer On in
the Print window to toggles echoing to a printer, or/and set Log File
On to toggles echoing to the log file "Prolog.Log". The Print Mode is 
in another window.
	By using MS-DOS screen print command <Print Screen>, 
everything on screen is printed. 


			5. Data Type
	Data that SymbMath accepts is the numbers, constants, variables,
functions, equations, lists, arrays, vectors, and matrxies. All data
can be operated.

			5.1 Numbers
	The types of numbers are integer, rational, floating-point, 
power, real and complex numbers in the range from -infinity to 
infinity. 
	In fact, the range of the input real numbers is 
-inf, -(10^308)^(10^308) to -(10^-308)^(10^-308), 0, (10^-308)^(10^-308)
 to (10^308)^(10^308), inf.
	The range of the output real numbers is the same as input 
when the switch Numerical=Off, but when the swich Numerical=On, it is
	-inf, -1.E308 to -1.E-308, 0, -1.E308 to 1.E308, inf.
	It means that the number larger than 1.e308 is converted 
automately to inf, the absolute values of the number less than 
1.e-308 is converted to 0, and the number less than -1e308 is 
converted to -inf, when the switch Numerical=On.

	For examples:
-------------------------------------------
Numbers		Type

23		integer
2/3		rational
0.23		floating-point
2.3E2		floating-point
2.3e-2		floating-point
2.3*10^20	power
10^1.E200	power
2+3*i		complex
inf		real
inf+i		complex
3.14+inf*i	complex
inf+inf*i	complex
---------------------------------------------

	The real numbers include the integer, rational, floating-
point, and power numbers. They may be different when the switch 
Numerical=Off, and are the same when the switch Numerical=On (i.e. 
all converted to the floating-point numbers). That "a" and "b" are 
the same means a-b = 0, while that they are different means a-b<>0. 
For the floating-point numbers, the upper and lower case letters E 
and e are the same, e.g. 1e2 is the same as 1E2.

		5.2. Constants and Built-in Constants
	Constants are the numbers or values. There are some built-in 
constants. The name of theses constants should be avoided in the user-
defined constants.

------------------------------------------------------------------
Built-in Constans	Meanings

pi=3.1415926536		the circular constant.
e=2.7182818285		the base of the natural logarithms.
      1/2
i=(-1)
inf			infinity.
-inf	 		negative infinity.
c-zero			approach c from negative.
c+zero			approach c from positive.
undefined		undefined values, e.g. 0/0, 1/0.
Constant		constant, integral constnat
--------------------------------------------------------------------

			5.3. Variables
	The sequence of charactors is used as the name of variables. 
The usual used independent variable is "x". A value can be assigned to
the variable by the assigment "=", by the user-defined function f(), 
or by the SymbMath function subs().


		5.4. Functions
		5.4.1 Built-in Standard Functions
	 Different versions of SymbMath have different buil-in 
standard functions. The Advanced Version C has all of them. See 
the following table in detail for other versions.

		5.1 Table of Standard Functions
-----------------------------------------------------------------------
Functions	Meanings

n!		factorial of n.
sqrt(x)		square root, the same as x^0.5.
exp(x) 		the same as e^x.
sgn(x)		1 when Re(x) > 0, or Re(x) = 0 and Im(x) > 0; 0 when x=0;
		-1 otherwise.

............... above functions in Shareware Version A ...................

re(x)		(1) real part of complex numbers, 
		(2) left hand side of an equation.
im(x)		(1) imaginative part of complex numbers, 
		(2) right hand side of an equation.
ln(x) 		natural log.
abs(x)		absolute value of x.

sin(x) 
cos(x) 
tan(x) 
csc(x) 
sec(x) 
cot(x) 
asin(x) 
acos(x) 
atan(x)

................ above functions in Simple Version B ...................

sinh(x) 
cosh(x) 
tanh(x) 
csch(x) 
sech(x) 
coth(x)

erf(x)		error function.
--------------------------------------------------------------------------


		5.4.2 Calculus and Transformation Functions

----------------------------------------------------------------------
Functions	Meanings

subs(x=c, y)	substitutes x by c in y.
subs(x=c to y)	the same as subs(x=c,y).
lim(x=c, y)	gives the limit of y when x approaches c. Note that the 
		correct answers only for the indeterminate forms, e.g. 
		0/0, inf/inf and 0*inf.
d(y, x=c)	gives the derivative of y with respect to an undefined
		variable x at x=c.
d(y, x=c, n)	gives the nth order derivative of y with respect to an 
		undefined variable x at x=c.
d((y)/d(x))	differentiate y with respect to x.
d((y)/d(x)), n)	gives the nth order derivattive of y with respect to an 
		undefined variable x.
d(y)		implicit differentiation, used in differential equations, 
		e.g. x*d(x)+y*d(y) == 0.
inte(y,x,a,b)	find the definite integral of y with respect to an 
		undefined variable x taken from x=a to x=b.
inte(y, x from a to b)	the same as inte(y, (x,a,b)).
inte((y)*d(x))	find the indefinite integral of y with respect to an
		undefined variable x.
inte(y)		implicit integration, used to integrate the differential
		equations

expand(F)	expand F, e.g. (a+b)^2 -> a^2 + 2*a*b + b^2.
factor(F)	factorise from F, e.g. a^2 + 2*a*b + b^2 -> (a+b)^2.
solve(F==0, x)	solve polynomial equation, systems of linear equations,
		linear differential equations.
sum(y, x from a to b step c)	sum of y.
sum(y, x from a to b)		sum of y step=1.
sum([y])			transform list to sum
prod(y, x from a to b step c)	product of y.
prod(y, x from a to b)		product of y step=1.
list(y, x from a to b step c)	lists of y
list(y)				transform sum to list
table(y, x from a to b step c)	data table
coef(expr, x^n)			gives the coefficient of x^n in expr.
-----------------------------------------------------------------------


	For example:
---------------------------------------------------------
differetiation	diff()		d((x^2)/d(x))		
integration	inte()		inte((x^2)*d(x))	
limit		lim()		lim(x=0, sin(x)/x)	
solving		solve()		solve(x^2+1==0, x)	
expanding	expand()	expand((a+b)^2)		
factoring	factor()	factor(a*c+b*c)		
-----------------------------------------------------------

	Above functions can be operated and chained, like the standard 
functions. The undefined variable "x" is only a simple variable.
	If the undefined variable d(x) is omitted in the functions d(y) 
and inte(y), they are implicit derivatives and integrals. If f(x) is 
undefined, d(f(x)/d(x)) is differentiation of f(x). These are useful in 
the differential and integral equations. (see later chapters).
	For examples:
	inte(inte(F * d(x)) * d(y)) is double integral with respect 
to both variables x and y. 
	d(d(y/d(x)) x=c) is the second order derivative of y with 
respect to x at x=c.
	d(d(y/d(x))/ d(t)) is the mixed derivative of y with respect 
to x and t.
	d((y)/d(x)) is different from d(y)/d(x): (1) d((y)/d(x)) is 
an operation of differentation, while d(y)/d(x) is not; (2) y and d(x)
is inside the same () in d((y)/d(x)), while d(y) and d(x) can be 
separated in d(y)/d(x). d(y)/d(x) is the same as y', d(x) can be 
operated.
	The Shareware Version has no solve() and lim(), while the 
Simple version and the Advanced version have all of these functions.


		5.4.3 Users-defined Functions
	Users can define the new functions by operator "=", they 
include the standard functions, SymbMath functions, and algebraic 
operators. 
	There are two ways to define new functions. First method is
to define "f(x)=", and then call f(x) as the standard functions. The 
function name can be any symbol. There are only two local variable 
in the users-defined functions on this version, e.g. f(x) and f(x,y). 
	Second method is to define "y=", and then call the the 
functions by subs(x=c to y).
	To assign it to itseft clears a value or function from memory.
x=x		clear x from memory.
f(x)=f(x)	clear f(x) from memory.
ClearAll	clear all from memory.
	Note that the switch library "Switch.Li" should be read after 
clearing all from memory by "ClearAll", otherwise the default switches
may be changed.


		5.5 Equatios
	An equation is an equality of two sides by "==", e.g. x^2+p == 0,
where the symbol "==" stands for an equation. Note the symbols "==" and 
"=" are different. Systems of equations are lists, e.g. 
[a1*x+a2*y==a3, b1*x+b2*y==b3].


		5.6 Lists, Array, Vectors and Matrices
	A list is [a, b, c].
	An array is [a, b, [c1, c2]].
	A vector and matrix are similar a list and array, but in a matrix,
the number of elements in each row should be the same, e.g. 
[[a11, a12], [a21, a22]].


			6. Operators

	Table 6.1	Operators
-----------------------------------------------------------------
Operation	Operators	Examples		Order

comma		,		a=2, b=3		1
assignment	=		p=2+b			2
equation	==		x^2+x+1==0		3
plus		+		a+b			4
minus		-		a-b			4
multication	*		a*b			5
division	/		a/b			5
power		^		a^b			6
factoral	!		n!			6
positive	+		+a			7
negative	-		-a			7
function	f()		sin(x)			7
index of list	f[]		f[1]			7
paratheses	()		(a+b)*c			8
list		[]		[a,b]			8
--------------------------------------------------------------------

	All functions have the same 7th order.
        Operations with higher order preceede, otherwise operations are
performed left to right.  These are the usual algebraic conventions.
	a^b^c is the same as (a^b)^c.


			7. Expressions
	An expression (i.e. expr) is combination of data and operators.
e.g. a+b-c.


			8. Input and Output
	SymbMath can read input from a keybroad and a disk, and write 
output to screen, a disk and a printer.
	When input is read from the keybroad, a key <F8> is for the 
last input. If input is error, to press the key <F8> to get original 
input and to edit it by the keybroad editing keys. 
	A reserved word "last" always is the last output regardless 
there is input, and <F8> is always the last input regardless there is 
output.
	Users can go to the Write Mode to write output into a disk 
file by the command "write", and exit the WRITE Mode by the command 
"endwrite". These output can be read back to SymbMath by the command 
"read".

-------------------------------------------------------
Editing Keys		Functions

<-			move one step backward
->			move one step forward
<Home>			move to the first charactor
<End>			move to the last charactor
<Backspace>		delete a charactor forward
<Del>			delete a charactor hereby
<Crtl>Y			delete whole input line
<Esc>			abort the input
---------------------------------------------------------------


			9. Commands
----------------------------------------------------------------------
Commands	Action

?		help.
exit		(1) exit SymbMath, (2) the end of the program in the 
		file xxx.DOS.
<Esc>		(1) exit the HELP Mode, (2) abort input.
DOS		go to the MS-DOS shell, return to SymbMath by typing 
		"exit".
DOS(xx)		execute the MS-DOS command xx.
last		the last output.
last[1]		the first element of the last output list.
<F8>		the last input.
ShowAll		show all the variables in memory.
ClearAll	clear all the variables from memory.
read		read the programs (the xx.SM file) or library 
		(the xx.Li file) from a disk.
end		the end of the program and library files.
write		to go the Write Mode to write output to a disk file.
endwrite	stop writing output to a disk file.
<Alt>P		go to the Print Mode for echoing output to a printer
		or/and a log file "Prolog.Log".
<Ctrl>Z		the same as <Enter>
<Ctrl>M		the same as <Enter>
<Ctrl>Y		delete whole line input.
<Alt>R		the same as <Alt>P.
<Enter>		execute.
<F10>		the same as <Enter>.
---------------------------------------------------------------------------


			10. Switches
----------------------------------------------------------------------------
Switch			Action

Numerical=On		convert numbers to floating-point numbers.
Numerical=Off		not convert numbers to floating-point numbers, 
			this is default.
NumIntegrate=Off	symbolicially integrate, this is default.
NumIntegrate=On		numerically integrate.
Output=TwoDim		display output in two dimension, this is default.
Output=OneDim		display output in one dimension.
Output=Off		not display output.
Direction=Left		the left limits.
Direction=Right		the right limits.
-----------------------------------------------------------------------------

        Remember first letter of the switch is upper case, and first
letter of words are upper case, too. e.g. TwoDim means two dimension.

			11. Separators
	The keywords "from" "to" "step" "," are the same.


			12. Programming
	SymbMath is an interpreter, and accepts input from the 
keyboard and a disk. It runs the program written by any editor in the 
file of the text format. On the SymbMath prompt, type "read" <Enter>, 
and the full name of the program (e.g. fSolve.SM, c:\SymbMath\fSolve.SM), 
to read. After the program was readed, users can call any part of the 
program as the input from the keyboard within SymbMath. Users can read 
many programs into SymbMath at a time. However,  all names of the 
variables are public and name conflicts must be avoived. Users can 
clear all of them from SymbMath by "ClearAll".
	Alterately, a program can be run in a batch file on the 
MS-DOS prompt, but only one program runs in one time. For example, on 
the MS-DOS prompt, the program fSolve.DOS runs as
A:\> SymbMath < fSolve.DOS
	Notice that the end of the program is "end" in the xx.SM file,
but is "exit" in the xx.DOS file.


			13. Library
	A library is a text file with a table of formula in mathematical 
notation, so users can edit them by any text editor. In order to expand 
the special ability of SymbMath, some libraries should be read. Users can 
read many libraries into SymbMath by the command "read" at a time. However,  
all names of the variables are public and name conflicts must be avoived. 
Users can clear all of them from SymbMath by "ClearAll".
	Note that the switch library "Switch.Li" should be read after 
clearing all from memory by "ClearAll", otherwise the default switch 
may be changed.
	There are many libraries. The following are some of them.

	Table 13.1	Library
------------------------------------------------------------------------
File Name		Library Function

Switch.Li		switches on the default state.
Units.Li		an units conversion.
Function.Li		the user-defined functions.
Reduce.Li		reduction of expressions.
Integral.Li		integrals.
Derivati.Li		derivatives of special functions.
Diff.Li			to find total derivatives, and implitic 
			derivatives of an equation on one step.
Chemical.Li		the atomic weight of chemical elements.
Inorgani.Li		inorganic chemical reactions.
Organic.Li		organic chemical reactions.
-----------------------------------------------------------------------


			14. Learning from Human
	SymbMath can learn from human being. If users teach SymbMath 
something that it cannot do before, then SymbMath can do many things 
since then. Why does SymbMath become to have many knowledge ? Because 
SymbMath has learned from uers. 
	For example, users show SymbMath that an indefinite integral 
of tan(x)^2 is tan(x)-x, then ask for a double definite integral of 
tan(x)^2+y respect with both x from 0 to 1 and y from 0 to 2. On the 
following example, the first three input lines are to check whether 
SymbMath has already known these integrals or not (i.e. to check 
if these integrals have already be stored in the data base or 
knowledge base, these checkings can be omitted if users trust 
SymbMath without these predefined knowledge), the fourth input line 
is to teach SymbMath the indefinite integral of tan(x)^2. The other 
input lines are to ask for the double definite integral of tan(x)^2+y 
and the indefinite integral of tan(x)^2+x.

->inte(tan(x)^2*d(x))

->inte((2*tan(x)^2+x)*d(x))

->inte(inte(tan(x)^2+y, x from 0 to 1), y from 0 to 2)

->inte(tan(x)^2*d(x)) = tan(x)-x

inte(tan(x)^2*d(x)) = tan(x) - x
->inte(inte(tan(x)^2+y, x from 0 to 1), y from 0 to 2)

2 tan(1)
->inte((2*tan(x)^2+x)*d(x))

2 (tan(x) - x) + (1/2)*x^2

Users will continue to ask for inte(inte(tan(x)^2+y^2), x from 1 to 2),
y from 2 to 4), inte(inte(tan(x)^2*y)*d(x))*d(y)), inte(x*tan(x)^2*d(x)), 
triple integral of tan(x)^2-y+z, or others. Try it !
	Notice that SymbMath has no knowledge about all of these 
integrals before. Users did nothing except for only telling SymbMath 
one indefinite integral of tan(x)^2, did not tell SymbMath anything 
about other indefinite integral (e.g. tan(x)^2+y, tan(x)^2+x, etc.), 
an indefinite double integral, definite integral, or definite double 
integral, did not write any line of a program (a function or 
procedure), did not load any file, or did not call any program. 
SymbMath will become to know all of these integrals although they are 
different. This learning can be saved into a disk as a library file, 
so that SymbMath will never forget it, otherwise SymbMath will forget 
the learning when the computer power is off.
	Learning is different from programming. Although users only 
show SymbMath one thing, SymbMath will learn many knowledges. 
SymbMath is able to learn, as a student does. On programming, users 
have many things to do. First, users define many procedures for the 
individual integrands (e.g. tan(x)^2, tan(x)^2+y^2, 2*tan(x)^2+x, 
x*tan(x)^2, etc.), and for individual integrals (e.g. the indefinite 
integral, definite integral, the indefinite double integrals, 
indefinite tripble interals, definite double integrals, definite 
tripble integrals, etc.), second, write many lines of body of the 
individual procedures, (i.e. to tell a computer how to calculate 
these integrals), third, load these procedures, finally, call these 
procedures. Users are required to know how to write many programs.
