Welcome
*******

   Welcome to [3mLAPLACE[0m V0.7 (Evaluation version). This manual describes
the installation and usage of the [3mLAPLACE[0m program. The last update
was on 17.9.1996.

   [3mLAPLACE[0m is MAILWARE!! Send me an e-mail or a postcard, if you like
it!!  Please look at Copyright for more information.

Introduction
************

About
=====

   [3mLAPLACE[0m is (or at least should be) an universal tool for
mathematical calculations.  It lacks such a GUI with hundreds of
windows like those other progs I've found on AMIGA.  Instead it works
like a shell, you enter a command and get the result displayed, which
is much more flexible.

   I started programming [3mLAPLACE[0m, because I was looking for a program
for handling matrices, what I needed for my studies. First all programs
I found were only able to handle floatpoints, but especially in matrix
calculations this leads quite fast to large errors. So I made a simple
prog that handled fractions instead of floatpoints. After that I needed
something to handle parameters in matrices, and so I started totally
rewrote [3mLAPLACE[0m. This is the result.

Copyright
=========

   (C)1996 by A VISION OF PARADISE

   This is only an evaluation version of [3mLAPLACE[0m. I plan to make it
SHAREWARE, when it reaches a reasonable state. For know [3mLAPLACE[0m is
MAILWARE. This means that you should send me a short e-mail or a
postcard, if you can't use the Internet.  This way I will know, whether
there is a demand for my program and it does NOT mean anything like
registrating to [3mLAPLACE[0m or like wise. If there should be a SHAREWARE
version, you'll have to pay it (if you want ;-)

   You are not allowed to take money for distributing [3mLAPLACE[0m, except
for Urban Mueller and his AMINET CD-collection.

   You may distribute [3mLAPLACE[0m only as the original archive
([1mLaplace.lha[0m), which can be found in the AMINET in
[1mmisc/math/Laplace.lha[0m.

   You are not allowed to distribute modified versions of [3mLAPLACE[0m.
You may use modified version for your own, but I take absolutelly NO
responsilibity for anything in this case (I even hard for ME to
understand, what's happening inside of [3mLAPLACE[0m, so it's quite likely
that you won't understand it at all ;-)

   Use it on your own risk. If you plan to build a nuclear plant, I take
absolutely NO responsibility for uncontrolled chain reaction caused by
false calculations!!!

   I used the following tools to create [3mLAPLACE[0m:

   * MUI V3.3 by Stefan Stuntz (see also [1mDocs/Readme.mui[0m).

   * DICE V2.07 by Matthew Dillon.

   * ENFORCER V37 by Michael Sinz.

   * GOLDED V3.1.4 by Dietmar Eilert.

   * REVUP V1.3 by Boris Folgmann.

   * FLEXCAT V1.3 by Jochen Wiedmann.

   * MAKEGUIDE V1.54 by Reinhard Spisser and Sebastiano Vigna.

   * MUCHMORE V4.1 by Fiedtjof Siebert and Christian Stiens.

Registration
============

   Since [3mLAPLACE[0m is currently FREEWARE, there's no need to register.
But you may send comments, bug report, flames etc. of course.

Address
=======

   This master piece of programming arts was done by

    [1mP!\K of /|_ __   . /\  |\__: /|____  /\__:__/\  .
    [0m [1m      /   |  \  :/  \ |   |/      \/    |    \ :
    [0m [1m    _/    |   \_|  \ \|  _/   |\   \___   ___/ |
    [0m [1m    \     |     |   \ \  \    |/   /         \ |
    [0m [1m     \ _________|____\  _/\ ______/\  __|__  / :
    [0m [1m      \|        :     \/   \|       \/  ·  \/  .
    [0m

                                s-mail:

                          Benjamin Stegemann

                          Rohrbacher Str. 66

                           69115 Heidelberg

                                Germany

                                e-mail:

                   bstegema@ix.urz.uni-heidelberg.de

                bstegema@urz-mail.urz.uni-heidelberg.de

                                 WWW:

             http://www.rzuser.uni-heidelberg.de/~bstegema

   Actual versions of [3mLAPLACE[0m can be found in the AMINET directory
[1mmisc/math/[0m.

   If you are interested in other programs I've done so far, look at
these:

   * [3mShuffleRun[0m - Funny arcarde game for two or more players,
     including tournament mode.

   * [3mWriter[0m - Creates totally stupid texts, based on any ASCII input.
     Even greatest literature will be shamelessly blown up!!

   * [3mTreeGrow[0m - Create fractal tree images.

   * [3mGED_Syntax[0m - LaTeX and Texinfo Syntax parser for GoldED4. Can be
     found at

   * [3mGED_Syntax[0m - LaTeX and Texinfo Syntax parser for GoldED4.

   These progs are not available on AMINET, sorry, but it's quite old
stuff..
Oh, almost forgot it, they are published on Fish disks, wait a moment,
I will see which ones..
Jo, back again, it's 814 ([3mTreeGrow[0m), 815 ([3mShuffleRun[0m) and 818
([3mTankHunter[0m).  [3mWriter[0m is (or was) available on BBS.
If you are really interested, send me a mail.

   * [3mGED_Syntax[0m - LaTeX and Texinfo Syntax parser for GoldED4. Can be
     found at [1mtext/edit/GED_Syntax.lha[0m.

   * [3mPGP_GED4[0m - PGP for GoldED4. Just a modified ARexx script by Lunz
     O. Wolfgang.  Can be found at [1mtext/edit/PGP_GED4.lha[0m.

Greets
======

   Thanks must go to (in alphabetical order):

       [3mLauri Aalto[0m (support), [3mAnders Bakkevold[0m (Amiga Translators'
Organisation), [3mVolker Barthelmann[0m (support), [3mLars Bischoff[0m
(support), [3mMichael Bock[0m (support), [3mDirk Burkamp[0m (support),
[3mChristoph Dahlen[0m (support), [3mMatthew Dillon[0m (DICE), [3mWalter
Dörwald[0m (icons), [3mDietmar Eilert[0m (GOLDED), [3mMattias p. Eriksson[0m
(icons), [3mBoris Folgmann[0m (REVUP), [3mGrazgur[0m (support), [3mMichael 'Mick'
Hohmann[0m (icons), [3mMartin Huttenloher[0m (icons), [3mMario Kemper[0m
(support), [3mLars Malmborg[0m (support) [3mKonstantinos Margaritis[0m
(support), [3mAndreas Mayer[0m (support) [3mFrederik Orinius[0m (support),
[3mSotirios Pappas[0m (support) [3mChristoph Rickers[0m (support), [3mThomas
Schraitle[0m (support), [3mFiedtjof Siebert[0m (MUCHMORE), [3mMichael Sinz[0m
(ENFORCER), [3mReinhard Spisser[0m (MAKEGUIDE), [3mChristian Stiens[0m
(MUCHMORE), [3mStefan Stuntz[0m (MUI), [3mTracer[0m, [3mKen Tyler[0m (support),
[3mSebastiano Vigna[0m (MAKEGUIDE), [3mJochen Wiedmann[0m (FLEXCAT)

   And all other folks around this crazy planet, who support the
AMIGA!!!!

    [1mP!\K of /|_ __   . /\  |\__: /|____  /\__:__/\  .
    [0m [1m      /   |  \  :/  \ |   |/      \/    |    \ :
    [0m [1m    _/    |   \_|  \ \|  _/   |\   \___   ___/ |
    [0m [1m    \     |     |   \ \  \    |/   /         \ |
    [0m [1m     \ _________|____\  _/\ ______/\  __|__  / :
    [0m [1m      \|        :     \/   \|       \/  ·  \/  .[0m

Getting started
***************

Requirements
============

   * 68020 CPU or better.

   * OS3.0 (V38) or better.

   * MUI3.3 (see also [1mDocs/Readme.mui[0m).

   * and a FAAAAAST AMIGA...

Installation
============

   Since [3mLAPLACE[0m is still under development, I didn't write an
installer script ;-)

   But, don't be afraid, installing is really easy!! Just drag the
whole [3mLAPLACE[0m directory to any place you like, no libs, fonts,
catalogs to install. Even an assign isn't needed anymore.

   You may add the assign [1mLaplace:[0m to the [3mLAPLACE[0m directory, then
this assign will be uses as [1mPROGDIR:[0m, but this is currently not very
useful at all (except for me, as I need this to find all files when
debugging...).

Tooltypes
=========

   You may enter some tooltypes to the icon of [3mLAPLACE[0m. To do this,
select the icon on the workbench and choose [1mIcons/Information[0m from
the workbench menu. Then modify the list of tooltypes using the (quite
bad) edit functions.

   Tooltypes are supplied using this format:

     1. KEYWORD
     2. KEYWORD=value

   Syntax 1 is for tooltypes marked as [1mswitch[0m. The descripted action
is performed, if this keyword is found. To disable it, simple set the
keyword in brackets.

   Tooltypes marked as [1mstring[0m use syntax 2.

   Unknown keyword will be ignored, syntax is caseinsensitive.

   Supported tooltypes are :

[1mAREXXONLY[0m
     (switch)
     If specified [3mLAPLACE[0m won't open a window on startup, but starts
     iconified; only an application icon will be shown on the
     workbench. The first window is opened when doubleclicking on the
     application icon or uniconifying [3mLAPLACE[0m on another way. This is
     useful, if you want don't want to use [3mLAPLACE[0m directly, but only
     through it's ARexx port.

[1mQUIETEXIT[0m
     (switch)
     If specified [3mLAPLACE[0m will not complain about forgotten objects.

[1mAUTOLOAD[0m
     (string)
     Here you can specify a file to be loaded everytime [3mLAPLACE[0m
     starts.  I needed this mainly for testing...

[1mPREFS[0m
     (string)
     Specify a path for the preferences file to be used instead of
         [1mPROGDIR:Laplace.prefs[0m.

Usage
*****

Working with Laplace
====================

   [3mLAPLACE[0m works much like a shell, you enter an expression, press
return and [3mLAPLACE[0m gives you the result (after some time;-). See
Editing or Menus for more about text editing width [3mLAPLACE[0m.

   [3mLAPLACE[0m's processing is based on objects. You can define new
objects and reference them later. Have a look at Expressions and
Definitions.

   When a new window is opened, [3mLAPLACE[0m will do several things to
setup the environment:

   * load options from [1mPresets/Default.opts[0m.

   * load F-keys from [1mPresets/Default.fkey[0m.

   * execute the command [1minclude(Init.lh)[0m.  You may modify all these
files, to adjust the environment to your needs.  See also Presets or
Libraries.

   To load and save sessions, see Project.

Editing expressions
===================

   Well, I think the basic edit functions are now available.

   Clipboard is supported, but currently only whole lines can be
[3mcutted[0m, [3mcopied[0m and [3mpasted[0m.

       [3mInsert line[0m inserts a line before the current line; to insert
a line at the end, just press  [1m<return>[0m in the last line.  [3mDouble
clicking[0m on a line, works just line pressing return.

   Here are the keys that you can use for editing :

[1mbackspace[0m
[1mdel[0m
[1mleft[0m
[1mright[0m
[1mup[0m
[1mdown[0m
     guess what..

[1mshift left[0m
[1mshift right[0m
     advance one word

[1malt left[0m
     goto beginning of line

[1malt right[0m
     goto end of line

[1malt up[0m
     goto first line

[1malt down[0m
     goto last line

[1mctrl up[0m
     move one item up in history

[1mctrl down[0m
     move one item down in history

[1mctrl-shift up[0m
     move to first item in history

[1mctrl-shift down[0m
     move to last item in history

[1mesc[0m
     undo changes in current line. This work only, as long as you don't
     leave the line.

[1mreturn[0m
     evaluate the current line and advance to the next line.

[1mshift return[0m
     evaluate the current line and insert a new line after it.

[1malt return[0m
     split the current line at the cursor position and insert a new
     line after it.

[1mshift backspace[0m
     erase current line from cursor position to the beginning of the
     line.

[1mshift del[0m
     erase current line from cursor position to the end of the line.

[1malt backspace[0m
     clear the current line.

[1malt del[0m
     clear the result of the current line.

[1mctrl tab[0m
     pop up a list of all available objectes of the current context.
     Select an entry and it will be inserted at the current cursor
     position.

[1malt tab[0m
     pop up a list of all available functions

[1mFn[0m
[1mshift Fn[0m
     insert the string linked to a F-key

Menus
=====

[1mProject[0m
    [1mAbout[0m
          ;-)

    [1mAbout MUI[0m
          about MUI, what else

    [1mNew window[0m
          Open a new, blank window

    [1mClear[0m
          Clears the current window

    [1mLoad..[0m
          Open a project file

    [1mQuickload[0m
          Fast access to some project files. Use
          [1mProject/Preferences[0m to modifiy the list.

    [1mSave[0m
          Save a project file. Use the current path or select a new

    [1mSave as..[0m
          Save a project file. Select a new path

    [1mDelete..[0m
          Delete project files. They will be lost forever!

    [1mPreferences..[0m
          Opens the preferences window, see below for more information,

    [1mMUI Prefs[0m
          Open MUI preferences window

    [1mQuit[0m
          NOOOOOOOO :-O

[1mEdit[0m
    [1mCut[0m
    [1mCopy[0m
    [1mPaste[0m
    [1mInsert line[0m
    [1mRemove line[0m
          see Editing

[1mWindows[0m
    [1mDebug[0m
          Opens the debug window with a list of all debug strings.

[1mOptions[0m
    [1mEdit...[0m
          Here you specifiy the default values for dynamic options (see
          Options for a full description) and the strings that are
          connected to the F-keys.

          The defined strings will be inserted into the current line,
          if you you hit an F-key. There are some special code that can
          be inserted into the string. They are introduced with a
          [1m%[0m. If a [1m%[0m should be inserted, you have to enter
          [1m%%[0m. Possible codes are:

         [1m%l[0m
               move the cursor one step to the left.

         [1m%(l n)[0m
               move the cursor n steps to the left.

         [1m%r[0m
               move the cursor one step to the right.

         [1m%(r n)[0m
               move the cursor n steps to the right.

         [1m%(run command)[0m
               execute the given shell command.

          The options and F-keys are saved in each project file, but
          they can explicitly be loaded and saved to preset files.

    [1mLoad...[0m
          Load options or F-keys from a preset file. You can also
          select a project file.  In this case the options/F-keys will
          be extracted from the project.

    [1mSave...[0m
          Save options or F-keys to a preset file.

[1mARexx[0m
     A list of ARexx macros. Use [1mProject/Preferences[0m to modify it.

[1mHelp[0m
    [1mIndex[0m
          Loads this file, displaying the main page.

    [1mFunctions[0m
          Loads the file [1mDocs/../Functions[0m, displaying a menu of all
          functions.

    [1mRexx[0m
          Loads the file [1mDocs/../ARexx[0m, which describes the usage of
          the ARexx port.

    [1mSearch...[0m
          Opens a window, where you can specify a keyword to search
          for. If the keyword is found the file will be opened on the
          correct page. Note that the text window runs asyncron, which
          means that you can leave the window opened while working.
          You don't even have to close the window to continue the
          search. Just bring the 'Searching...' window to front, select
          'Continue' and the next page containing the keyword will be
          loaded into the textwindow.

Preferences
-----------

   bla bla bla...

Projects
========

   [3mLAPLACE[0m saves project files as plain ASCII files, you may edit
them with any standart text\-editor. Projects are usually placed in the
[1mProjects[0m directory.

   All options (see Menus) and the F-key definitions are save in the
project file, the same format as in preset files is used.

Presets
=======

   Options are saved as plain ASCII files, and are usually stored in the
[1mPresets[0m directory. The can be edited by any standart texteditor.

   The line format is quite simple: a line starts with an [1m#[0m followed
by a keyword, a [1m=[0m and the value for this option. You must not insert
any spaces, except otherwise stated below. E.g.
     #USEFLOAT=TRUE
     #ERRBND=12

Options
-------

   Options (marked with a [1mx[0m in Menus) are saved in files ending with
[1m.opts[0m. The keywords are:

[1m#USEFLOAT[0m
     set to [1mTRUE[0m or [1mFALSE[0m

[1m#SIMPLIFY[0m
     set to [1mTRUE[0m or [1mFALSE[0m

[1m#ERRBND[0m
     an integer value between [1m1[0m and [1m32[0m

[1m#EXPDSP[0m
     an integer value between [1m1[0m and [1m12[0m

[1m#PREC[0m
     an integer value between [1m0[0m and [1m15[0m

F-keys
------

   The F-key definitions are saved in files ending with [1m.fkey[0m. The
keyword is followed by the string for the key, the whole rest of the
line is used, including all spaces.

[1m#F1 ... #F10[0m
     normal F-keys 1..10

[1m#F11 ... #F20[0m
     shifted F-keys 1..10

Expressions
===========

   Expressions are entered in a usual manner, e.g.
     1+2/3*(4-2) [1m<return>[0m

   Guess what's the result...

   More formally, an correct expression is:

   * object (Types) or

   * reference (Definitions) or

   * function (Functions/Functions) or

   * expression list (see below) or

   * expression binary_operator expression

   * unary_operator expression

   Binary operators are:

[1m[1m+[0m, [1m-[0m, [1m*[0m, [1m/[0m, [1m^[0m[0m
     you should know these...

[1m[1m×[0m[0m
     vector product. This is not an usual [1mx[0m, but can be reached by
     [1malt-x[0m!

[1m[1m||[0m[0m
     boolean or

[1m[1m&&[0m[0m
     boolean and

[1m[1m==[0m, [1m!=[0m, [1m>[0m, [1m<[0m, [1m<=[0m, [1m>=[0m[0m
     comparison

   The only unary operator is:

[1m[1m![0m[0m
     boolean negation

   You may enter several expression at once, seperated by commas, e.g.
     1+2,2/4,12+10 [1m<return>[0m
   The results will be displayed seperated by lines.

Expression List
---------------

   An expression list is an list of expression seperated by commas
embedded in [1m{}[0m brackets or supplied to the [1mdo()[0m command.

   All expressions will be evaluated, but only the last result will be
used.  The result of the list will be this last result. This makes only
sense with functions like [1mdebug()[0m. E.g.
     sin({debug("Hello world!"), pi/2}) [1m<return>[0m

Types and objects
=================

   [3mLAPLACE[0m supports currently six types of objects : [1mNumber[0m,
[1mBoolean[0m, [1mVector[0m, [1mMatrix[0m, [1mEquation[0m and [1mSets[0m.

   Usually [3mLAPLACE[0m determines the type of an object when it is
created. If you declare a constant object, you have to specify the type
it should have.  To do so, you use the [1mconst()[0m function with
identifiers of the format [1mname:type[0m. This will create a new object
with the specified [1mname[0m and [1mtype[0m. Allowed types are

[1mn[0m, [1mnumber[0m
     number object (default, if you don't give a type)

[1mv[0m, [1mvec[0m, [1mvector[0m
     vector object of any dimension

[1mv[d][0m, [1mvec[d][0m, [1mvector[d][0m
     vector object of dimension [1md[0m

[1mm[0m, [1mmat[0m, [1mmatrix[0m
     matrix object of any size

[1mm[r,c][0m, [1mmat[r,c][0m, [1mmatrix[r,c][0m
     matrix object with [1mr[0m rows and [1mc[0m columns

   For example:
     const(a:vec[3])
     [1,2,3;4,5,6;7,8,9] * a

Number
------

   These are just numbers as well all know them (or do we know them
all?!).

   Numbers can be entered in exponential style, which is
    [1m{+/-/<nothing>}ddddd[.ddddd][e{+/-/<nothing>}dddd][0m.
Ufff, but it's quite easy;-) to enter e.g. [1m6.626 * 10^(-34)[0m write
[1m6.626e-34[0m. The (whole) number after [1me[0m is just the exponent. Don't
use brackets, if the exponent is negative!

   [3mLAPLACE[0m supports complex numbers. To enter a complex number,
simply write something like [1ma + b*i[0m. But they are not fully
implemented, e.g.  errordistribution is lost when you have complex
value in your expression and not all functions work now with complex
arguments.

   As long as you enter only whole numbers, [3mLAPLACE[0m tries to use
fractions, so enter [1m1/2[0m instead of [1m0.5[0m (in this simple case
[3mLAPLACE[0m converts [1m0.5[0m to [1m1/2[0m itself, but this may not always
work). This way you can enter things like [1m1/7[0m exactly, and you won't
get result which are almost exact zero, when it should be exact ;-)

   A fantastic new feature of [3mLAPLACE[0m is the direct support of
Gaussian errordistribution. Now it is possible to enter values with
their standart error, do what ever calculations you have to do, and
then get the result with the correct error value! This is very useful,
if you are calculating with result of some measurements, like I did
during my physical practial.

   For example, you want to measure the earth accelaration by measuring
the falling time of a ball. You measured the falling height to 1.119
meters with a precision of one millimeter and the time to 0.50 seconds
with a precision of 1/50 second.  Now simply enter:
     t=0.50±0.02
     h=1.119±0.001
     g=2*s/h^2
   and that's all!! (Next time you should do it more precisely..)

   The [1m±[0m can be entered by [1malt-y[0m (on the german keyboard) or
[1malt-z[0m (on others).

   But you should be aware, that in some cases you might get wrong
result, because [1m10±1 * 10±1[0m is not the same as [1m10±1 ^ 2[0m. So, if
the same value is used at different places in a formula, it is
evaluated as if they had indepented error ranges!

   The best way to avoid this is declaring all values with errors as
parameters, construct you (possibly big) formula and simplify it, so
that every parameter occures only a single time, e.g.:
     x := 10±1
     y := 12±2
     a = 3*x^2*y^3
     b = 5*x^3*y^2
     result = a/b
     eval(result)

   If you on the other hand have something like this:
     x := 10±1
     result = x/(x+1)
   you'll get a wrong error value and there is no way to avoid it,
sorry.

Boolean
-------

   A boolean object can only contain the two values [1mTRUE[0m and
[1mFALSE[0m.

   Possible operation for boolean objects are: [1m&&[0m (and), [1m||[0m (or) and
[1m![0m (not).

     a=TRUE
     b=FALSE
     c=TRUE
     a && (b || !c)

Vector
------

   A vector is a tupel of numbers. To create a vector [1m(2,4,1)[0m enter
[1m[2,4,1][0m.  Any expression can be (of course) a component of a vector.

   You can add and multiply (scalar) two vectors, or multiply a
[1mnumber[0m or [1mmatrix[0m with a vector (in this order, not [1mvector *
number[0m!). You get the vector product of two 3-dimensional vector by
typing [1mvector × vector[0m. The [1m×[0m is not an ordinary x, but can be
entered by [1malt-x[0m (on the german keyboard and probably all others,
too).

Matrix
------

   A matrix is something like a 2-dimensional vector.. (if you don't
know what's this, you probably won't need them ;-) A matrix with the
columnvectors [1m(1,2,3)[0m, [1m(4,5,6)[0m and [1m(7,8,9)[0m can be created with
[1m[1,2,3;4,5,6;7,8,9][0m.  If you have rowvector in mind, use
[1m[1,4,7;2,5,8;3,6,9]~[0m instead (append a 'tilde').

   You can add and multiply two matrices, or multiply a [1mnumber[0m and a
matrix (in this order, not [1mmatrix * number[0m!).

Equation
--------

   To create a equation use the [1meq()[0m command.

   You can of cource calculate with equations. The operations will be
applied on both side of the equation. You can add or multiply two
equations. If you add or multiply a [1mnumber[0m, [1mvector[0m or [1mmatrix[0m to
an equation, the equation has to be on the left side, e.g.
     a=eq(2*x+4,0) [1m<return>[0m
     a=a-4 [1m<return>[0m
     a=a/2 [1m<return>[0m

   You can also apply functions line [1msin()[0m, [1mexp()[0m... on equations,
e.g.
     a=eq(ln(x),12*e) [1m<return>[0m
     a=exp(a) [1m<return>[0m

Set
---

   To create a set use the [1mset()[0m command.

   A set is a set (?!?) of objects of the same type. Currently there
are some statistic functions that can be applied to sets.

   If you calculate with sets, all operations (exept those affecting
the set directly) are applied to all elements of the set, e.g.
     s=set(1,2,3) [1m<return>[0m
     s+2 [1m<return>[0m
   This will return the set {3,4,5}

Definitions
===========

   If you want to use an result later or just define a variable, write
[1mname = expression[0m. This creates an objects that can be referenced by
it's name in later(!) lines. If you reference to an object,
[3mLAPLACE[0m searches from the actual line back, so you may define an
object several times, but only the latest version is used. E.g.
     [1] a=1/2 [1m<return>[0m
     [2] 2*a [1m<return>[0m
     => gets 'a' from [1]
     [3] a=a+1 [1m<return>[0m
     => 'a' on the right side references to the definition in [1]
     => and creates a new object called 'a' to be referenced below
     [4] a [1m<return>[0m
     => gets 'a' from [3]

   If you move back to [2], you still get the same result, because the
new [1ma[0m is defined below and cannot be reference from [2].

   If [3mLAPLACE[0m encounters a object name, that was not defined earlier,
an constant will be automatically created:
     f(x) = x^2 [1m<return>[0m
     f(a) [1m<return>[0m
     => a^2
   This is the same as
     f(x) = x^2 [1m<return>[0m
     const(a) [1m<return>[0m
     f(a) [1m<return>[0m
     => a^2

   This work only for number constants. If you require e.g. a constant
vector object, you have to use [1mconst()[0m to declare it.

   Generally you should always declare constants with [1mconst()[0m,
otherwise you are in danger that the reference has already been defined
(e.g. in a library file) and you get an type error, look at this:
     a=[1,2]
     ....
     [thousand of lines...]
     ....
     f(x)=x^2
     f(a)
     error--> Not defined to vectors.

Conventions
-----------

   There are some special conventions for object names. Valid
characters are [1mA..Z Ö Ä Ü a..z ö ä ü 0..9 @ § $ ' ~ _[0m. You may
not use a number as the first character.

   There are two special characters which may be used: [1m~[0m (tilde) and
[1m_[0m (underscore). [1m_[0m as the first character will create a line above
the name, which is often used in mathematics. Inside the name [1m_[0m will
create an index, character after [1m_[0m will be used as the index at the
bottom of the name. [1m~[0m work similar, but creates an index at the
Usage. You can use both indexes. E.g. [1m_a[0m, [1ma_1[0m, [1ma~1[0m or everything
at once [1m_a~2_1[0m.

   Starting with version 0.3 [3mLAPLACE[0m support the usage of greek
symbols. If the name or an index matches the name of a greek letter,
then this letter is used to display the variable. Number may follow the
letter name. E.g. [1malpha1_beta[0m. A name in lower case represents a
small greek letter; if the first character of the name is uppercase,
then you get an big greek letter. All supported names are :

       [3malpha[0m, [3mbeta[0m, [3mgamma[0m, [3mdelta[0m, [3mepsilon[0m, [3mzeta[0m, [3meta[0m,
[3mtheta[0m, [3mjota[0m, [3mkappa[0m, [3mlambda[0m, [3mmy[0m, [3mny[0m, [3mxi[0m, [3momikron[0m,
[3mpi[0m, [3mrho[0m, [3msigma[0m, [3mtau[0m, [3mypsilon[0m, [3mphi[0m, [3mchi[0m, [3mpsi[0m,
[3momega[0m, [3mAlpha[0m, [3mBeta[0m, [3mGamma[0m, [3mDelta[0m, [3mEpsilon[0m, [3mZeta[0m,
[3mEta[0m, [3mTheta[0m, [3mJota[0m, [3mKappa[0m, [3mLambda[0m, [3mMy[0m, [3mNy[0m, [3mXi[0m,
[3mOmikron[0m, [3mPi[0m, [3mRho[0m, [3mSigma[0m, [3mTau[0m, [3mYpsilon[0m, [3mPhi[0m, [3mChi[0m,
[3mPsi[0m, [3mOmega[0m

Definition types
----------------

   There are three difference kinds of definitions : [1mvariables[0m,
[1mparameters[0m and [1mconstants[0m.

Variables
.........

   When you reference a [1mvariable[0m, it's contents will be inserted.
Variable are defined using [1mname = expression[0m. E.g.
     a=3 [1m<return>[0m
     a+1 [1m<return>[0m
     => 4

Parameters
..........

   A reference to a [1mparameter[0m will not be evaluated, it will remain
in the result.  Use [1mname := expression[0m to create a parameter. If you
want to get the final result use the [1meval()[0m function. E.g.
     a:=3 [1m<return>[0m
     2*(a+2) [1m<return>[0m
     => 2*a+4
     eval(2*(a+2)) [1m<return>[0m
     => 10

Constants
.........

       [1mConstants[0m have no value, so they won't be evaluate, even with
the [1meval()[0m function. They are defined using the [1mconst()[0m function.
E.g.
     const(a) [1m<return>[0m
     2*(a+2) [1m<return>[0m
     => 2*a+4
     eval(2*(a+2)) [1m<return>[0m
     => 2*a+4

Functions
.........

   You can also define [1mfunctions[0m. Just enter a argument list embedded
in bracket after the object name, e.g.
     f(x):=x^3 [1m<return>[0m

   The arguments will be handled like constants in the function
expression. If you want to use other object type than numbers, you have
to specify the type in the parameter list, the format is line in
[1mconst()[0m.

   When referencing a function you have to specify the arguments to be
inserted into the function's expression, e.g.
     f(3) [1m<return>[0m
     => 27
     const(a) [1m<return>[0m
     f(a+1) [1m<return>[0m
     => (a+1)^3

   It is also possible to omit the arguments; if you do so,
[3mLAPLACE[0m will insert the arguments as they were defined, e.g.
     f(x,y) = x^2 + y^2 [1m<return>[0m
     f'(x,y) = diff(f(x,y),x) [1m<return>[0m
     f'(x,y) = diff(f,x) [1m<return>[0m
   Note that the last two lines are the same, because [1mf[0m will be
expanded to [1mf(x,y)[0m.

Libraries
=========

   [3mLAPLACE[0m offers the ability to process external files. These files
are plain ASCII files and may be edited with every texteditor. These
files will be processed, just as if each line would be entered, blank
lines and lines with leading [1m;[0m will be ignored. The results won't be
displayed, so this is only useful for constant and function
definitions. Library files have a trailing [1m.lh[0m and are located in the
[1mInclude[0m directory.  Use the [1minclude()[0m command to gain access to a
library.

   Some basic files are included:

[1mInit.lh[0m
     This file will always processed, when a new window is opened.

[1mInitARexx.lh[0m
     This file will be processed during the initialization of the
     ARexx-port.

[1mmath.lh[0m
     Some useful mathmatical definition.

[1mphysic.lh[0m
     Some useful physical definition.

   If you want a library to be available on startup add a line
[1minclude([1mlibname.lh[0m)[0m to the file [1mInclude/Init.lh[0m, which is
always processed on startup.

Options
=======

   There are some options to influence to calculation or presentation
of expression.  They are marked with a [1m$[0m (dollar sign) following a
keyword, a [1m=[0m and the new value.

   As always, [3mLAPLACE[0m searches backwards until it finds an option,
this way setting an option will not influence the lines above. If not
explicit assignment has been done, the default value is used. To modify
these defaults, use the menu item [1mOptions/Edit...[0m.

   These are the keyword:

[1m$usefloat[0m
     Possible value: [1mTRUE[0m, [1mFALSE[0m. If set to [1mTRUE[0m, [3mLAPLACE[0m will
     always use floatpoints and never converts them to fractions.

[1m$useerror[0m
     Possible value: [1mTRUE[0m, [1mFALSE[0m. If set to [1mFALSE[0m, [3mLAPLACE[0m will
     not use and display error ranges.

[1m$simplify[0m
     Possible value: [1mTRUE[0m, [1mFALSE[0m. Enable/Disable simplification
     pass. Without simplification, the calculation will be faster, but
     the result might look quite ugly.

[1m$dispprec[0m
     Possible value: [1m1..15[0m. Select maximum number of decimal digits
     to be displayed.

[1m$dispexp[0m
     Possible value: [1m1..12[0m. Select number of digits to be displayed
     before switching to exponential display.

[1m$convprec[0m
     Possible value: [1m1..32[0m. [3mLAPLACE[0m tries to convert floatpoints
     into fractions whenever possible.  But the floatpoint routines are
     not too exact, so there might be an small difference to the
     correct value (e.g. 1.2000000000000001 when it should be 1.2).  If
     the difference is smaller than the specified precision (precision
     12 means 10^(-12)), [3mLAPLACE[0m assumes the value as a fraction and
     converts it (in this case to 6/5).  This is not applied to value
     near zero, so 1e-30 won't be converted to 0.

   For example:
     $usefloat=FALSE
     sin(2) => sin(2)
     $usefloat=TRUE
     $dispprec=5
     sin(2) => 0.9093
     $dispprec=8
     sin(2) => 0.90929743
     a=12000.3
     $dispexp=3
     a => 1.20003*10^4
     $dispexp=6
     a => 12000.3

Online help
===========

   To get a short description of a function, you can enter
[1m?functionname[0m, e.g.
     ?const
     => const(name1[:type],name2[:type],...) : create constant objects

   To get a full description use [1m??functionname[0m.

   You can also use [1m??intro[0m as an entrypoint to the complete online
documentation.

To do
*****

   As I said before, this is only an evaluation version, so there are
quiet a lot of things left to do, before I release [3mLAPLACE[0m as
SHAREWARE.  If you have any [3msuggestions[0m, you are invited to send me a
note!!

   Here is a list of some major things:

   * editing is not very comfortable now, improve it (history, block
     editing..)

   * use CGFonts for output

   * function plotting, perhaps internal or external using ARexx (seems
     that Graph2D needs a better ARexx port..)

   * export expressions as TeX,...

   * calculate integrals (do you REALLY believe, I manage this...)

   * the greek font is rendered by IntelliFont and doesn't look very
     pretty (does any have a designed one??)

   * use integers of arbitary length

   * OS independet kernel and different portations

   * rewrite the parser, offering things like [1mprocedures[0m, [1mfor[0m,
     [1mwhile[0m, [1mif[0m statements, enter complex numbers as e.g.
     [1m2i[0m, etc.

   * a whole bunch of small improvementes...

Known bugs
**********

   If you find a bug, not documented feature etc. don't hesitate, TELL
ME.

   Here are those nasty things I know, but didn't manage to remove 'em
(for now):

   * my MUI-CustomClass 'eats' all keyboard input, disabling the tab-key
     and button shortcuts.. Currently there is only a workaround for
     the tab-key, but things are still quite ugly...

   * you get sometimes problems with object names ending with an 'e',
     try [1mm_e+pi[0m (no spaces!!). [1mm_e + pi[0m (with spaces!!) works...

   * I'm using the [1mmathieeedoub*.library[0m for floatpoint processing.
     Seems that it's not too precise; [1m0.4 * 5.0[0m is [1m2 ± 1e-16[0m!!
     When trying to convert floats into fraction, [3mLAPLACE[0m ignore
     differences smaller than 1e-15...

   * Taylor approximation crashes, if you try to evaluate at an [1ma[0m,
     where the function is not defined, e.g. [1mtaylor( (ln(x))(x), 0, 2
     )[0m.

   * Support for complex numbers is not fully implemented. And that's
     what already done is quite crappy ;-) Try something like [1mi^2[0m and
     you see what I mean...

   * ARexx port is currently not working, and the docs for it are
     neither converted to Texinfo nor translated to german.

   * Things like [1mconstant operator set[0m and [1mconstant operator
     equation[0m don't work. This is not a real bug, but a conceptual
     problem of [3mLAPLACE[0m. To change it some internal changes have to
     be done that are not insignificant!

   * It is reported, that the [1mamigaguide.datatype[0m V40 has problems
     with some parts of the AmigaGuide-manual (the german
     [1mAnleitung[0m cannot be loaded).  This doesn't happen with V39.
     Has anyone the same problem and knows the reason and/or a solution?

Competitors
***********

   There are many other math programs for different operating systems,
but I will only look at those available for AMIGA. Well most of them are
quite professional projects, with lots of studied coders and
mathematicians behind, so I cannot compete with them. But just have a
look at them.

MAPLEV
======

   Well, what to say about it? I didn't see the AMIGA version, but I
know the UN*X version, and I think there are not many differences, at
least I think the mathematical functionality is the same.

   MapleV does almost everythink for you, you can think of. Integrals,
differential equations, eigenvectors, function plotting etc. If there
would not be a small problem, I would have never written [3mLAPLACE[0m: the
price. DM1500.- is a lot of money, which I cannot afford. This was
probably the main reason to create [3mLAPLACE[0m. Although there is a
cheaper student version for AMIGA systems, I will continue my work,
'cause it's too much work to be wasted!  If the price is not a problem
for you, don't hesitate to erase [3mLAPLACE[0m from your harddisk.

PARI
====

   PARI is a freeware project of the university of Bordeaux, France. It
lack a graphical user interface, but offers some interesting features.
The biggest advantage is: it's really fast! PARI's best sides are
algebraic calculus, polynomials and power series. On the other side, it
is not able to integrate functions other than polynomials. For
transcendential functions a taylor expansion will be integrated, which
is at least a good approximation, but it just gives up on broken
rational functions. It has a simple function plotter and basic online
help, plus a 500k dvi-manual.

   PARI is available on AMINET, in [1mmisc/math/gpamiga_1_38_3.lha[0m
(binary) and
    [1mmisc/math/pari_1_38_3.lha[0m (source and docs). Other versions are
available at
    [1mmegrez.ceremab.u-bordeaux.fr[0m (147.210.16.17) and
[1mmath.ucla.edu[0m (FTP).  You can contact the authors via e-mail at
[1mpari@ceremab.u-bordeaux.fr[0m.

MuPAD
=====

   MuPAD is also free project of the university of Paderborn, Germany.
The AMIGA version is still an alpha release and lacks a graphical user
interface.  It requires an FPU (which I don't own), so I wasn't able to
test it. There might be an UN*X version that I can test.

   You can find MuPAD at [1mmath-ftp.uni-paderborn.de/pub/MuPAD/[0m (FTP)
and
    [1mhttp://math-www.uni-paderborn.de/MuPAD/[0m (WWW).

Biography
*********

   Not available now...

Index
*****



 MAPLEV                                 Competitors
 PARI                                   Competitors
 About                                  About
 Address                                Address
 binary operators                       Expressions
 Boolean                                Bool
 Bugs                                   KnownBugs
 Competitors                            Competitors
 complex numbers                        Number
 Constants                              Definitions
 Copyright                              Copyright
 Definitions                            Definitions
 Editing                                Editing
 Equation                               Equation
 errordistribution                      Number
 Expression list                        Expressions
 Expressions                            Expressions
 F-keys                                 Menus
 F-keys                                 Presets
 Functions                              Definitions
 General usage                          GeneralUsage
 Getting started                        Getting started
 Greets                                 Greets
 Grek letters                           Definitions
 Installation                           Installation
 Introduction                           Introduction
 Known bugs                             KnownBugs
 Laplace, P. S. Marquis de              Biography
 Libraries                              Libraries
 Matrix                                 Matrix
 Menus                                  Menus
 MuPAD                                  Competitors
 Name conventions                       Definitions
 Number                                 Number
 Objects                                Types
 Online help                            OnlineHelp
 operators                              Expressions
 Options                                Options
 Parameters                             Definitions
 Presets                                Presets
 Project                                Project
 Registration                           Registration
 Requirements                           Requirements
 Set                                    Set
 To do                                  ToDo
 Tooltypes                              Tooltypes
 Types                                  Types
 unary operators                        Expressions
 Usage                                  Usage
 Usage                                  GeneralUsage
 Variables                              Definitions
 Vector                                 Vector

