
		Transforms

Currently the only tranform defined is {LaplaceTransform},
which has the calling convention:

*	LaplaceTransform(var1,var2,func)

It has been setup much like the integration algorithm. 
If the transformation algorithm cannot perform the transform, the
expression (in theory) is returned unsimplified. Some cases
may still erroneously return {Undefined} or {Infinity}.

	    The {LaplaceTransform} algorithm

This section describes the steps taken in doing a Laplace 
transform.

	    General structure

{LaplaceTransform} is immediately handed off to {LapTran}.
This is done because if the last {LapTran} rule is met, the
Laplace transform couldn't be found and it can then return
{LaplaceTransform} unevaluated.

	    Operational Properties

The first rules that are matched against utilize the various
operational properties of {LaplaceTransform}, such as: 

*	Linearity Properties
*	Shift properties, i.e. multiplying the function by an exponential
*	$ y * x^n = (-1)^n * Deriv(x,n) LaplaceTransform(x,x[2],y) $
*	$ y/x = Integrate(x[2],x[2],Infinity) LapTran(x,x[2],y) $


The last operational property dealing with integration is not
yet fully bug-tested, it sometimes returns {Undefined} or {Infinity}
if the integral returns such. 

	    Transform tables

For elementary functions, Yacas uses transform tables. For instance,
the fact that the Laplace transform of $ Cos(t) $ is $ s/(s^2+1) $ is
declared in a transform table.

For the purpose of setting up the transform table, a few
declaration functions have been defined, which use some
generalized pattern matchers to be more flexible in recognizing
expressions that are transformable.

	    Transforming simple functions 

For functions like $ Sin(t) $ the transform can be declared
with the function {LapTranDef}. 

The calling sequence for {LapTranDef} is

	LapTranDef( in, out )

Currently {in} must be a variable of {_t} and {out} must be a function
of {s}.
For instance, for the function $ Cos(t) $ there is a declaration:

	LapTranDef( Cos(_t),                    s/(s^2+1) );

The fact that the first argument is a pattern means that each
occurrence of the variable to be matched should be referred
to as {_t}, as in the example above.

{LapTranDef} generalizes the transform implicitly, in that it will
set up the system to actually recognize expressions of the form
$ Cos(a*t) $ and $Cos(t/a)$ , and return the appropriate answer.
The way this is done is by three separate rules for case of {t} itself,
{a*t} and {t/a}. This is similar to the {MatchLinear} function that 
{Integrate} uses, except {LaplaceTransforms} must have {b=0}.

	    Further Directions

Currenlty $Sin(t)*Cos(t)$ cannot be transformed, because it requires
a convolution integral. This will be implemented soon. The inverse
laplace transform will be implement soon also.
