This document describes DataProc 1.33, an elaborated shareware data processor for any kind of analysis of experimental data. Supports about 100 functions for regression, table management and output formatting.

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

DataProc is a command-driven data processing program, which works much like a tabular calculation program. DataProc reads in a command file holding commands and data and can produce a number of different output files for further processing with other software. DataProc is especially designed to work with GNUPLOT and LaTeX. Both of the latter are available as public domain software on almost any platform.

Beyond the standard mathematics to apply on data several statistic specials like regression and averaging are implemented.

You should pass a filename to DataProc. This file will be read and executed by DataProc. The default extension for this file is '.tst'. So DataProc tries to open <filename.tst>, if <filename> is not available. E.g.:

                 DataProc project.tst
                 DataProc project

are equivalent, unless a file named project exists, which will then be read by the second line. If the file project.tst does not exist an error will be issued.

If you don't pass a commandfilename, DataProc will enter the interactive mode. Anything you enter behind the prompt will be executed just like a commandfile line. As comments don't seem to make sense in interactive mode, any comments will be interpreted as include file names. See include for more information. An example session might be:

                 TeX:physics> DataProc
                 DataProc 1.221 (24.1.93)
                 © 1992 by MGR, Asgard
                 This Amiga copy is registered to Lars Hanke #: 000012

                 1 > *project1
               [messages from execution of project1.tst]
                 2 > *project2
               [messages from execution of project2.tst]
                 3 > #quit

                 TeX:physics>

Poltics
*******

Some words about software in general. Never use original files to run software. Always create copies and run them, because you will never know what might happen to the software.

If you have problems getting started with the evaluation copy, contact me immediately, no matter if you want this program or not. I cannot test the software on a lot of systems with different configurations and it may do really weired things on other systems. If I do not come to know it, this won't change ever and at most leads to a bad reputation of the program.

Distribution
============

In a nutshell, DataProc may be distributed freely as long as the following restrictions are met:

  * The distributor may only charge a fee up to the costs of obtaining a public domain diskette from Fred Fish.

  * The distributor agrees to cease distributing the programs and data involved if requested to do so by the author.

  * The distributor may only distribute an unmodified copy of the original program, with all the supplied documentation and copyright notices intact.

For more details, see the section called License.

Support
=======

If you have any suggestions, bug reports etc., feel free to contact the author of DataProc at the address given in the section Registration. Additionally, you can reach me at:

               Lars Hanke
               FIDO:   2:243/4802.22
               UUCP:   mgr@asgard.bo.open.de

License
=======

 1. This license applies to the product called DataProc, a program available for the Amiga computer and MS-DOS (tm) machines, published by Lars Hanke under the concepts of ShareWare, and the accompanying documentation, example files and anything else that comes with the original distribution. The terms "Programs" and DataProc below, refer to this product. The license is addressed as "you".

 2. You may copy and distribute verbatim copies of the programs' executable code and documentation as you receive it, in any medium, provided that you conspicuously and appropriately publish only the original, unmodified programs, with all copyright notices and disclaimers of warranty intact and including all the accompanying documentation, example files and anything else that came with the original.

 3. You may not copy and/or distribute these programs without the accompanying documentation and other additional files that came with the original. You may not copy and/or distribute modified versions of these programs.

 4. You may not copy, modify, sublicense, distribute or transfer the programs except as expressly provided under this license. Any attempt otherwise to copy, modify, sublicense, distribute or transfer the programs is void, and will automatically terminate your rights to use the programs under this license.

 5. By copying, distributing and/or using the programs you indicate your acceptance of this license to do so, and all its terms and conditions.

 6. Each time you redistribute the programs, the recipient automatically receives a license from the original licensor to copy, distribute and/or use the programs subject to these terms and conditions.  You may not impose any further restrictions on the recipients' exercise of the rights granted herein.

 7. You may not disassemble, decompile, re-source or otherwise reverse engineer the programs.

 8. You may use the programs for a period of up to 40 days for evaluation.  After that, you have to register.

 9. If you wish to incorporate parts of the programs into other programs, write to the author to ask for permission.

 10. You agree to cease distributing the programs and data involved if requested to do so by the author.

 11. You may charge a fee to recover distribution costs. The fee for diskette distribution may not be more than the cost to obtain a public domain diskette from Fred Fish.

Warranty
========

      THERE IS NO WARRANTY FOR THE PROGRAMS, TO THE EXTENT PERMITTED
      BY APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE
      COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAMS "AS
      IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
      INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
      MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE
      ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAMS IS
      WITH YOU.  SHOULD THE PROGRAMS PROVE DEFECTIVE, YOU ASSUME THE
      COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

      IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
      WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
      REDISTRIBUTE THE PROGRAMS AS PERMITTED ABOVE, BE LIABLE TO YOU
      FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
      CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
      THE PROGRAMS (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
      BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
      PARTIES OR A FAILURE OF THE PROGRAMS TO OPERATE WITH ANY OTHER
      PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED
      OF THE POSSIBILITY OF SUCH DAMAGES.

Disclaimer
==========

  * No warranty, either express or implied, is made with respect to the fitness or merchantability of DataProc.

  * Lars Hanke (referred to as the author), reserves the right to not develop any future versions of DataProc.

  * The author will try to make a good faith attempt at correcting any problems if any are discovered, but is in no way required, nor bound to correct them.

  * The author neither assumes nor accepts any responsibility for the use or misuse of these programs. He also will not be held liable for damages or any compensation beyond the original registration fee due to loss of profit or any other damages arising out of the use, or inability to use these programs.

  * Lars Hanke will not be liable for any damage arising from the failure of these programs to perform as described, or any destruction of other programs or data residing on a system attempting to run the programs. This does not depend on my knowledge of damaging errors in the programs.

  * I may change prices and distribution conditions at will, with every new revision of the programs. I cannot be forced to distribute old revisions. Registrations not meeting the current conditions will lead me to inform you of the changes. You may then cancel your registration or meet the new conditions. Note that you have to express any interest in special distribution conditions explicitly, or I will assume that you agree with the current conditions. Lars Hanke is not liable for any costs of monetary transfers and other expenses concerning a cancelled registration.

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

As already mentioned, this program is Shareware. Shareware is neither Public Domain, nor Freeware, nor Giftware, nor Copyleft. If you decide to use this program, you must pay for it! If you don't pay, but use, this is software piracy, with all its legal consequences.

Some reasons to register: First of all, to stay legal, but as nobody cares nowadays, there are some other good reasons. An important reason is the support of the shareware idea. You don't buy shareware blindly, but you may test it thoroughly before. But if nobody pays, it is only a logical consequence that no-one will write shareware anymore and finally you have no chance, but buying software blindly. Finally the support of Shareware programmers will encourage them to care for their programs and you are more likely to get the same support as with commercial software.

Unfortunately, experience tells us that those reasons aren't too convincing for a lot of users. Well, here are some reasons to register DataProc. First of all, the banner message will change from "unregistered" to your name and registration number. Then you will be able to install DataProc anywhere in your path, the evaluation copy may only be started from its very own location's directory. Finally those nerve-racking Shareware posters with its requests for keyboard input during the execution of your commandfile will disappear. The evaluation copy of DataProc is fully operative, but has limitations to the possibilities of automatic execution e.g. during batch jobs and to a proper installation in your system, e.g. paths or packing of the program. Due to a loss of dumb checks whether the copy may be used or not, the registered software improves a great deal in performance, especially the reloading of the own code in bytes will drop.

Remember, a software worth using is a software worth buying. And don't tell me you can't afford DM 25.--, you could still sell your computer! This price is for registration only. The keyfile will be sent via UseNet. If you don't want your keyfile via UseNet or would like an update included add DM 2.-- for European Union countries or DM 5.-- for countries outside the EU, and I will send a disk including your keyfile and the most recent DataProc version. Note: If the service "keyfile via email" becomes too excessive, I may quit that service at will, either mine or the will of my mailservers.

Send your registration (including: Name and address, DataProc version, source you got DataProc from, your system configuration and your EMAIL address) to:

              MGR, Asgard
              Lars Hanke
              Schlachthofstr. 67
              D-44649 Herne

              FIDO: 2:243/4802.22
              UUCP: mgr@asgard.bo.open.de

This is also the adress to send suggestions and bug reports to. For urgent bug reports try:

                    bugs@asgard.bo.open.de

If you intend to install this programm on a multi user system, or are interested in ports to other machines or want to customize it, send me a note. I will gladly cooperate.

Credits
=======

  * Thanks to the developers of GNUPLOT and TeX. The existance of those products was the main influence to start this project. Also the basic layout of the user interface was drawn from there. This does of course in no way apply to any code used for DataProc.

  * Thanks to TrapLand, showing me that SHAREWARE might work even in Europe. I hope you don't mind that I took your legal stuff as the basis of the DataProc license.

  * Thanks to Mr. Teulings, Mr. Preuß for beta testing and Mr. Kulka for alpha testing. Thanks as well to Mr. Böllmann and Mr. Beisemann for lending me their machines for the MS-DOS compilation.

  * Thanks to Mr. Teulings for "WRITE" coping with those goddamned space syntax in the .doc file.

  * Thanks to all those helpful guys round FIDO and UseNet, helping me with coding and porting problems.

  * Thanks to Commodore for producing the Amiga and to SAS for their prompt help and support of their compiler.

  * Finally thanks to me for not needing any sleep at all and to my dog for generously freeing me of that task, sleeping for both of us.

  * Thanks to Odin, the Aesir and the Runes for my name and logo.

Basics
******

Syntax
======

There are some basic rules about the structure of command files. In general empty lines and the number of spaces are ignored. The same is with leading and trailing spaces, tabs or whatsoever. DataProc does not distinguish between different spacing characters.

The characters *, ; and % mark lines as comments. Inline comments are by default introduced by an ;* token. You may change this default using the Configuration facility. Note that in interactive mode the line following the comment sign will be passed as arguments to the include command. The latter does NOT apply to inline comments.

The characters ! and $ will post whatever they are followed in that line on screen during the execution of the commandfile. They should be used to supervise proper operation of a commandfile or for intoductory usage notes for configurable scripts.

A commandline is made up by ASCII characters and ends with the EOL character (usu. $0a). By now you cannot mark a line as a follower.

Commandlines are made up by tokens. Each token is seperated by either a space or :, / or &. While // declares an empty token two spaces do not. (See above). Since Version 1.108 system tokens aren't case sensitive anymore. Strings you define yourself of course won't be translated to a special case.

Tokens may hold seperators, if they are enclosed in grouping characters. These grouping character pairs are: () or [] or '' or "". The grouping pairs may not nest. If an opener (bra) is encountered, the input line will be copied to the token until the corresponding close character (ket) is found.

Commandlines hold either a command or data. The line is interpreted as a command, if it begins with a sharp sign #. In any other case DataProc expects data to be there.

Organization
============

Internally DataProc works much like a spread sheet program. It inits a table of a user defined length and can add an arbitrary number of columns to it. Commands usually affect a whole column. As you might guess the column is the basic unit in DataProc. That is the major difference to a tabular calculator where the cell serves as its unit.

Each column has one physical and two logical numbers. The physical is the basic reference. It is simply the number of the column as it was declared by the columns command.

Beyond that each column may be assigned a specific read column and a write column, meaning the order data is read into them or written from them. For more information see using and ocol.

Mathematics
===========

DataProc supplies a scientific calculator. You may define your own constants, variables and functions. Read the following for its syntax:

Atom
     Atoms are plain Values like 7.65e-12 and constants like PH Functions are treated as atoms as well, but the arguments are itself Expressions

Operator
     The currently supported operators are + - * / ^ with the commonly known meaning. Missing operators like in 3sin(x) or 3 4 are treated as * so that the former expressions would be expanded to 3*sin(x) and 3*4. Operators obey the common priority rules.

Braces
     grouping characters. You may set Expressions into pairs of corresponding braces. All types are treated equally, but must of course match. The brace pairs are: [] {} () Thus (3*[4+5]-2)/6 would work but (3*[4+5)-2]/6 would not!

Expression
     any valid combination of Atoms, Operators and Braces.

            ATOM OPERATOR ATOM
            EXPRESSION OPERATOR EXPRESSION
            ATOM ATOM                      => OPERATOR = '*'
            EXPRESSION EXPRESSION          (dto.)
            ([{ EXPRESSION }])             => treated as ATOM in this level

Name
     Names start with an alphabetic character and may be followed by any combination of alphanumeric characters. The total length must not exceed 29 characters. Names are not case sensitive.

Variable
     NAME followed by OPERATOR or end of line

Function
     NAME followed by an opening brace. In defines this must be an opening parenthesis (. Note that a defined VARIABLE in the combination VARIABLE(... will be correctly interpreted as VARIABLE*(... and a defined FUNCTION in the combination FUNCTION EXPRESSION will lead to the message --> Argument expected. Note also that spaces are ignored, except for separation numbers, so that 3 4 is interpreted as 3*4 and 34 is interpreted as 34.

Define
     := defines or redefines a variable or function. When defining a function the next character must be ( (spaces are ignored)

            VARIABLE:=EXPRESSION                 => define a symbolic variable
            FUNCTION(VARIABLE,...):=EXPRESSION   => define a new function

     Note that the template arguments are not stored to the variable list. If identical entries exist in the variable list they will not be recognized -- the template has higher priority. Note as well that global variables are evaluated immediately, so later changes won't affect the function.

Comments
     The line is terminated by any nonprintable character or a semicolon ;. The rest can be used for comments.

Reserved
     In future versions the following symbols may come to a meaning, so do not put your own stuff on them! The charcters are: ! _ _i _[] |

Symbols
     The following symbols are predefined:

        PI          - you now that number (3.14...), don't you?
        ME          - the Euler number                  (2.718...)
        RT2         - the square root of 2              (1.41...)
        PH          - Planck's quantum                  (6.626...e-34)
        PHB         - Planck's quantum divided by 2*PI
        PE0         - electrical field constant SI      (8.854...e-12)
        PU0         - magnetical filed constant SI      (1.256...e-6)
        PC          - light speed in m/s                (2.997...e8)
        PK          - Boltmann constant                 (1.380...e-23)
        PR          - general gas constant              (8.31441)
        PSIGMA      - Stefan-Boltzmann constant         (5.670...e-8)
        PE          - charge of electron in C           (1.602...e-19)
        PME         - mass of electron in kg            (9.109...e-31)
        PBM         - Bohr's magneton in Am^2           (9.274...e-24)
        PMP         - mass of proton
        PMN         - mass of neutron
        PF          - gravity constant                  (6.672...e-11)
        PG          - standard earth acceleration       (-9.80665)
        PKEL0       - absulute zero temperature         (-273.15)
        PPN         - normal pressure in Pa             (101325)
        PVM0        - ideal gas molaric volume in l     (22.41...)
        PNA         - particles per mol                 (6.022...e23)
        PFARAD      - Faraday constant                  (9.648...e4)
        PRH         - Rydberg constant                  (1.097...e7)
        PLC         - Compton wavelength                (2.426...e-12)
        PSOLAR      - solar constant                    (1.368e6)

        N2KP        - newton to kilopond                (0.102)
        MS2KMH      - m/s to km/h                       (3.6)
        J2MEV       - Joule to MeV                      (6.241e12)
        TORR2P      - Torr to Pascal                    (133)
        U2KG        - u (nuclear mass unit) to kg       (1.660...e-27)
        KG2MEV      - kg to equivalent energy in MeV    (5.609...e29)
        U2MEV       - u to MeV                          (931.433...)
        LY2M        - light years to meters             (9.465...e15)
        AE2M        - astronomic units to meters        (1.495...e11)
        PARSEC      - Parsec to meters                  (3.085...e16)
        IN2CM       - inches to centimeters             (2.54)
        FT2CM       - feet to centimeters               (30.48)
        YD2CM       - yards to centimeters              (91.44)
        MILE2KM     - miles to kilometers               (1.609)
        PS2KW       - german horsepowers to kilowatts   (0.736)
        CAL2J       - calories to Joule                 (4.1868)

        EXA         - scaling syllable                  (1e18)
        PETA        -                                   (1e15)
        TERA        -                                   (1e12)
        GIGA        -                                   (1e9)
        MEGA        -                                   (1e6)
        KILO        -                                   (1e3)
        HEKTO       -                                   (1e2)
        DECA        -                                   (10)
        DECI        -                                   (0.1)
        CENTI       -                                   (1e-2)
        MILLI       -                                   (1e-3)
        MICRO       -                                   (1e-6)
        NANO        -                                   (1e-9)
        PICO        -                                   (1e-12)
        FEMTO       -                                   (1e-15)
        ATTO        -                                   (1e-18)

      Machine identifiers

        AMIGA       : 10 if we're running on Amiga, -10 else
        MSDOS       : dto. for MS-DOS machines

      Arguments of trigonometric functions are expected in radian!

        SIN(x)      - sine function                     sin(x)
        COS(x)      - cosine function                   cos(x)
        TAN(x)      - tangent function                  tan(x)
        COT(x)      - cotangent function                cot(x)
        SEC(x)      - secant function (1/sin)           sec(x)
        SINC(x)     - slit function (sin(x)/x)          sinc(x)
        DSINC(x)    - derivative of the slit function   cos(x)/x-sin(x)/x^2

        ASIN(x)     - arcus sine function               arc sin(x)
        ACOS(x)     - arcus cosine function             arc cos(x)
        ATAN(x)     - arcus tangent function            arc tan(x)
        ACOT(x)     - arcus cotangent function          arc cot(x)
        ASEC(x)     - arcus secant function             arc sec(x)

        SINH(x)     - hyperbolic sine                   sinh(x)
        COSH(x)     - hyperbolic cosine                 cosh(x)
        TANH(x)     - hyperbolic tangent                tanh(x)

        ASINH(x)    - area hyperbolic sine              ar sinh(x)
        ACOSH(x)    - area hyperbolic cosine            ar cosh(x)
        ATANH(x)    - area hyperbolic tangent           ar tanh(x)

        SQR(x)      - square of x -- faster than x^2    x^2
        SQRT(x)     - square root                       x^(.5)
        ROOT(y,x)   - yth root of x                     x^(1/y)

        LN(x)       - natural logarithm                 ln(x)
        LG(x)       - decadic logarithm                 log10(x)
        LOG(y,x)    - logarithm based y                 log_y(x)
        EXP(x)      - xth power of Euler constant       e^x

        FAC(x)      - faculty of int(x)                 x!

        RAD(x)      - convert degree argument to radians
        DEG(x)      - convert radian argument to degrees

        ABS(x)      - absolute value                    |x|
        SGN(x)      - signum function                   sgn(x)

        MAX(x,y)    - returns the greater of x and y
        MIN(x,y)    - returns the smaller of x and y

Concluding Notes: Unlike most math programs the operator '/' is interpretd as a fraction bar, so everything behind it is interpreted as the denomiator unless an addition operator '+' or '-' is encountered. E.g.:

        40/4*5   results in 2
        15/45/9  results in 3
        6/3+2    results in 4 (!)

There is a conceptional bug in the handling of the '-' operator. Do not chain them. Instead write: EXPRESSION - (EXPRESSION + EXPRESSION). Also the monadic '-' does not always work the way it should. (-ATOM) usually does.

In older manuals I stated here that I will rewrite the math module. As nobody seems to have need for it - otherwise please request it - I cancelled this project in favor of other projects and some interface features of DataProc. On the other hand this means that I will try to work around the bugs with the '-' operators.

Commands
********

General
=======

The command is the first token in a commandline. Commands always start with a leading sharp sign #. Commands aren't case sensitive. There must not be any space between the sharp and the command.

As most commands affect one specific column there is a syntax that is common to most commands:

           #command col arg1 ...

where command is the command name and col is the physical column to affect. However, there are some commands that do not affect a specific column or more than one, so col represents zero or more tokens in the general syntax. The same is with the arguments.

Any commandfile must contain the columns command. So read the section concerning that command carefully.

Variables
=========

There are three types of variables maintained by the program that aren't related in any way, may not be mixed up and cannot be processed together in any way. Except for the fourth variable that may be build from two of the latter.

Math Variables
     The most important are the math processor's variables. Beyond what was said in the math processor section, you may use them as data to write to columns and post them on screen, by means of the equally named command. Specifying $= in a Data field makes a maths variable available to the data stream. See the Data section for more information about that. Math variables are not cleared by the reset command.

Global variables
     Global variables -- it's just a name, math variables are of course global as well -- are used to make the commandfile handier and more readable. Global variables may replace any number token of any command, no care if it is a column number, function number, row boundary or whatever. It will be much easier to reference columns and functions by name than to keep track of hundreds of abstract numbers. The mark command even frees you of the task to count data rows for your boundaries. See define, queue, mark and undefine for more information about global variables. Global variables are cleared by the reset command.

Terminal environments
     Terminal environment variables are local variables, meaning that their value is set per terminal. Two different terminals may carry different values in equally name variables. On the other hand they are not cleared by the reset command. They are used to provide the terminal with additional information of how to produce their output. See set, unset, storeset, flushset and the Terminals' chapter for more information about environment variables.

Global Strings
     Since 1.159 global strings are supported. They are useful for two purposes. First of all you can use computation results in terminal environment variables, e.g. to add a fit curve to your data plot in the GNUPLOT terminal. Secondary you can produce a better formatted output on runtime.

Templates
=========

All commands listed in the following paragraphs have a template line. The templates contain several switches; in alphabetical order they read: \a special argument (see text), \b banner line, \c column number, \d may be an undefined variable, \e terminal environment, \f function number, \g group number, \i format identifier, \m maths expression, \n filename, \o may be omitted, \r row index, \s global string, \u must be an UNDEFINED variable, \v any integer value.

Special arguments are format strings (see build) or math definitions (see math and func). Beyond that [item] means that zero or more items may be specified and (item1|item2) means that, if the item cannot be interpreted as an item1, it will be interpreted as item2, and so on.

Note that all values (actually most with 1.28, but this will improve) may also be given by their corresponding variables. Variables are parsed before plain values are accepted.

Configuration
=============

Here is a summary of the configuration setting that is currently supported by DataProc. Note that some of them have global effects and others only affect a group of commands. Configurations are maintained by config and unconfig.

InLine
     Sets the pattern to recognize an inline comment. Note that it must be a parsable token. That means: Comment identifiers MAY NOT contain seperators or grouping characters. See Syntax for details about the reserved characters. This pattern defaults to ;*. Note that inline comments do NOT work with the ! post command group.

           #config InLine @comment
           #post "3*4" @comment Here's the comment

LogComment
     The logfile support commands newlog and applog print a banner message to the logfile, unless disabled by NOLOGMSG. The string given by LOGCOMMENT will be inserted in front of this banner.

           #config LogComment %
           #newlog TeXOut.tex

     will mark the banner line as a comment for TEX and you may thus include the logfile into your TEX document to save retyping the results of your DataProc session.

LogBase
     Sets the base for logarithmic regressions done by logreg. The base of any regression is stored with its results and may be considered by the terminals. LOGBASE defaults to 10 meaning the decadid logarith. Thus DataProc will behave just like previous versions.

NoLogMsg
     The logfile support commands newlog and applog by default print a banner line to the logfile, when opening it. Setting NOLOGMSG disables the banner completely.

Reference
*********

System control

Column maintenance

Output format control

Titles and units

Column generation

Regressions, etc.

Terminal control

Mathematical support

Variable support

Data classes

Logfiles and tags

Flow control and miscellaneous

AddCol
======

            addcol col\c\d type\i

This command adds a new column to an existing table. Normally you should use the columns command for that task, but AddCol might produce more readable code or in some cases may cope with memory problems.

AddCol must be followed by a number token, which is the physical column number to generate. You may pass a name there and it will be assigned the highest column number as a global variable. This is basically the way you should use this function.

The second token must be a format identifier as specified in the columns command.

     Example:

            #addcol LastCol %f
            #row 0
            #using LastCol
            #include "MyData.tst"

This add a column behind all existing columns, reset the row counter and read new data from MyData.tst to that column. LastCol would hold the number of the new column.

See also columns and remcol.

AppLog
======

            applog logfile\n

This command opens a file to store some scratch that you would usually write on some sheet for further evaluation during the formulation of your data analysis. If the file given with the first token already exists, new lines will be appended to it.

Note that this command may be customized with the config settings NOLOGMSG and LOGCOMMENT. See Configuration for detailed information.

See also newlog, logline and logpost.

AReg
====

            areg x\c y\c f\f fa\f fb\f est_a\f est_b\f depth\v\o start\r\o end\r\o

This is the most complex command implemented by now and it will hopefully stay forever. areg enables you to do a least square approximation to any function you like as long as you don't wish to optimize other than two parameters. Note that for standard situations e.g. linear or logarithmic regressions special commands are implemented so that you won't need this command too often. See lreg and logreg for more information about that.

The syntax is long but logical. The tokens are in sequence: x-column, y-column, function to match, partial derivation of the function according to the first parameter (a), partial derivation of the function according to the second parameter (b), estimation for a and estimation for b. While all of the latter tokens oblige the following may be omitted: iteration depth, start row and finally end row.

The columns are indicated by their physical column number. The functions are indicated by their number as assigned by the func command. For both groups of numbers as well as for the start and end row, you may of course use global variables. The functions are expected to take the parameters:

              y=f(a,b,x)

in exactly that sequence. Take care that you only pass 3 parametred functions matching the above convention.

The token contents for the estimation values are passed to the maths processor, so you may use its math variables or even mathematical expressions for the estimation values. Note that areg is usually rapidly convergent, but false estimations my even crash the iteration.

If you pass zero to iteration depth or you omitted that token, areg will work interactively. Thus it will stop after every iteration and show where you are. If you're satisfied with the result, you leave the iteration pressing the Q key. Any other key will compute the next step.

Finally you may specify the first and last row of data to include in the regression. Row numbers start with 1 and both rows given as boundaries will be included. If you specify zero or leave the token empty the maximum value will be set, meaning the first row as start or the last row as end.

The regression results are printed on screen during execution of the commandfile and are stored to the math variables DPA holding the first parameter result, DPB the second and DPSA and DPSB the corresponding absolute errors.

See also lreg, logreg and func.

Ask
===

            ask ( string\s | question\b\o )

Works just like if but the condition is given online by the user. The rest of the line is promted to the screen and the user is asked to enter Y or J for a true condition or N for a false condition. The command must further be handeled by else and endif.

Instead of a plain text question the first token is checked against the global string list. If found, the global string will be placed instead of the line contents.

Note that setting a batch level higher or equal to 10 will always answer this command with N.

     Example:

            #ask Shall I do it?
            ! I did it!
            #else
            ! why not?
            #endif

will print on screen Shall I do it? (Y/J,N) >  If you type N, it will post why not? or if you type Y or J, it will post I did it!

See also if, else, endif, readvar, stop and batch.

Average
=======

            average col\c weight\c\o start\r\o end\r\o

Followed by the column to average, an optional weight column that may be left empty and the start and ending row, which as well may be left empty or set zero.

If a weight is specified DataProc computes the average to the weight given in the designated column.

If the startrow token is empty or zero the first row is defaulted. The analogon is an empty or zero token for endrow that is interpreted as the last row currently read.

The results of the average computation is posted on screen during the execution of the commandfile. The results are also stored to global variables that may be accessed by the maths processor. DPMX holds the computed mean and DPSMX its absolute error. DPMSX holds the average absolute error (standard deviation). Those can be further processed using math, post and generate.

     Example:
              #average 3
              ! The average peripherial length is
              #post dpmx*pi

computes the unweighted average of all entries in column 3. If we assume that column 3 holds the results of several attempts to measure the diameter of a circle, it finally posts the average length of the peripherial on screen.

See also mean, math, generate, post and lreg.

Batch
=====

            batch level\v

This command sets a so called batch level. The next token must be a number token, which is set as batch level. Default is batchlevel 0. Any nonzero level will ignore all stop commands. A level higher or equal to 10 will answer any ask command with N.

See also ask and stop.

Build
=====

            build string\s\d format\a [arguments according to identifiers]

This command is used to assemble global string Variables. It acts much like typical print commands in many programming languages. The arguments in sequence are: variable name, format string, arguments. Note that the argument line is parsed as tokens, thus you will usually have to quote the format string or mathematical expressions.

The format string may contain %d (%ld) what believes the corresponding argument to be a global variable, %f (%lf) is replaced by the result of the given mathematical expression, %s what denotes a pure string or a global string variable and finally %% producing the percent itself. %f (%lf) may be followed by a single digit denoting the number of significant cyphers just like the prec command. The precision defaults to 7.

     Example:
              #build mystr "The mean pressure is: %f +/- %f hPa" DPMX DPSMX
              #post mystr

This makes your script's runtime output a little more readable.

CBuild
======

            cbuild expression\m string\s\d format\a [arguments]

This command works exactly as build, but requires one argument more which is prepended. The build is only performed, if the expression is valid and evaluates to zero.

     Example:
              #cbuild sgn(profit)+1 message "You lost %f4 Dollars" abs(profit)
              #cbuild sgn(profit)   message "You'd better stayed in bed - all for naught"
              #cbuild sgn(profit)-1 message "Hurra! You gained %f4 Dollars" profit
              #post message

See also build.

Choice
======

            choice value\m [choices\m]

Works much like if, but compares value agains an arbitrary lengthed list of expressions given in choices. If any of those values is equal to the given value the command is evaluated as true and proceeds. If no value matches, the current condition is set to false and all lines up to else or endif are ignored.

     Example:
              #choice Language phoneUSA phoneGB phoneSA
              ! We're speaking English
              #endif
              #choice Language phoneD phoneAU phoneCH
              ! Heute mal deutsch
              #endif

See also if, else and endif.

CPut
====

            cput expression\m string\b\o

This function evaluates the given expression and displays the string if the expression is evaluated to zero. Note that this is quite the contrary behaviour to if. This is a conditional ! command. Note that it is not a conditional post!

     Example:
              #cput Language-49 Bundesrepublik Deutschland

Will print "Bundesrepublik Deutschland" on screen, if "Language" contains the international phone number 49.

See also if and post

CloseLog
========

            closelog

Closes a note sheet file that has been opened by newlog or applog. Usually you won't need this command, because DataProc closes all files when closing down. Anyhow, if you like to print out your logfile during execution, you must close it, before another application may open it for further processing.

     Example:
           #applog "mylog.log"
           ; do something
           #closelog
           #dos type mylog.log

Will print out the log file mylog.log that had been generated or modified in the same commandfile.

See also closetag, newlog and applog.

CloseTag
========

            closetag

Closes a tag database file that has been opened by tagfile. Usually you won't need this command as DataProc closes all files when closing down. Anyhow, if you want other applications to work with it, before your commandfile ends, you may make it accessible by this command. See closelog for a typical application.

See also tagfile and closelog.

Columns
=======

            columns count\v\o [type\i]

The first token is expected to hold the number of columns for the table to hold. Since version 1.204 this token is optional and may be omitted. If you supply a number of columns it will be used. Note that any format identifier beyond that mark will be ignored and if you supply less identifiers this will cause an error.

The next tokens hold format descriptors for the relating column. They are just like the printf() C type format descriptors.

%f
     float number

%lf
     float number (synonym to %f)

%d
     integer number

%s
     character string

The sequence the columns are declared in makes their physical column number. E.g.:

          #columns 3 %d %f %s

would allocate space for three columns and declare the physical column number 1 to hold integer numbers, physical column 2 to hold floats and physical column 3 to hold strings.

In addition the logical read and write numbers of the columns are inited to the physical column number.

See also dsize and reset.

Config
======

            set configuration\e contents\b\o

Since 1.300 DataProc supports global environments that make several commands behave differently according to the environments set. Refer to the specific command to see how it supports such environments.

     Example:
             #config logbase me

sets the logbase configuration to me. The logreg command will read this configuration, evaluate it through the math processor and use the the natural logarithm instead of the decadic.

See also unconfig and set.

Contract
========

            contract col\c start\r end\r step\v func\f [argcol\c]

This command is quite similar to generate. But unlike generate it produces a new column by processing entries of the same column. It could be used to compute the deltas between to entries, but that is already done by delta.

The first token holds the column to generate. Then the start and end row follow. Empty tokens there or zeroes are interpreted as boundary values, meaning first or last row. The next token holds the stepwidth, meaning the distance between two rows to process together. So if you have a data stream holding the occurences of maxima and minima, a stepwidth of 2 would serve to compute the e.g. deltas between maxima and minima without mixing them up. The next token holds the function number to use for processing. The following tokens build a column list, so you can use the information of more than one column.

The function arguments are passed in the following manner: Current row of the first column in the list, current row plus stepwidth of the first column in the list, current row of the second column in the list and so on.

The destination is written to the destination column at current row plus stepwidth. The first stepwidth rows in the destination are thusly marked void.

The row boundaries refer to the current row. Each row between the first and last minus stepwidth may become current row, if you select that range.

     Example:
             #func 1 f(u1,u2,i1,i2):=(u2-u1)*(i2-i1)
             #contract 5 0 0 2 1 3 4

Writes the product of the differences of odd and even row pairs in columns 3 and 4 to column 5. As the whole range is selected any possible pair in forward sequence will be processed. The first two entries in column 5 will be marked void.

See also func, generate and delta.

Count
=====

            count col\c func\f\o

Fills a column with the current row number. An optional function as defined by a func command may follow. In the latter case the column will hold the results of the given function, which is passed the row number as its argument.

     Example:
             #func 1 f(x):=10x+3

             #count 1
             #count 2 1

The first command stores the row number to column 1. The second stores the row number multiplied by 10 incremented 3 to column 2.

See also func, make and scale.

Define
======

            define var\u val\v

Defines a global variable. Global variables may replace any token that expects numbers. No matter if it be column numbers, function numbers, row boundaries, etc. They however aren't related in any way to the math processor's variables and thus cannot be used in mathematical contexts.

The syntax is variable name followed by value.

     Example:
             #define MyVar 6

MyVar may now replace any number token with the value 6.

     For instance:
             #lreg 1 2 3 myvar

would do a linear regression of column 2 to 1 weighted by 3, beginning with row myvar -- which we defined to be 6. As you probably guess from that, global variables -- being system tokens -- are not case sensitive.

See also undefine, queue and mark.

Delta
=====

            delta col\c sorce\c "-"\o start\r\o end\r\o

Works similar to contract with the function f(x,y):=y-x as the inbuilt, eternal and unchangeable default. Thus the function token is missing.

The first token holds the column to generate. The next token holds the column to take the data from. If the next token holds a - sign, the function result is negated, resulting in f(x,y):=x-y. If this token does not hold a - it is directly interpreted as the next one, which holds the start row and the next the end row. As usual empty or zero tokens mean boundary values that is first or last row. The first entry in the destination column is marked void.

If source and destination columns have an error column assigned, errors are generated automatically with the function s(sx,sy):=sqrt(sx^2+sy^2).

See also contract and errlist.

Diff
====

            diff col\c weight\c\o

Computes the average difference of the entries in a column in a better and faster way then a combined delta and average. It uses the so called FAR DIFFERENCES METHOD which produces much better results than the above, if you have more than 6 items. The item count however must be even or the last item will be ignored.

The first token holds the column to process and the second may optionally hold a weight column. By now the latter is simply averaged to compute a mean error, which is in turn stored to DPSMX. The mean itself is posted on screen and of course stored to the global maths variable DPMX.

     Example:
             #diff 3
             ! Wavelength
             #post 2DPMX

Suppose column 3 holds the coordinates where zero amplitudes of a standing wave have been encountered. diff computes the average difference between those coordinates that is half the wavelength. The post command doubles it and puts the result on screen.

See also average, delta and post.

Digital
=======

            digital col\c prec\v

Sets the PRECISION fixed to the decimal point for the column. The argument is the decadic exponent of the last significant cypher.

     Example:
             #digital 2 -2
             #digital 3  1

will cause the number 123.456 to appear as 123.46 in column 2 and as 120 in column 3.

Beyond that a minimum error is computed for that column which is used in averaging, etc. when no error column is specified to avoid meaningless results.

See also prec and average.

DigList
=======

            diglist prec\v [col\c]

Assignes the digital fixpoint precision given with the first token to all columns that appear in the column list. The meaning of that precision is identical to digital.

See also digital and preclist.

DOS
===

            dos command\a

This command passes whatever it is followed by to the operating system's command processor.

     Example:
           #term gnuplot
           #write "MyPlot.dta" "MyPlot.gnu"
           #dos gnuplot MyPlot.gnu

will imediately plot your results.

DSize
=====

            dsize size\v

Sets the maximum number of rows that all columns of the table may hold. This command should preceed the columns command.

If no dsize command preceeds the columns command, columns will default the table size to 10 rows. If a table exceeds the given size, DataProc will try to enlarge it, by either doubling the current size or adding 100 rows, whatever is smaller. Note that this might cause memory fragmentation and takes some time, if you have a lot of columns. So if you encouter memory problems, try to specify a tight -- but sufficient -- dsize.

dsize may now appear anywhere in the commandfile. Note that in previous releases this might have caused severe crashes. Anyhow, you cannot shrink tables. If you specify a size smaller than the current size, dsize will be ignored. If you want to save memory during runtime shrinking a table, you must reset.

     Example:
             #dsize 40

Sets the maximum number of rows in the data file to 40.

See also columns and reset.

Else
====

            else

Will switch to the other condition of an if statement. If the last if already encountered an else, it will cancel this if and else refers to the previous nesting level.

See also if, endif and ask.

EndIf
=====

            endif

Cancelles an if nesting level and returns to non conditional execution.

See also if and else.

EndRun
======

            endrun

Deletes any make command from the whole table, just as you would undo any automatically generated column during rereads - maybe in different columns - of the same rows. Otherwise MAKE would again recompute the results of already done columns during rereads.

See also make, row and undo.

ErrList
=======

            errlist [col\c errcol\c]

Assignes error columns to columns. The syntax is an arbitrary lengthened list of column, error column pairs in sequence.

See also remerr, delta, mean and LaTeX.

Estimate
========

            estimate ( 0 | read_col\c )

Works similar to slip but marks the result as an estimation rather than a misresult. If you pass 0 for the column token, all read columns will be marked as estimations. This is especially useful, if your results are such bad that any regression fails, due to a lack of support points, or if you have cumulating errors and a misresult in the first table, destroys the whole experiment.

See also slip.

Exit
====

            exit

Causes DataProc to terminate immediately. Any further data either in the current or the parental file or files will be ignored.

See also quit.

FlushSet
========

            flushset

Annihilates all assignments to terminal environment variables done by storeset at one time.

     Example:
           ; adapt to german language and EEPIC output
           #include deutEEP
           ; do something
           ; prepare output for a doubly logarithmic regression
           #term latex
           #storeset aID Exponent
           ; produce some output
           ; and return to the "deutEEP" settings
           #flushset

See also storeset, set and reset.

FlushVar
========

            flushvar

This function clears all global constants. I'm not sure, if you might have need for it, because reset does this as well, but if you should, here it is.

See also reset.

For
===

            for variable\d start\v\o end\v\o stepwidth\v\o

This is a keyword for loop constructions. It acts much like the BASIC language FOR scheme. Any expression enclosed between for and next will be repeated, while the variable beginning with start is increased by stepwidth by every passing of next, until the variable exceeds end. Note some special features, the DataProc for loop is autosensitive to backward or forward counting in dependence of stepwidth; the default stepwidth is +1; the loop end condition is checked with next thus all commands in a for loop will be executed at least once. Finally note that for and its corresponding next must be part of the same commandfile, but you may of course use input commands inside a for loop. But make sure that you never call for and next in different input files.

     Example:
           #for j 17 10 -2
           #build out "loop variable: %d" j
           #post out
           #next

     will result in a screen output

           loop variable: 17
           loop variable: 15
           loop variable: 13
           loop variable: 11

     and

           #for j 17 10 2
           #build out "loop variable: %d" j
           #post out
           #next

     leads to

           loop variable: 17

See also next.

Func
====

            func function\f\d expression\m

The next token numbers a function that is explained in the rest of the line to the maths processor. By this number make, count and scale reference their functions. Note that since 1.231 you may place an undefined global variable instead of a defined number token. DataProc will seek for an empty slot and define the global with the number it assigned the function.

The name of the arguments are arbitrary, but the sequence left to right corresponds to the left to right sequence how make passes the cell values of its designated argument columns.

     Example:
             #func 4 c(a,b):=a/b
             #func 5 errc(a,b,sa,sb,c):=c*sqrt((sa/a)^2+(sb/b)^2)

Computes a value c as the quotient of a and b and its error by the Gauss error propagation for potency expressions. The make command my look as follows:

             #make 5 4 1 3
             #make 6 5 1 2 3 4 5

This would expect a to be in column 1, its error in 2, b in 3, its error in 4 and would generate the quotient c to column 5 and its error to 6.

See also make, count, scale, generate and math.

Generate
========

            generate col\c start\r end\r func\f [argcol\c]

This command is similar to make. The difference is that it does not execute during the data read, but it does generate a new column immediately from the already read table.

The syntax differs a little from make. The first token holds the column number to generate. The next two tokens hold the start and end row to process. Empty tokens or zeroes are interpreted as boundary values, meaning first and last row. The next token holds the function number. The value -1 calls the inbuilt function that results with the row number. The following tokens are just as make the function arguments.

     Example:
             well we read some data to column 1 and 2 ...

             #lreg 1 2
             #func 1 delta(x,y):=abs(y-DPA*x-DPB)
             #generate 3 0 0 8 1 2

Column 3 will then hold the absolute difference to the mean straight line.

See also make, columns and func.

GlobTitle
=========

            globtitle title\s

globtitle sets a global title to the whole table. The next token is interpreted as a string which is used to name the table. See the Terminals chapter for more information about titles.

See also title.

Group
=====

            group group\g\d [col\c]

The first token is expected to hold a group number. If the group number is new, a new group is allocated. The following tokens hold a list of columns to add to the group. You cannot shrink a group by now.

Since 1.273 the group number token may be an undefined global constant. Group will then allocate a new group and assign it the next free number and store the latter to the given constant.

Grouping is mainly a formatting advise for the Terminals' drivers. Table drivers for instance should equip groups with a common title as specified by the name command.

     Example:
             #group 1 5 6
             #group 1 7
             #group 1 6

The first command allocates the group 1 and specifies the columns 5 and 6 as its members. The second command adds column 7 to the same group that now holds the columns 5, 6 and 7. As column 6 is already in the group the third command is ignored.

See also globtitle, title and name.

GTitle
======

            gtitle col\c title\s

Sets a secondary title to a column. Works just as title, but the argument string is stored to a different place. This title should be used to e.g. name the points in a plot. See the Terminals section for more information about titles.

     Example:
             #gtitle 2 "Counter rates"

Sets the gtitle to Counter rates. The GNUPLOT terminal will thus name the data plot Counter rates.

See also title and rtitle.

If
==

            if expression\m

Initiates a conditional block of statements. The rest of the line is passed to the maths processor and the result is checked. Any value greater than zero denotes TRUE, zero or less FALSE. Any undefined math expression will issue a warning and proceed with FALSE.

If FALSE, control will not execute any command until else or endif is encountered.

If TRUE, control will continue execution until else is encountered. In that case the block will be skipped until endif appeares. else is of course NOT obligatory.

See also else, endif and ask.

Include
=======

            include file\n\s

The following token is the filename to include. If the file does not open, DataProc retries filename.tst and if that fails, too, it issues a File does not exits error. The include file is expected to be a commandfile, just like the one calling for include. This is especially handy, if you e.g. create your data automatically and have to process them just the same every time. So you would write a commandfile inputting theese data. Another extremely practical usage is to create a datafile by the current script and reread the preprocessed data after resetting the table to the same script. Well, possibilities seem infinite.

Whatever is in the file is handeled as if it were part of the original file. You may nest include as deep you will. As the algorithm is recursive you may be well advised to increase stack for extremely deep include nests. On other machines like MS-DOS you might have to increase the FILES entry in your config.sys, but DataProc's concept has no problem with deep nesting.

You should however ensure, that you do not create include loops, meaning a subfile including one of its parentals. DataProc doesn't check that and will crash sooner or later, because of stack leakage or other system odds. Depending on the runtime system of the compiler it might even leave files open, what may have severe consequences to your filesystem. On some systems the medium will become unreadable and will have to be reformatted!!!

Input
=====

            input file\n\s

This is a contribution to all TeX freaks constantly typing input instead of include. Both commands are absolutely synonymous.

Inter
=====

            inter var\m\d x\m x1\m y1\m (x0\m y0\m)\o

This command does an online linear interpolation. The syntax is math variable name to store the result to, maths expression holding the x value to compute the result for, maths expression holding the x value of the first coordinate, dto. y coordinate and then the same for the second point. The second point's coordinates may be omitted and the origin will then be assumed to be the second point.

     Example:
            #inter y 4 "2^3" 5
            #post y

Will post the value 2.5 on screen.

Leave
=====

            leave ( 0 | read_col\c)

Works similar to slip but marks the column to permanently hold misresults until a take command disables leave. This command is used to exclude groups of results from a regression, e.g. a non linear area.

The argument token holds the column number to mark as misresults. If the column number zero is specified leave marks all read columns as misresults. Note the the column number refers to the logical read column as assigned by using.

Anything that is gained by further processes of a marked entry (e.g. by make or generate is also marked.

See also make, using, columns, slip and take.

LogLine
=======

            logline text\b

Whatever follows the command will be written to the current logfile. If no logfile is opened, the command will be ignored.

     Example:
           #newlog "Important.log"
           #logline Now comes the most important thing ever!

Will open a new file called Important.log overwriting existing an existing file and write Now comes the most important thing ever! to it.

See also applog, logpost and newlog.

LogPost
=======

            logpost ( string\s | expression\m )

Works exactly like post, but redirects its output to the current logfile. If you did not open any logfile, the command is ignored.

See also applog, logline, newlog and post.

LogReg
======

            logreg mode\v x\c y\c weight\c\o start\r\o end\r\o

Works just like lreg, but the first token is interpreted as a regression mode. Specifying zero makes this command equivalent to lreg. One causes logarithmic scaling on the x-axis, two on the y-axis and 3 on both.

This command uses the logarithm given by the Configuration LOGREG. The results that are posted to the terminal and set to DPA, DPB, DPSA, DPSB and DPR are the parameters of the straight line. It is the user's task and the task of the Terminals' drivers to interpret theese results correctly.

Note that there are two special cases. Natural logarithms are represented by ln and decadic logarithms by lg, any other logarithm is represented by log and a note, telling the base used. Further note that DataProc assumes the respective special case whenever the logbase comes closer than 1e-7 to one of the special bases. Note also that the LOGBASE defaults to 10.

For more information see lreg.

LReg
====

            lreg x\c y\c weight\c\o start\r\o end\r\o

Starts a linear regression. The arguments are: x-column, y-column, y-weight, startrow and endrow. Only the first two cannot be omitted. An empty or zero startrow or endrow sets this value to firstrow or lastrow.

If a weight column is specified a weighted regression will be done. If not, well DataProc does a simple regression.

The regression results are hooked to the y-column. Output terminals may care to output them when outputting the y-column. See the Terminals chapter for more information.

Beyond that the variable DPA, DPB, DPSA, DPSB and DPR of the math processor are set to the regression results. Where DPA holds ascend of the regression straight line, DPSA its error, DPB the y-offset and DPSB the error of the latter and DPR the correlation ratio.

Regression results are monitored to stdout (usually the screen) during execution of the commandfile.

     Example:
             #lreg 1 3//8 0

Does an unweighted linear regression of column 3 against column 1 beginning with row number 8.

See also logreg, areg, average, math and post.

Make
====

            make col\c func\f [arg\c]

This command specifies a function to generate an entry in a column from a number of  entries in other columns. All entries belong to the same row. Note that make won't overwrite valid data. If you want it to, use void to mark it invalid.

The first token designates the column to generate, the second the function number to use (see func for more info) and the following tokens are the column numbers which the function arguments are to be taken from.

     Example:
             #make 3 1 4 5

generates the entries of column 3 using the function 1 passing it the contents of columns 4 and 5 as arguments each row. The whole thing might look as follows:

             #func 1 f(x,y):=x+y
             #using 4 5
             #make 3 1 4 5

would read the data in the file to columns 4 and 5 and would store their sum in column 3.

The sequence of the make commands is irrelevant. Before execution they are sorted as necessary that all columns hold valid data before being passed as arguments. An error will be issued, if that is not possible.

See also func, count, generate, scale, undo, endrun and void.

Mark
====

            mark variable\v\u

This command is used to define a global variable to the current row number. It is helpful to make row boundaries easier -- you don't have to count anymore -- and more transparent. The only argument is the name of the variable to define. Note that you cannot redefine variables. Use undefine to free them first.

     Example:
             some data here ...

             #mark RegStart

             some data there ...

             #mark RegEnd

             and there may be still some ...

             #lreg 1 2//RegStart RegEnd

This would cause lreg to do an unweighted regression of column 2 to 1 beginning with the data set following the #mark RegStart and ending with the data set following #mark RegEnd -- both inclusive.

See also define, undefine and queue.

Math
====

            math expression\m

Whatever follows this command is directly passed to the maths processor. You will usually use it to compute results from regression data and use them as constants in new functions or post them on screen.

     Example:
             #title 1 diameter
             #unit 1 cm
             #digital 1 -2
             #using 1

             then some data follows

             #average 1

             #math l:=mx*pi
             #math sl:=smx*pi

             ! The average length of the peripherial is
             #post l
             ! with an average error of
             #post sl

Well, that speaks for itself, doesn't it?

See also func and post.

Mean
====

            mean col\c [source\c]

Works similar to make, but you cannot choose an arbitrary function. As with make the first token holds the destination column. The next tokens hold a list of source columns. The entries of the destination columns are filled with the mean of the source columns during the data reading procedure.

You can reference the error of the mean using the smean command, or you may specify an error column using errlist.

     Example:
             #mean 6 1 2 3 4 5
             #smean 7 6

Stores the mean of columns 1 thru 5 to column 6 and the error of the mean to column 7.

See also smean, make and average.

MeanOf
======

            meanof mean\m\d error\m\d [value\m]

In many cases you need the average of a well defined set of values for further computation. meanof frees you of the task of typing it as two math lines. The syntax is pretty simple. The first token holds the name to store the average to, the second the name of its error, then a list of maths expressions must follow. Note that you must at least supply two expression tokens. Beyond that the total number is arbitrary.

     Example:
           #meanof mr smr r1 "2*r2" 123

Will compute the average of r1, (2*r2) and 123 and store it to mr. The average spot check error.

See also mean and wmeanof.

Merge
=====

            merge col\c [merges\c]

Adds up to 20 columns to a data column for output purposes. This is used to plot more than one column's data in a single diagram by means of the GNUPLOT terminal driver. See the Terminals chapter for more information of how the terminals handle merges.

     Example:
             #merge 2 5 6 7

             well, there might be anything

             #term gnuplot
             #ocol 1 2
             #write "data.dta" "data.gnu"

This will produce a graph showing the behaviour of the y-data in coloumns 2 5 6 and 7 to the x-data in column 1. Without the merge command only the data in column 2 would be taken.

See also ocol and write.

Name
====

            name group\g title\s

This command sets a title common to a group. If you are measuring for example a set of parameters of a gas at different pressures, you would put all measuring series to a common pressure into a group and name it according to the pressure used.

The first token holds the group number as specified by a group command. The second token holds the title for the group.

     Example:
             #group 1 1 2 3
             #group 2 4 5 6
             #group 3 7 8 9
             #name 1 "700 mbar"
             #name 2 "800 mbar"
             #name 3 "900 mbar"

See also group, globtitle and title.

NewLog
======

            newlog file\n

This command opens a file to store some scratch that you would usually write on some sheet for further evaluation during the formulation of your data analysis. If the file given with the first token already exists, it will be overwritten.

Note that this command may be customized with the config settings NOLOGMSG and LOGCOMMENT. See Configuration for detailed information.

See also applog, logline and logpost.

Next
====

            next variable\d\o

This command terminates a prior defined for loop. If you specify the keyword #all for the variable name, all for loops defined in the current commandfile will end here. If you specify a certain variable, next will terminate all for loops defined in the current commandfile until the given variable name is met. It will also terminate the given variable. This is mainly for debugging purposes. If no name is given, next terminates the innermost loop, if there are any nestings.

See also for.

NOP
===

            nop

No operation. This command does absolutely nothing and is only a kludge for debugging purposes.

OCol
====

            ocol [col\c]

This command is followed by a list of physical column numbers. The terminal output is generated from that list in the given sequence. It also assigns the logical write numbers of the columns. It is the pendant to using doing the same for data input.

     Example:
             #term gnuplot
             #ocol 2 9 7
             #write "data.dta" "data.gnu"

This will output in sequence the columns 2, 9 and 7 to data.dta. The GNUPLOT terminal will interpret that as x-data, y-data and y-errors and will thus output the corresponding command sequence to data.gnu.

See also term, write and using.

Post
====

            post ( string\s | expression\m )

Whatever stands behind post is passed to the maths processor, unless the first token is found as a global string as defined in build. The result is then printed on screen during execution of the commandfile.

See math for an example. See also build, func, lreg and average.

Preamble
========

            preamble term_cmd\b

The string following this command is set in front of any terminal output via write. Internally the string is passed to an fprintf() function, so mind the C type character specials. If the first token is found to be a global string as defined by build its contents are used to fill the preamble.

     Example:
             #term gnuplot
             #preamble 'set terminal eepic; set size 1,1.5; set output "data.gph"'

These commands select the GNUPLOT driver as output terminal and the preamble in turn inits GnuPlot to output an EEPIC data file to data.gph in my preferred size.

See also term, write and unamble.

Prec
====

            prec ( 0 | col\c ) prec\v

Sets the precision for one column or defaults it for all columns if the column number 0 is passed. If the column number is set to -1 (by now any negative value, but do not rely on it) prec affects all error columns as assigned by errlist. Precision means the number of significant cyphers to display. It does NOT affect the internal computations.

     Example:
             #prec 0 4
             #prec 1 5

will at first default the precision to 4 significant cyphers for all columns and then define the higher precision 5 for column 1. Thus:

       3.0145   will result 3.0145 and in column 1: 3.0145
       3.01458  will result 3.0146 and in column 1: 3.01458  (last digit rounded)
       0.0003   will result 300e-6 and in column 1: 0.0003   (exponents are
                                                              multiples of 3)
       etc.

See also digital, preclist and errlist.

PrecList
========

            preclist prec\v [col\c]

Works similar to prec but saves some typing. You specify a certain precision that is common to several columns and then denote all columns in the following list that should hold that precision.

See also prec and diglist.

Queue
=====

            queue offset\v\o [var\v\u]

Defines a chain of global variables, meaning a number of those with following numbers. This is especially useful, if you want to name the coloumns of your table. The first entry is expected to hold the value of the first global variable in the list. If the first token holds an undefined variable already, this value defaults to 1. This may of course also be a global variable. The following tokens hold an arbitrary list of global variables to define. Note that you cannot redefine variables, use undefine to free them first.

     Example:
             #queue 3 myvar1 myvar2 myvar3

would set myvar1 to 3, myvar2 to 4 and myvar3 to 5.

See also define, undefine and mark.

Quit
====

            quit

Causes DataProc to terminate the current file. In the main commandfile this will terminate execution -- just like exit. In children files this will return control to the parent.

See also exit and include.

Read
====

Well, for all practical purposes this command became meaningless. You shoul not use it. It redefines the format of logical read columns. The syntax is just like the columns command, but the identifiers refer to the logical read columns and not to physical columns.

See also using and columns.

ReadString
==========

            readstring var\m\s text\b

This command enables you to define global strings during runtime. The first token holds the strings' name, the rest of the line is posted to the screen and a prompt is added. Execution waits for a string to be entered and will assign it to the named global string.

            #readstring gppath Where did you install GNUPLOT
            #build gnucom "%s\GNUPLOT MyGnu.gnu" gppath
            #dos gnucom

The example is useful if your port does not support paths. It will invoke GNUPLOT from the given path and let it work on MyGnu.gnu on an MS-DOS machine.

See also readvar and build.

ReadVar
=======

            readvar var\m\d text\b

This command enables you to define math variables during runtime. The first token holds the variable name, the rest of the line is posted to the screen and a prompt is added. Execution waits for a float number to be entered and will assign its value to the given variable.

See also readstring, ask and stop.

RemCol
======

            remcol col\c

Removes a column from the current table. remcol must be followed by a physical column number. I am not sure, if it is always save to use that function, but if you are in trouble with memory space, you might welcome this function. Anyhow, if you find crashes that may be caused by remcol report them and I will see what I can do.

See also addcol and columns.

RemErr
======

            remerr [master\c]

Removes error columns from columns. The syntax is a simple list of columns you want the error columns detached from.

See also errlist.

Reset
=====

            reset

Starts a new table and thus forgets all columns, regressions, etc. that have been done previously. The math processor is however not affected by reset and thus all variables, constants and functions are still available.

reset attempts to free all the memory allocated by table private structures. I am not sure if it is always succesful in freeing everything. So if you should have memory troubles a reorganization of the commandfile may take you out of there.

After processing reset the declarations for dsize and columns must be newly set, because the previous are forgotten and deallocated. Global variables are also forgotten. Terminal environment variables however are not affected by reset.

See also dsize, define, set and columns.

Row
===

            row counter\r

Sets the row counter to the specified value. This is useful especially to read data for different columns from different files as well as to partially replace data in an already made table. Be careful using this command, you can easily produce WHITE SPOTS in your table. The command only checks that you do not exceed the maximum size as defined by the dsize command.

     Example:
           #using 1
           #include "Col1.dta"
           #row 0
           #using 2
           #include "Col2.dta"

This would read column one from Col1.dta and later read the same rows but in column two from Col2.dta.

See also using, include and void.

RTitle
======

            rtitle col\c title\s

Sets a secondary title to a column. Works just as title, but the argument string is stored to a different place. This title should be used to e.g. name the regression graph in a plot. See the Terminals' chapter for more information about titles.

See also title, gtitle and runit.

RUnit
=====

            runit col\c unit\s

Sets a secondary unit to a column. Works just as unit, but the argument string is stored to a different place. This title should be used for hybrid units like in regressions. If no runit is specified, the Terminals should care to create their own hybrids.

See also unit, runit, gtitle and title.

Scale
=====

            scale col\c func\f

Sets a function to scale data before storing it to the table. The function must expect one argument of course. scale expects the physical column number.

     Example:
             #func 1 f(x):=x/milli
             #scale 2 1

For example the data unit of column 2 may be meters, but you measured millimeters and thus copied them to the data section. The scale command will care for that problem and divide all values by milli.

Set
===

            set environment\e contents\b\o

Sets a terminal environment variable. Please refer to the Terminals chapter for the meaning of such variables to the terminals. The first token is expected to be the variable name and whatever follows will be stripped of leading and trailing spaces and set to the variable value, unless the first token is identified as a global string as defined by build what sets its contents.

The variable is -- just as the preamble -- hooked on the terminal. It will not be affected by reset and each terminal holds its own set of environment variables. Thus you must first activate the terminal, you want to change the variable in (see term) set redefines without any warnings, unlike e.g. define.

     Example:
             #set output myfile.gph
             #set author Lars Hanke

sets the environment variable output to myfile.gph and author to Lars Hanke. Note that the variable name is a system token and thus not case sensitive.

See also unset and term.

SetMath
=======

            setmath variable\m value\v

This function stores any integer value given plain or in terms of a global constant to a math processor's variable.

     Example:
           #define d 4
           #setmath x d
           #math y:=3*x
           #post y

will result into the screen output

           12

See also for, func and math or nowhere.

Slip
====

            slip ( 0 | read_col\c )

Marks the following row of the specified read column or of all read columns, if column number 0 is given, a misresult that should not be used for regressions or averaging. Note that anything computed from that entry e.g. by make or generate will bear the same mark. Also note the the diff command will ususally produce bad results, if an item is left out.

The first token holds the READ COLUMN to affect. If zero is specified it affects all column data is read to. Other tokens are ignored. slip is only valid for one single row. It is used to mark one single misresult. Note that the column number refers to the logical READ COLUMN as assigned by using.

     Example:
             3/3/1
             #slip 2
             4/9/1
             5/5/1

Obviously the result should have been something like 4/4/1 and 4/9/1 will destroy any good regression, so this single line will not be considered by a later lreg command.

See also average, lreg, diff, using, columns, leave and take.

SMean
=====

            smean col\c meancol\c

This stores the error of the last mean command to a new column. The first token holds the column to store the error to and the second token holds the column the MEAN was stored to. The whole thing is done during the data read procedure.

See also mean.

Stop
====

            stop ( string\s | text\b )

Promts the rest of the line on screen and waits for any key to be pressed. You should use this function to stop a screen scrolling by and watch some results.

If the first token is a valid global string the contents of the global string will be printed instead of the rest of the line.

Note that a nonzero batch level will cause this command to always continue.

See also batch.

StoreKill
=========

            storekill environment\e

This command is used to locally unset a terminal environment variable. The syntax and function is equivalent to unset, but this command is tracked and the variable will be restored with a call to flushset.

See also flushset, storeset and unset.

StoreSet
========

            storeset environment\e contents\b\o

This command is used to locally set a terminal environment variable. The syntax is exactly equal to set, but this command is tracked and may be annihilated by flushset. This is useful, if you preset your terminals with e.g. a language definition file and want to change some settings for a specific output.

See also storekill and flushset.

TagData
=======

            tagdata sep\a\o [( string\s | expression\m )]

Produces a clear data entry to a tagfile. Accepts an arbitrary number of arguments that may be global strings or math expressions. Note that all arguments are tokens. The arguments are evaluated and written to the tagfile using the separator given in the first token. If the FIRST TOKEN is LONGER than a SINGLE CHARACTER, it will be evaluated as first data entry and the separator will default to /.

     Example:
           #tagdata & mystr 3*4 2+pi

will write (contents of mystr)&12&5.14... to the tagfile

See also tagfile and tagpost.

TagFile
=======

            tagfile file\n tag\s

Opens a tagfile or - if you would rather have it - only one tag. A tagfile is a textfile containing marks which areas belong to which source files. You may post an arbitrary number of lines to each tag and finally read it as an input file for DataProc again. As all tags are assured to start with a comment, DataProc won't notice them while rereading such a file.

The syntax is tagfilename in the first and tagname in the second token. The tagname may be a global string.

Calling tagfile automatically closes previously opened tagfiles and automatically appends new tags, if the given tag is not in the file. It also creates new tagfiles, if the given filename is not found.

     Example:
           [something computed the maths: amp amperr DPA DPSA DblDPA DblDPSA]

           #tagfile "MyTags" File1Results
           #build regress1 "%f/%f/%f/%f" amp amperr DPA DPSA
           #build regress2 "%f/%f/%f/%f" 2*amp 2*amperr DblDPA DblDPSA
           #tagpost regress1
           #tagpost regress2

This would always maintain two data entries in the tagfile MyTags. You may later reread the tagfile as input for another table. This is extremely useful, if you have to regress or average the results of several regressions or averages of different tables.

See also tagpost, tagmath and newlog.

TagMath
=======

            tagmath [var\m]

Generates #math name:=value expressions and outputs them to a tagfile. The syntax is just a list of variables.

     Example:
           #math adj:=10
           #math off:=sqrt(adj)
           #tagmath adj off

will output to the tagfile

           #math adj:=10
           #math off:=3.162278

See also tagfile and tagpost.

TagPost
=======

            tagpost ( string\s | expression\m )

Works exactly like post, but the results are written to the current tagfile. If no tagfile exists, the command will be ignored.

See also: tagfile, post and logpost.

Take
====

            take ( 0 | read_col\c )

Removes the misresult tag set by leave from a read column or from all read columns, if column number zero is specified.

The argument token holds the logical read column to affect.

See also leave.

Term
====

            term driver\s

Specifies an output terminal driver. The next token is expected to be the terminal name. For more information about terminals and output see the Terminals' chapter.

See also write.

Title
=====

            title col\c title\s

Sets a title to a specific column. The command has standard syntax. The argument token holds the string to be used as the column's title. See the Terminals' chapter for more information about titles.

     Example:
             #title 2 Speed

Sets the title Speed to the physical column 2.

See also gtitle, rtitle, unit and globtitle.

UnAmble
=======

            unamble

Deletes a preamble from a terminal. Just to get rid of formerly defined terminal initialization strings.

See also term and preamble.

UnConfig
========

            unconfig [configuration\e]

Deletes a configuration as defined by config from the current table. Refer to config and set for more information about this command group.

See also config and unset.

UnDefine
========

            undefine [var\v]

Cancelles a global variable as defined by define, queue or mark. It also frees its memory. You may pass as many variables as you like to free.

     Example:
             #undefine myvar1 myvar2 myvar3

will free all the 3 variables named. If a variable is not found, undefine doesn't care.

See also define, queue and mark.

Undo
====

            undo col\c

Removes a make directive from a column and thus stops its automatic generation. undo removes mean and smean directives as well.

     Example:
             #make 3 1 4 5

             column 3 is now generated using function 1 with columns 4 and 5
             as function arguments.

             #undo 3

             column 3 won't be generated any longer

See also make, mean, smean and endrun.

Unit
====

            unit col\c unit\s

Sets the name of the unit in the specific column. In fact this is nothing else than another title. The terminals care for a handling of the unit string as a unit. See the Terminals' chapter for more information about titles and units.

     Example:
             #unit 4 cm
             #unit 2 "\frac{\mbox{m}}{\mbox{s}}"

Sets the unit of the physical column 4 to cm and of column 2 to a LaTeX style command to issue m/s.

See also title.

UnSet
=====

            unset [environment\e]

Deletes an environment variable as defined by set from a terminal. See set and the Terminals' chapter for more information about environment variables.

unset may be passed an arbitrary list of environment variables. It will attempt to free all of them and won't mind, if any of them exist.

     Example:
             #unset author output

will free both variables author and output.

See also set and term.

Using
=====

            using [col_sequence\c]

This command assigns the LOGICAL READ COLUMN NUMBERS. using is followed by a list of physical column numbers that are in turn assigned logical read columns in the given sequence. Columns that do not appear in the list will not be read.

     Example:
             #using 3 6 1

will read the first data token into the physical column 3, the second token to column 6 and the third to column 1. Any further data tokens are ignored.

See the Data chapter for  more information about data tokens, etc.

See also columns and ocol.

Void
====

            void col\c start\r\o end\r\o

This command marks a block of rows in a column as invalid. The syntax is in sequence: column to affect, first row to mark void and last row to mark void, both inclusively. As the make command does not overwrite valid columns, void can be used to enable remakes in a second read pass realized by resetting the row counter using the row command.

See also row and make.

WMeanOf
=======

            wmeanof mean\m\d spot_check\m\d [value\m error\m]

This function fulfills the same task as meanof but is its WEIGHTED derivate. The first token holds the variable name to store the average to and the second the variable name to store its spot check error. These tokens are followed by pairs of maths expressions denoting value and their errors each. Note that you must at least supply two pairs -- that is six tokens all in all and that you may NOT average more than 50 pairs, I don't think that you will get 100 values in one line anyway.

See also meanof.

Write
=====

            write datafile\n commandfile\n\o start\r\o end\r\o

Followed by one to four tokens. The first token holds the name of the output file to write to. The second token supplies a secondary filename for additional information that is needed by some terminals.

The last two tokens hold start and endrow, which are both included. Empty tokens or zeroes are interpreted as maximum values -- meaning first or last row.

What columns are written depends on their logical write numbers. See ocol for information about assigning LOGICAL WRITE NUMBERS.

What files are needed, how many columns may be passed and how that is interpreted depends on the selected terminal. See the Terminals' chapter for more information about that.

NOTE that if the first token contains * as the primary output file name, DataProc will choose the stdout stream, usually your console terminal, to print its output. This is nothing new to AMIGA systems, but it is to other platforms. Use this to watch e.g. your Plain terminal output on screen.

     Example:
             #write "data.dta" "data.gnu" 0 8
             #write "dat1.dta" //9

Writes from the first row to row number 8 to data.dta and passes the name data.gnu for the driver file. Then outputs the rest to dat1.dta specifying no driver file.

See also ocol and term.

Data
****

Any line that cannot be processed as a command, comment or post is expected to hold data. Data lines are series of tokens. Each token is read to a LOGICAL READ COLUMN as defined by using in the sequence of their occurence. An empty or missing token causes DataProc to copy the last entry again.

If the first token for a column is read empty the default value on startup is void.

     Example:
             #using 1 2 3
             #math lv:=2*3.9

             1/2.1
             2/3.5/6
             3/4.7
             4/5.2/3
             5/6.1
             6/6.8
             7/7.2/-
             8/7.5
             9/$=lv

     would result in a table:

             1 2.1 -
             2 3.5 6
             3 4.7 6
             4 5.2 3
             5 6.1 3
             6 6.8 3
             7 7.2 -
             8 7.5 -
             9 7.8 -

A token is marked void, if the last character is a - sign. That does however not apply to string typed data. It is also possible to read in variables from the maths processor as shown in the last line of the above example. The MAGICAL sequence $= causes DataProc to seek for a variable that is named as the rest of the token and put its value there. This feature works with double typed columns as well as with integer typed columns.

Terminals
*********

Together with the regression facilities this is the most useful and complex section. DataProc can issue data correctly formatted for a number of other programs. DataProc generates LaTeX tables (tabular environments) using the latex terminal driver, GNUPLOT data and command files using the gnuplot terminal and several other terminal e.g. plain which produces a printer output comes with this version. Read this section carefully, because some terminals may handle some situations absolutely different from others.

All terminals support preambles, which are outputted at the beginnig of the secondary outputfile. If there is no secondary file for the specified terminal, the preamble goes to the primary. All terminals support backslash controls in their preambles.

See also write and ocol for the definition of primary and secondary output files, logical write columns, etc. See term to select a terminal for output.

Terminal names aren't case sensitive anymore, for they are system tokens.

Backslash controls
==================

Some terminal environment variables allow non-printable characters, or you may wish to set linefeeds etc. into preambles. Therefore you may set backslash control sequences. They all begin with the backslash \. The definitions of those sequences is similar to the C-language character definition. Note that by now you may set \% or % to result as a percent sign. Future versions may however support arguments and then \% will oblige. The characters following the backslash are not case sensitive. By now the following controls are supported.

\\
     displays the backslash itself

\0
     is compiled to a null character; ASCII code 0.

\b
     is compiled to the backspace character.

\d
     must be followed by exactly three decimal digits. If you've got less, place leading zeroes. The sequence will be compiled to the ASCII code represented by the decimal number.

\f
     is compiled to the formfeed character. This will feed the current page out of a printer or on most systems clear the screen.

\n
     is compiled to a linefeed character. On most systems this will not only feed, but also cause a carriage return.

\r
     is compiled to a carriage return character.

\t
     is compiled to a horizontal tabulator character.

\v
     is compiled to a vertical tabulator character.

\x
     must be followed by exactly two hexadecimal digits. If you've got only one, place a leading zero. The sequence will be compiled to the ASCII code represented by the hexadecimal number.

\
     must be followed by exactly three octal digits. If you've got less, place leading zeroes. The sequence will be compiled to the ASCII code represented by the octal number. Note that there is NO extra identifier behind the backslash.

Dump
====

This terminal is used to auto-generate include files for DataProc itself. It does not do any data formatting, but the result may be read in right away even by the same commandfile e.g. after resetting the current table. The dump terminal takes care that information about void data or misresults won't get lost. It may also preserve titles and environment variables including preambles.

The very few supported environments for DUMP are:

Global
     will issue a #globtitle command to the destination to preserve the current table name.

NoSlip
     switches off the generation of #slip and #estimate commands to mark misresults or estimated results respectively.

NoTitle
     switches off the generation of titelling commands. Default is to issue #title, #gtitle and #unit. Note that you will get misassigned titles, if you change the column sequence or start by using when rereading the table.

Seps
     sets the data separator character. Usually a space is used, but you may feel like specifying other seperators either to generate output for other programs or to get along with string type columns, which are by now not quoted. That will change in future. Note that backslash controls are supported.

TermScan
     scans the terminals for their environment settings and issues a command sequence that sets those variables again when reread. Rereading won't however cancel variables that have not been scanned, but set later by your commandfile.

GNUPLOT
=======

The primary data file holds the data to plot. The secondary file will have a sequence of GNUPLOT commands written to. All you will still have to do is to start GNUPLOT, type load "secondary file" and you should see your graphics on screen.

The GNUPLOT terminal writes no more than 4 data columns. The first column is expected to hold the x-data and the second the y-data. If three columns are given the third is interpreted as y-delta error and the errorbars style is automatically written to the commandfile.

If 4 data columns are selected, you will need the official GNUPLOT 6.x. This one supports an xyerrorbars style meaning x and y errorbars. Anyhow, the third column holds the x errors and the fourth the y errors. The xyerrorbars style will of course be automatically selected.

Void data is not plotted, but misresults are plotted plain without any further marks. Future versions may enable you to switch that off.

If an rtitle is specified for the y-column and a regression had been done to it, the regression graph is printed as well. Logarithmic regressions (See logreg) are considered and printed correctly, so that you will expect an arced graph in a linear scaled diagram. This graph is titled with the rtitle string. All regressions are memorized!

The globtitle is set to GNUPLOT's equivalent. The column titles (See title) are used to title the axes and their units are put in square brackets. Finally the y-columns gtitle is used to label the data plot.

Preambles (see preamble) are made exactly the first line of the GNUPLOT commandfile. You may use them to custom scale the diagram, select an output file for GNUPLOT and its terminal for instance. You will also find it useful to tell GNUPLOT about scaling the axes e.g. by

              #preamble "set logscale x"

Anyhow, since a lot of versions you would do this by terminal environments and not by preambles anymore.

Grouping is not supported. But you may merge columns and get multiple y-data and even regressions printed to the same x-axis. Note that the terminal checks, if the x-axes of the various regressions are compatible.

Well, there is quite a lot of environments for this terminal. You should be able to produce any 2-D-plot you like. In the following I will use the Dollar symbol $ to indicate the variable's contents. In any case consult your GNUPLOT manual. Here they are in detail:

Angles
     issues a set angles $ to the commandfile. This is needed to switch between radians and degrees in polar plots.

AddPlot
     contents are added behind a seperating comma behind the plot command in the command file. This enables you to e.g. plot a theoretical curve into your experimental data.

AddName
     if ADDPLOT is specified, this environment sets a t behind the ADDPLOT line followed by the ADDNAME variable contents. Thus you may specify a special title for your plot, but only if your added line contains a single plot, or if you like, for the last added plot only.

Errcol
     sets the degree the gnuplot terminal shall handle error columns as defined with the errlist command. Three switches are implemented by now: NONE won't consider any error column, which is the same as not specifying this variable, SINGLE will only consider y-error columns and ALL will output x and y error columns. Note that errorcolumns are overridden by ocol specifications, meaning they only influence the main plot, if you specify exactly two output columns. But whatever its meaning might be to the primary plot, it is newly evaluated with secondary plots as concatenated with merge. The meaning of the switches is quite the same then, but ERRCOL is evaluated if the first plot is two OR MORE data columns, so that you can mix different errorstyles in one plot.

Errorbars
     forces a 4 column output to be handled with errorbars and not xyerrorbars. This should always be set by users, who work with GNUPLOT inferior to 4.x.

FullRange
     contents will be verbally inserted at the position of ranges in the GNUPLOT command file. Note that you have to write the square brackets!

Key
     issues a set key $ to the commandfile. This is needed to place the graphics key in the plot, thus to get it out of interesting regions.

LogBase
     GNUPLOT 3.3 and higher offers the possibility to specify logbases other than 10. If LOGBASE is set and a logarithmic plot is done, the current setting of the LOGBASE Configuration is used as the custom logbase.

LogScale
     issues set nologscale if it is left empty. In any other case it issues set logscale $. You may want to use it with logreg plots.

Output
     issues a set output "$" to the commandfile. You should use it as soon you are sure the plot fits your needs. It saves a lot of typing.

Polar
     issues a set polar if set. By default set nopolar is issued.

Range
     issues a range after the plot command. The brackets are generated, so you will only set the pure range stuff.

          Example:
                  #set range 1:8

          will issue:

                  plot [1:8] ...

     to the GNUPLOT commandfile. As you see you can only set the x-range by now, but if you wish, I may add a more common environment variable.

Size
     issues a set size $ to the commandfile. You will usually use it together with output and term.

Style
     adds another data file plot to the plot command in the commandfile, using the style given in the variable's contents.

          Example:
                  #storeset style csplines
                  #storeset stylename lined through
                  #ocol 1 2
                  #write "data.dat" "data.gnu"
                  #flushset

          would issue the following plot command to data.gnu:

                  plot "data.dat", "data.dat" with csplines

     Note that the csplines style -- data interpolation by cubic splines -- is also a feature that comes with the GNUPLOT 4.x and higher. But e.g. lines would be applicable with any GNUPLOT.

StyleName
     if you specified a special STYLE this will normally be named like the data file read -- this is just GNUPLOT default. STYLENAME adds a title to the extra style.

Term
     issues a set terminal $ to the commandfile. You will usually use that together with OUTPUT.

Tex
     adapts the output for TeX style GNUPLOT terminals for a better TeX graph formatting. You should always set this, if you intend to use the GNUPLOT terminals latex, pictex, epic or eepic.

Yrange
     works just like RANGE but produces a range entry that affects the y-range only. Note that FULLRANGE overrides YRANGE which in turn overrides RANGE.

LaTeX
=====

The traditional terminal and meanwhile the most complex. At first a crude overview. The latex terminal produces a LaTeX tabular environment for output. This is written to the primary output file. The secondary output is ignored. The whole table is put into an \fbox{}. The globtitle is set as a \multicolumn{} stretching across the full table width. If it is missing, the field won't be generated. Then group titles are displayed (see name). If two or more columns of the same group are neighboured in their logical write numbers, no vertical seperators will be drawn between them and the group title will center in that \multicolumn{}.

The table's head is concluded by the column title and unit, which are printed TITLE OVER UNIT and each column separated by a vertical bar from each other. If no units at all are specified the unit line will be suppressed. The head is separated by a double horizontal bar from the table itself.

Void entries are printed as -- medium sized horizontal bars. Misresults are printed in italics. The numbers are formatted and rounded as to the precision selected in the commandfile (see prec and digital). All entries are centered. Columns and rows are seperated by vertical and horizontal bars.

After the table has concluded, the terminal scans for regressions, averages and so on. If an averaging column or a regression's Y-COLUMN is included in the logical write list, all averaging and regression done to each of those will be summarized and the results will be posted in new \tabular environments following the main table. Future Versions may have a feature to influence its style or switch it off.

Regression results are printed as y-title regression type superscript and x-title. The superscript defaults to English. This Version is however freely configurable in any texts. Then the A and B values are printed with errors and units. The A unit is built by \frac{y-unit}{x-unit}. If the regressions were logarithmic, \log is set before the corresponding unit.

Avaraging results are printed in a similar manner. Column title, superscript in the first line. The next line holds \bar{x} the mean, its error and unit. The last line displys the standard deviation with unit after \sigma.

Finally results of FAR DIFFERENCES made by diff. Just as averaging results, but as no standard deviation is computed there is no third line. The mean difference is named \bar{\triangle x}.

The LaTeX terminal supports a whole lot of environment variables and is very freely configurable. Beyond that I am sure that there will still be need for further configuration variables.

The variables REGDATA, MEAN, MEANID, DIFF and DIFFID serve to adapt automessages to your native language. Other than in the old versions (1.120 and below) the default values are now English. I recommend to write an include file for language adaption. By now DataProc is shipped with deutsch.tst and deuteep.tst supplying a German language adaption ex- or including EEPIC settings for the GNUPLOT terminal.

Except for the preamble BACKSLASH CONTROLS seemed not to be necessary and are thus NOT SUPPORTED by this terminal.

Here are the environment variables in detail. As before I use the Dollar symbol $ to indicate the variable contents.

aID
     sets the identifier string that preceeds regression slopes. Defaults to a.

Base
     sets the identifier string that preceeds custom logbases as set with the LOGBASE Configuration for logarithmic regressions done by logreg. Note that this identifier will only be used, if none of the special cases - namely decadic represented by lg and natural represented by ln - is detected.

bID
     sets the identifier string that preceeds regression offsets. Defaults to b.

Caption
     produces a \caption line. You will probably use it together with FLOATHEAD. The globtitle is used as caption and won't be issued anymore in the table itself, when CAPTION is set. If CAPTION holds contents they are used as the \label name.

          Example:
                  #globtitle Tabelle
                  #set caption mytab

          would produce an output like:

                  \caption{\label{mytab} Tabelle}

Corr
     enables the output of correlation ratios in regression data blocks.

CorrID
     sets the identifier string that preceeds correlation ratios. Defaults to $r$.

Diff
     sets the default name for Differencing data, which is posted at the beginning of a block containing those data.

DiffID
     sets a symbol for the differencing data, which is displayed directly in front of the numerical value. This string defaults to $\bar{\triangle{x}}$.

ErrSty
     sets the way error columns should be handled. Currently NONE and TINY are supported. NONE is the same as not specifying this variable and will ignore error columns. TINY prints both, the column's and error column's contents in one column seperated by $\pm$. This results in more narrow tables.

Estimate
     sets the string to issue in front of estimated data. This string defaults to \bf.

Exclude
     specifies the relationship between slip, estimate and invalid data. The syntax is pairs of the above keywords, the first naming the influencing data type and the second which to exclude with the former.

          Example:
                #set exclude invalid slip invalid estimate slip estimate

     This is the default setting meaning that invalid data won't cause the slip or estimate strings to issue, if the data is not only void but marked irregressible or estimated too. Finally slip is set to override estimate, thus misresults won't be marked to rely on estimated data, if they do.

FloatHead
     puts the whole table into a table and center environment as most of you will probably do anyway. Well, it saves typing.

Invalid
     sets the string to issue for invalid data. This string defaults to ---.

Mean
     sets the default name for Averaging data, which is posted at the beginning of a block containing those data.

MeanID
     sets a symbol for the averaging data, which is displayed directly in front of the numerical value. This string defaults to $\bar{x}$.

NoHead
     inhibits the standard tabular header and titeling. Note that it does not influence CAPTION or FLOATHEAD.

NoReg
     inhibits the regression data blocks which are printed following to the table itself.

Priority
     sets the sequence for the SLIP, ESTIMATE and INVALID strings. This defaults to estimate first, slip second and invalid last. Simply set the keywords slip, estimate, invalid in the desired sequence.

RegData
     sets the default name for Regression data, which is posted at the beginning of a block containing those data.

Size
     puts the table -- not the regression data blocks -- into a LaTeX environment, which receives the name of the variable's contents. You may use it for oversized (too wide) tables and select a smaller font for it.

          Example:
                  #set size scriptsize

          would result in the structure:

                  optional FloatHead and Caption

                  \begin{scriptsize}

                  the table itself ...

                  \end{scriptsize}

                  regression data blocks ...
                  optional FloatHead close

Slip
     sets the string to issue in front of inregressible data. This string defaults to \em.

SuperTab
     tells DataProc to use the SUPERTABULAR environment. Note that you need the corresponding style file to use this environment. As supertabular can pagebreak in tables I recommend to use this option for long tables. Note also that I cannot place the table into an enclosing \fbox anymore and thus it looks a bit different, say more loosely, so for smaller tables you may prefer the normal tabular still. SUPERTAB inhibits NOHEAD, but that my change, if you request me to do it.

Plain
=====

This terminal was designed for a 7 bit ASCII output e.g. to a printer. You may in some respects however select an extended charset and I'm working on improving that. Beyond that I plan to write a terminal supporting graphics facilities of printers, but it has low priority, as long I don't drown in requests.

The output format is similar to the LaTeX terminal. Please refer to that section for detailed information about how the table and regression blocks look like. As TeX does, all scaling is done automatically.

Note that other than the LaTeX terminal, plain supports backslash controls. Backslash controls may be specified for any single character definition and the slip style initer string. Of course like all the other terminals plain supports those controls in its preamble.

Note that during software developement the LaTeX terminal has higher priority than Plain. So LaTeX is usually a little bit better featured than Plain, but Plain will always catch up in near revisions.

The environment variables differ a little from the LaTeX terminal and beyond that there are many more of them to customize your output. Indeed I would recommend an include file for your favorit settings. It may be a good idea to select your screen as output file for table previewing and thus have an include for your terminal as well. Now the environments in detail:

aID
     sets the string preceeding regression slopes in the regression data summaries

Base
     sets the identifier string that preceeds custom logbases as set with the LOGBASE Configuration for logarithmic regressions done by logreg. Note that this identifier will only be used, if none of the special cases - namely decadic represented by lg and natural represented by ln - is detected.

bID
     sets the string preceeding regression offsets in the regression data summaries

Corr
     enables output of the correlation ratio in the regression summaries.

CorrID
     sets the string to preceed correlation ratios. Defaults to r.

Cross
     the first character of the contents defines the character to use for a single horizontal bar crossing a single vertical. Defaults to +. On MS-DOS systems you may try: #set cross \d197

Custom
     allows you to custom scale the column widths of the table. The variable string is parsed for tokens. Each of those tokens is parsed for number$width. This will set the fixed WIDTH to the table's NUMBER column. Note that SPACING is added left and right to the column width, as well as one character for a vertical bar.

Deviation
     sets the string to issue in the regression blocks in front of the standard deviation result, which is by now only supported by blocks generated by average. Defaults to Deviation.

Diff
     sets the string to issue in the regression blocks for titelling data created by diff. Defaults to Difference avaraging data.

DiffID
     sets the string to issue in front of the DIFF result. Defaults to Mean difference.

Estimate
     allows to define a control sequece to mark estimated values. The variable string is parsed as two tokens. The first one switches the estimate style on, the second off. The string is parsed as a C-type printf() format string. Thus you may use e.g. \x08 to define the ASCII control character number 8. As you probably know \x introduces a hex number, the backslash alone an octal number. You must write \\ for the backslash itself and \% for a %-sign. Each of both control strings may not exceed 29 characters. The default is nothing.

Exclude
     specifies the relationship between slip, estimate and invalid data. The syntax is pairs of the above keywords, the first naming the influencing data type and the second which to exclude with the former.

          Example:
                #set exclude invalid slip invalid estimate slip estimate

     This is the default setting meaning that invalid data won't cause the slip or estimate strings to issue, if the data is not only void but marked irregressible or estimated too. Finally slip is set to override estimate, thus misresults won't be marked to rely on estimated data, if they do.

Feed
     sets the number of blank lines in front of the table. Defaults to zero.

HDCross
     sets the character used for a single vertical bar crossing a double horizontal. Defaults to |. On MS-DOS systems you may try: #set hdcross \d216.

HDLeft
     sets the character used for a single vertical bar ending a double horizontal found at the left hand side. Defaults to =.

HDLine
     sets the character to use for a double horizontal bar. Defaults to =. On MS-DOS systems you may try: #set hdline \d205

HDRight
     sets the character used for a single vertical bar ending a double horizontal found at the right hand side. Defaults to =.

HLine
     sets the character to use for a single horizontal bar. Defaults to -. On MS-DOS systems you may try: #set hline \d196

Invalid
     sets the string to issue for invalid data. If this environment is not set, the terminal fills the cell with - leaving one space left and right.

InterFeed
     issues a formfeed between the table and the regression block if set.

Left
     sets the character used for a single vertical bar ending a single horizontal found at the left hand side. Defaults to -.

Margin
     sets the number of spaces left of the table and regression blocks. Defaults to zero.

Mean
     sets the string to issue in the regression blocks for titelling data created by average. Defaults to Avaraging data.

MeanID
     sets the string to issue in front of the average result. Defaults to Mean.

NoReg
     suppresses the output of regression blocks if set.

NoTable
     suppresses the output of the table if set.

Priority
     sets the sequence for the SLIP, ESTIMATE and INVALID strings. This defaults to estimate first, slip second and invalid last. Simply set the keywords slip, estimate, invalid in the desired sequence.

RegData
     sets the string to issue in the regression blocks for titelling data created by lreg and logreg. Defaults to Regression data.

Right
     sets the character used for a single vertical bar ending a single horizontal found at the right hand side. Defaults to -.

Slip
     allows to define a control sequece to mark misresults. The variable string is parsed as two tokens. The first one switches the slip style on, the second off. The string is parsed as a C-type printf() format string. Thus you may use e.g. \x08 to define the ASCII control character number 8. As you probably know \x introduces a hex number, the backslash alone an octal number. You must write \\ for the backslash itself and \% for a %-sign. Each of both control strings may not exceed 29 characters. The default is nothing.

Small
     tells the terminal to omit the single horizontal bars. This lets the table appear more compact and reduces it to half its length. Try it out.

Spacing
     sets the number of spaces to place left and right of a table entry. Defaults to one.

VLine
     sets the character to use for a single vertical bar. Defaults to |. On MS-DOS systems #set vline \d179 is preferable.

Regressions
***********

As mathematic formulae cannot be typeset in standard ASCII format, this chapter is only available in the TEX document. If you do not want to read the TEX manual, consult your calculator manual -- most of the formalism used might be found there.

Errors
******

Well, I'm not very pleased with the error handling of neither DataProc itself nor the math processor. The messages of latter are well defined and need no further explanation, but the position marked, where the error should have occured, is almost arbitrary. I will try to install a better error handler when wedging the math module, soon.

The error messages of DataProc itself are typical for compilers. They are not too definite and are sometimes caused by faults lines ahead. Although the error system already improved a lot, some situations still don't give good diagnostics. In any case I cite the errorline and command.

But here are the massages and what they mean:

Never mind -- it's a joke
     well, ignore it and give me a note, if that occures. The problem is a software bug.

Invalid column
     the column number given is out of range. In most cases you will have forgotten to define the column (see columns)

Unknown command
     tells you that the COMMAND is unknown. You will supposedly have mispelled it.

Invalid function
     the function number given was never defined

$ -> File "$" does not open
     the named file cannot be opened, because of the numbered operating system error.

Invalid terminal
     the named terminal is not found in the terminal list. You will probably have mispelled it.

Low memory space
     well, buy some RAM to cope with that.

Invalid mathematical expression
     should be preced by the message produced by the math processor. See my words above of how I think about those.

Invalid format descriptor
     e.g. in columns you specified a column format other than %d, %f, %lf, %s

No data for regression
     In most cases that will mean that the y-column or the wheigt columns are invalid. If they are O.K. check your memory and if that isn't low report it to me, because that may be a bug. This of course applies to average and diff as well.

Invalid group
     the group number given was never defined. Define the group or correct the number.

This should not appear
     well, it's exactly that. There is certainly a software bug.

Did not expect data here
     should never appear. If so, give me a note.

Cannot add number tag
     a global constant cannot be set, because either the variable already exists or there is no memory available to store it.

Unknown number tag
     a number was represented by an unknown global constant

Global constant expected
     in a define statement (or similar) an obligatory name of a global variable is missing

Terminal environment variable expected
     in a set or unset command the variable key is missing

Terminal environment variable not parseable:
     you will have mispelled backslash controls in an environment or preamble. Note that the error is issued by the terminal and thus won't appear when the definition was made.

Unknown option $ in terminal environment
     some environments supply realtime parsed option strings (e.g. LaTeX - priority). You will have mispelled an option or missed an option, if the list requires pairs.

Table size exceeded, enlarge #dsize
     should no longer appear

Column already exists
     The column you want to add with addcol is already part of the table

Global string $ is not parsable
     The named global string cannot be evaluated. Check your backslash syntax

The string $ is too long
     A given string is longer than the field it should be written to. Note that only some functions check for such overflow. Specifying too long strings may cause your machine to crash with a lot of commands. I will gradually introduce such checks to all functions, but until then -- be careful.

DOS command "$" failed
     The command you passed to dos caused an error during execution

No more #IF opened
     You called else or endif, but you did not specify a corresponding if.

#IF at line $ is not closed
     You exit a commandfile with an if command that was not terminated by endif.

NEXT without FOR
     There is no for command that could be terminated by the given next command at that line.

Identifier expected
     The command assigns a value to some symbolic constant, but its name is missing.

Obligeous argument missing
     An argument that must be supplied is missing. Only very few functions generate this error. By now it is only meanof and wmeanof, but do not rely on that, cause that may change independantly from the documentation.

$ writing file "$"
     the numbered operation system error occured during output to the named file.

$ clearing file "$"
     the numbered operation system error occured when flushing the buffers of the named file.

$ closing file "$"
     the numbered operation system error occured when closing the named file.

$ working on file "$"
     the numbered operation system error occured during non-I/O operations in the named file.

$ reading from file "$"
     the numbered operation system error occured during a read operation from the named file.

History
*******

Some words on history. The internals of DataProc have been severly tested during my physics practice and should work fine, but without any kind of user friendliness. That were the revisions 1.0 to approximately 1.100. The rest was spent on more abstract commandfiles and more flexible terminals resulting in such as global variables, terminal environments and the removal of case sensitivity. Performance has increased a little as well, although I did not really optimize anything by now. The first version fulfilling (hopefully!) this manual is 1.144. As the manual developed from 1.120 there might still be some ancient remarks in it. Ignore them, if you find more comfortable remarks somewhere else in this manual.

I added the areg command in revision 1.145, but as I already feared, the math processor is much too instable and too slow for it. I tried to fit the results of a slit experiment to a sinc-function. Using the same data in a hardcoded program with the same subroutine worked fine, but the results of DataProc are unusable and seem to be slightly divergent. NOTE: I came back to it later and found out that there had never been a bug in DataProc. areg worked fine from the very first moment, but sinc(x) was instable around zero.

SAS/C (tm) V6.0 arrived and I recompiled the old stuff. According to new compiler warnings I found some errors in the code. Also I removed some bugs in the Plain terminal and made the GNUPLOT terminal useable without TeX. I fitted the code for compilation on an IBM PC, detecting another set of buggy code sequences. Finally I ran the standard Amiga test, meaning MungWall and Enforcer and removed DataProc's Enforcer hits. Revision 1.153 is the product of all those internal bugfixes. DataProc became about 7 kB longer but considerably faster.

Well, the first release should be DataProc 2.0, but I lacked of testers and as it all works fine so far, I don't think it to be a big fault to release Version 1.153 already.

Version 1.154 fixed the end vbar of the unit title line of the Plain terminal.

Version 1.156 is almost the same code -- apart from a fix of the sgn() function, but as I gained confidence in the code I set the optimize flags for the compiler and DataProc shrinked about 12 kB and increased a great deal in speed.

Version 1.157 now supplies the ADDPLOT environment variable in the GNUPLOT terminal to add theoretical functions to experimental data.

Version 1.162 supplies the GLOBAL STRING feature and a slightly enhanced error report feature. The latter will be one of the major concerns in future.

Version 1.167 fixes the boundary bug. Previous versions needed the upper boundary to be set one higher than told in this manual, namely the first excluded row. This bug is now fixed.

Version 1.169 introduces the environment variable SMALL in the Plain terminal and fixes a disgusting bug in the digital type formatting of output. It still does not work how it should, but it at least should not produce wrong results anymore. As soon as I'll find some time I'll rewrite that routine to ultimately fix that problem.

Version 1.174 is the promised digital fix. The new code might be slightly slower, because it now uses floating point maths, but it has a crucial difference. It has a chance to work and the first tests seemed very positive. Beyond that the new modules have been compiled with SAS/C 6.1 resulting in even more effective code.

Version 1.177 is the answer to the reported rounding problems. Why hadn't such severe problems been reported before? The trimming routines are now completely rewritten and should be stable by now. Anyhow, there might still be special cases that I didn't consider, so check the new routines carefully. The behaviour has changed a little. Selecting a precision of 4 cyphers will always result in a display of 4 significant cyphers, even if the last ones are zeroes! Rounding should do fine now.

Version 1.178 adds the runit command and some smaller enhancements in configurability.

Version 1.182 supports the LaTeX SUPERTABULAR environment for LaTeX style tables.

Version 1.187 now computes correlation ratios for linear and logarithmic regressions, can monitor them to stdout, set them to math variables and of course output them to the relevant terminals. Finally I found an Amiga specific bug in the stdout management. Here's to you, Tim, now your stdout will be sorted, finally!

Version 1.189 is the answer to a set of guys using this software extensively but don't even think of paying for it. Well, this version is equipped with a keyfile. It runs perfectly without a keyfile, if you got strong nerves, but a valid keyfile will switch off those nasty intermezzos!? Well, see and enjoy!

Version 1.202 is nothing but the (almost) perfection of the shareware reminders. You will notice, what it is, while using it. Never mind, pay!

Just coming back from porting DataProc to MS-DOS. Finally it seems to run fine as I thought of carrying my test files with me. I fixed a possible bug in the maths processor that the compiler complained about. The handling of the Keyfile changed a bit, because fseek() doesn't seem to work how it should. In the end the MS-DOS users are the lucky guys, cause the most nasty shareware reminder during the execution does not work. Don't be too happy, but be sure that I'll fix that. Version 1.203 is nothing but the recompiled port sources.

Version 1.205 no longer requires the number token in the columns command. Beyond that a bug in COLUMNS had been fixed allowing you to omit the using command from your scripts. By default DataProc will read all columns in the given sequence now.

Version 1.213 now allows to read several columns later. See the command row that has been added. Beyond that quit and exit are new and prepare an interactive mode. Finally a bug in the plain terminal has been fixed. Well, I had some severe crashes, but I couldn't track them down to DataProc. Two hours of constant testing with Enforcer and MungWall didn't produce any hit ... so I tend to blame it on some other task. Anyhow, if you encounter crashes, report them immediately and tell me what other tasks are running, libraries installed, etc.

Version 1.214 is the product of two sleepless nights of debugging and the INTERNAL version now owns a 40kB sized cross debugger. I will now go to sleep telling you ... there ain't no more crashes! Ahh, before I forget to mention it, there had been a display format bug with void data in the plain terminal, this had been fixed during the last two nights as well.

Version 1.221 has the interactive mode added. See documentation for special information.

Version 1.225 is a bugfix compendium. First a bug I most likely have implemented myself in 1.213 that prohibited DataProc from making columns, which have already been generated by make, is fixed. Then a typo in the GNUPLOT terminal was also fixed. And finally an annoying and heavy bug in logscaled regression is removed. Note that any results you got from logarithmic actions like logreg used the natural logarithm and NOT the decadic as mentioned in the manual. By now this is fixed. Finally weighted logarithmic actions had been pure nonsense, this is fixed as well.

Version 1.227 fixed another typo in the GNUPLOT terminal. Logarithmic plots should now be perfect.

Version 1.228 fixed the POLAR environment in the GNUPLOT terminal. It now works as it should.

Version 1.233 is another contribution to user friendliness. First you may specify undefined global variables as function numbers in the func command which will then automatically initialized, second the dsize command is far less critical than before.

Version 1.234 added the addcol and remcol commands. For all practical purposes they are obsolete, but you may think them as a contribution to the beauty of commandfiles. As I lack of time I had no time to test the routines, but for all thats logic ADDCOL has to run and REMCOL at least should do.

Version 1.235 is the recompile of the 1.234 MS-DOS port on the Amiga machine. The sources are now assured to be identical.

Version 1.236 is the product of half an hour using the program myself. For what do I have testers, if they don't even notice severe uncomfortabilities? The GNUPLOT terminal now supports a YRANGE environment. The LaTeX terminal's regression slope and offset identifiers are now configurable. Titles may now be fed with global strings. Finally you may now open a logfile to store additional information you may need while while writing down your results.

Version 1.238 fixes a handful of bugs I found in the same half hour. As nobody complained, I assume nobody uses the features added since 1.100.

Version 1.239 adds the precision feature to the build command's float conversion.

Version 1.241 fixes a bug that came in with the titles taking global strings and an old bug in mark. MARK now really works as described in this manual, but it returned a one too small number in older versions.

Version 1.246 adds the tagfile support and the dos command.

Version 1.247 adds the if clause and a lot of interactive stuff. See ask, else, endif, readvar and stop for more information. Tagfile support was enhanced by tagdata.

Version 1.249 adds the enhanced batch support commands storeset, flushset and flushvar. The online statisic commands meanof and wmeanof and finally the Plain terminal, too, supports the AID and BID environments.

Version 1.254 has a lot of the keyfile and shareware reminder stuff with a completely new concept rewritten. I hope it now works on MS-DOS machines. Note that UNREGISTERED MS-DOS VERSIONS CRASHED on some systems.

Version 1.258 adds the storekill, closetag and closelog commands. It also fixes some bugs in the terminal environment variable storing code. Now input may be used as a synonym for include, because me and some other TeX freaks messed them up constantly. Finally the error handlig using include files returned the location of the uppermost INCLUDE command. This is fixed by now and the correct location will be displayed.

Version 1.260 now monitors all file I/O errors and traps them. So on Amiga systems you should have to press nasty requesters only one time. Originally I wanted to find a bug by tracking I/O activity, but the bug is still in there. During the installation of the control routines I optimized file I/O a little. It seems to me that output got faster even though anything is checked by now. Beyond that two new commands are installed. See batch and nop for documentation. See also the chapter Errors, because a whole lot has changed there.

Version 1.263 is the result of 10 hours of bug hunt and I finally caught it, it came in with flushset and caused weired error messages.

Version 1.264 is the recompile of the MS-DOS port. Some smaller bugs in the I/O error handling had been resolved. Beyond that the MS-DOS file I/O has been completely revised. At least with MS-DOS Version 6 everything works all right -- yes the keyfile stuff as well!

Version 1.265 fixes a bug in the tagdata command that missed out the last seperator.

Version 1.267 adds the linear interpolation command inter.

Version 1.268 predefines some math variables to identify the system you're running on. The Amiga version defines Amiga:=10 and MSDOS:=-10 and the MS-DOS version vice versa.

Version 1.270 fixes some strange error messages on MS-DOS systems and an enforcer hit.

Version 1.272 fixes the string data type. It didn't run at all, but it had done earlier. Beyond that a bug in the scanner was fixed, now grouping works as one would it expect it to.

Version 1.274 enables auto define in group command and adds the tagmath command.

Version 1.279 adds the automatic error column support. See errlist, remerr and mean for more information. Beyond that it fixes a bug in the group command. It now handles global constants correctly. Finally I added ERRLIST support for the GNUPLOT terminal.

Version 1.281 fixes another boundary bug. Some functions e.g. write, contract, generate mixed up the upper and lower bound token. This is fixed now. Beyond that a small internal bug with mean and errorcolumns was fixed.

Version 1.282 defaults the queue offset to 1 and it may now be omitted.

Version 1.284 adds error column support to the delta command and fixes a severe bug in it. The old versions marked all output as void and inregressible. I'm not sure when this error creeped into the program.

Version 1.287 enhances the prec command for error column support.

As I will have to do a cosine fit next week, I investigated on problems in the areg command and I found none. See the demo for two examples, a cosine fit and a hyperbolic tangent fit. It works slow, but fine. The fit that left me in doubt was a fit to sin(x) by x, which is not defined properly for x=0. So be careful with such functions.

Finally I added the template concept to the do documentation. Note that there may be \s tokens that do not accept global strings by now, but this will change in future.

Version 1.289 makes write and input/include accept global strings as filenames.

Version 1.292 adds the for loop and the setmath command. Furthermore the math processor now supplies the slit function (sinc) and its derivative with correct results for small arguments (see Mathematics).

Version 1.296 adds the endrun, preclist and diglist commands. Beyond that it enables global constants for digital precisions. Furthermore a severe internal bug was fixed that showed up during data rereads and automatic column generation.

Version 1.303 has major internal changes. This finally results in the support of estimated data (see estimate), the LaTeX terminal grouping bug is fixed, tag files should do fine with every multitasking environment now and some minor internals were fixed. Beyond that a new type of variables was introduced - the configurations (see config). Step by step a lot of commands will behave differently with varying configurations. Finally I ran a MungWall Enforcer test and encountered no errors with the full demo.

Version 1.304 supplies a wider configurability of the LaTeX terminal. See its environments SLIP, ESTIMATE, INVALID, PRIORITY and EXCLUDE.

Version 1.306 fixes a bug in the if command nesting. Former versions evaluated else and endif during false conditions.

Version 1.307 fixes a big bad bug with all those slip, estimate, leave and take commands. They did not evaluate read columns as stated in the docs, but physical columns. This is fixed. Beyond that the Dump terminal now supports the ESTIMATE command.

Version 1.310 fixes another bug in the if nesting. Beyond that I noticed that DataProc reacts pretty sour to misbuilt data input. I will try to establish a better error handling. IF is now patient with undefined math expressions. It issues a warning and proceeds with false condition.

Version 1.314 fixes an enforcer hit (not too serious) in the grouping stuff and copes with some shutdown problems with tagfiles. Beyond that the demo v15 was corrected. Finally the ADDNAME environment for the GNUPLOT terminal was added.

News
****

Here are the bugfixes, enhancements and new features since the last worldwide spread version. Just fly through them, if you're familiar with DataProc.

Finally I'm just typing the last line of the new documentation concept. The root is now a .texinfo file and will be shipped as AMIGAGUIDE, INFO and .dvi and ASCII.

Version 1.318 updates and fixes some problems in the Plain terminal. Beyond that a not too serious problem in the LaTeX terminal was fixed. LaTeX might have opened and closed too many braces, thus wasting space.

Wedged a little bit through the documentation. Umlauts now appear in the .dvi file as well as the systematic command Reference. The shipping scheme is also done: the .texinfo file is shipped with any version. The .dvi file will not be part of archives, but will be included on disks. The AMIGA release is shipped with a .guide file and the MS-DOS release with a .doc file, which longs for a little improvent, but it is better than the old .hlp anyway.

Version 1.320 introduces the first Configuration settings customizing the LOGFILE banner messages and allowing inline comments. Beyond that the write command now supports * as an identifier to redirect the primary output to stdout.

Version 1.322 added inline comment support to hopefully all functions that did not support them, yet. Beyond that the readstring function was added.

I just FAST ported TEXINDEX to the AMIGA and thus fitted the printed documentation with the Concept Index.

Version 1.324 finally supports the HDCROSS environment for the Plain terminal. Beyond that it may be further customized by LEFT, RIGHT, HDLEFT and HDRIGHT.

Version 1.332 supports variable logarithm bases with logreg. During implementation I noticed a severe bug in the Configuration concept. So if your program did weired things or even crashed, it might be it. The LOGBASE feature added some environments to all terminals except for DUMP.

Version 1.336 is a whole lot of minor and subtle, but annoying bugfixes.

Version 1.339 fixes a bug in the include command. It now really accepts global strings. Beyond that the areg template in this documentation was corrected. Finally a typo in ask was removed. Finally it fixes a bug in wmeanof. It computed a wrong error.

Version 1.342 adds the STYLENAME environment to the GNUPLOT terminal enabling you to title auxiliary styles in plots.

Version 1.343 fixes a bad bug in the endif function. If you had a closed if construct in the else clause of an outer if, the clause wouldn't be continued after the inner endif. Sorry!

Version 1.346 fixes the bad ! layout. On most platforms the command issued too many linefeeds. It now works like one would expect it to work. Thus two sequential ! commands will produce two lines that are NOT separated by blank lines.

Version 1.347 adapts the GNUPLOT terminal to GNUPLOT 3.6. The ERRORSQUARES style was replaced by XYERRORBARS. DATAPROC is now no more compatible with my older patch to gnuplot, but as I became gnuplot co-coordinator, I may assure you that with the 3.6 release you may use any further official gnuplot.

Version 1.348 is now localized on the Amiga - well, I only have a German translation by now. Anyhow, maths processor messages come from a different link module and stay English.  Note that the terminal string defaults are also localized.

Version 1.350 completes the Amiga localization. The math module however is not localized. As for now I do not intend to localize it, but if you ask me to do it, I'll try. Beyond that the Keyfile handling was made a bit more flexible. Furthermore the whole code was recompiled with SAS 6.50.

Version 1.358 hunted down a big nasty bug that must have been in DataProc from the very beginning. Apparently it never showed up before. It should be fixed by now. Furthermore a new maths-processor's variable is initialize upon startup. It's called LANGUAGE and holds the phone code of the country DataProc is setup for. With non-localized implementations this defaults to 1, which is USA and Canada.

Version 1.361 adds the choice command, which is an extension of if and the cput command, which is a conditional form of the ! command. Furthermore it adds the cbuild command and makes ask to accept global strings.

Version 1.362 makes stop accept global strings as arguments. I noted that SAS 6.50 made the Amiga release a great deal faster than it was. Whence the tanh demo regression took 5.5 seconds in earlier times I now hardly note a delay. The demo files are now localized and appear in English, German or French, just as you would have it.

Version 1.364 fixes a small, light but nerving bug upon interactive mode termination. For some reasons DataProc tried to close the Shell it was running from. Furthermore it fixes a bug in keyfile handling with 68040 processors.

Report errors, suggestions and registrations to:

        MGR, Asgard
        Lars Hanke
        Schlachthofstr. 67
        44649 Herne 2
        Federal republic Germany

        FIDO: Lars Hanke 2:243/4802.22
        UUCP: mgr@asgard.bo.open.de

Good luck with this program and happy computing!