GREG High-Level Subroutines

These routines essentially format the command line to pass it later to the GR_EXEC subroutine, and are thus the less efficient routines of the GREG library. They are provided essentially for user convenience because the formatting needed to use GR_EXEC might be tedious. Note all GREG commands have the high level equivalent, but all can be used with GR_EXEC.

Each subroutine corresponds to a command, and each entry corresponds to an option of that command. The subroutine and entry names are built from the 4 first characters of the corresponding command and option names. The entries must be called before the subroutine, since it is this one which effectively transmit the command to GR_EXEC.

The conventional type of arguments are

        NAME            Character
        ARG,ARG1,...    Real*8
        IARG,IARG1,...  Integer*4
        NARG            Integer*4

When NARG is present, all arguments need not be passed : trailing arguments may be omitted. NARG is used to give the actual number of arguments passed after NARG itself and it must be set precisely. All arguments before NARG, usually the character string NAME, and the argument NARG must always be present (even if NAME=' '). Note that if ARG1 is missing, ARG2 cannot be present. Note also that the double quotes should not be passed for character strings. For instance, the interactive command LABEL ``A little toy'' should be replaced by CALL GR_LABE('A little toy').

Example : CALL GR_DRAW ('MARKER', 2, 0.3D0, 0.8D0)

Note that the ARG1 and ARG2 arguments are here expressed as constants, and the D exponent is required as they must be Real*8 values.

The high level routines are not yet fully guaranteed as up to date. In the following description, each high level subroutine is preceeded by the assumed syntax for the equivalent command. If this syntax differs from the current internal help description, using the discrepant parts of the high level routine will cause a fatal error, but common parts of the syntax can be used safely.

For the GTVL language, the following routines are available

CLEAR [Argument]
        SUBROUTINE GR_CLEA(NAME)

DEVICE [Type [Descriptor]] [/OUTPUT Logical_Name]
        SUBROUTINE GR_DEVI(NAME)
        All arguments of command DEVICE being character strings, it is
        easy to concatenate them into NAME.

For the GREG1 language, the routines are

AXIS Name [A1 A2] [/LOCATION X Y] [/TICK Orientation [BIG SMALL]]
        [/LABEL Position] [/[NO]LOG] [/ABSOLUTE]
        SUBROUTINE GR_AXIS(NAME,NARG,ARG1,ARG2)         ! 28-Sep-1986
        ENTRY GR_AXIS_LOCA(NARG,ARG1,ARG2)
        ENTRY GR_AXIS_TICK(NAME,NARG,ARG1,ARG2)
        ENTRY GR_AXIS_LABE(NAME)
        ENTRY GR_AXIS_LOG
        ENTRY GR_AXIS_NOLO
        ENTRY GR_AXIS_ABSO

BOX [Arguments]
        SUBROUTINE GR_BOX(NAME)                         ! 28-Sep-1986
        ENTRY GR_BOX_ABSO

COLUMN [X Nx] [Y Ny] [E Ne] [/FILE File] [/LINES Lmin [Lmax]]
        [/TABLE TableName]
        SUBROUTINE GR_COLU(NAME)                        ! 28-Sep-1986
        As this routine is normally of no use in the library version,
        it requires you to code explicitly the remaining part of the
        command line. Hence, it should be equivalent to use
        either GR_EXEC('GREG1\COLUMN '//NAME)
        or GR_EXEC1('COLUMN '//NAME)

CONNECT [/BLANKING Bval Eval]                           ! 28-Sep-1986
        SUBROUTINE GR_CONN
        ENTRY GR_CONN_BLAN(NARG,ARG1,ARG2)

DRAW [Action [X Y]] [/USER] [/BOX N] [/CHARACTER N] [/CLIP]
        SUBROUTINE GR_DRAW(NAME,NARG,ARG1,ARG2)
        ENTRY GR_DRAW_CHAR(NARG,IARG)
        ENTRY GR_DRAW_USER
        ENTRY GR_DRAW_BOX(NARG,IARG)
        ENTRY GR_DRAW_CLIP

        Note that no support is given for DRAW TEXT and DRAW FILL_AREA,
        unless you specify in NAME all the arguments and set NARG to 0.
        DRAW TEXT can easily be replaced by GR_DRAW('RELOCATE'...)
        followed by a call to GR_LABE.

ERRORBAR NAME
        SUBROUTINE GR_ERRO(NAME)                        ! 28-Sep-1986

HISTOGRAM [/BASE [Ybase]] [/BLANKING Bval Eval]
        SUBROUTINE GR_HIST                              ! 28-Sep-1986
        ENTRY GR_HIST_BASE(ARG)
        ENTRY GR_HIST_BLAN(NARG,ARG1,ARG2)

LABEL "String" [/X] [/Y] [CENTERING N] [/APPEND]
        SUBROUTINE GR_LABE(NAME)                        ! 28-Sep-1986
        ENTRY GR_LABE_X
        ENTRY GR_LABE_Y
        ENTRY GR_LABE_CENT(IARG)
        ENTRY GR_LABE_APPE

LIMITS [Xmin Xmax Ymin Ymax] [/XLOG] [/YLOG] [/RGDATA] [/REVERSE [X] [Y]]
        [/BLANKING Bval Eval]
        SUBROUTINE GR_LIMI(NARG,ARG1,ARG2,ARG3,ARG4)    ! 28-Sep-1986
        ENTRY GR_LIMI_XLOG
        ENTRY GR_LIMI_YLOG
        ENTRY GR_LIMI_RGDA
        ENTRY GR_LIMI_REVE(NAME)
        ENTRY GR_LIMI_BLAN(NARG,ARG1,ARG2)
        Arguments of GR_LIMI can be omitted with the standard VAX
        convention to indicate that automatic limit must be computed
        for this one. For example
                CALL GR_LIMI_XLOG
                CALL GR_LIMI(4,0.d0, ,-10.d0,10.d0)
        is equivalent to
                CALL GR_EXEC1('LIMITS 0 * -10 10/XLOG')
        Presently, there is no support for the fifth argument (Angular
        unit or Absolute coordinates) and for the =, < and > possibilities
        of command LIMITS in this High Level routine. To use these
        possibilities, you should use directly GR_EXEC1('LIMITS ...').

PENCIL [N] [/COLOUR C] [/DASHED D] [/WEIGHT W] [/DEFAULT]
        SUBROUTINE GR_PEN(NARG,IARG)                    ! 28-Sep-1986
        ENTRY GR_PEN_DASH(IARG)
        ENTRY GR_PEN_WEIG(IARG)
        ENTRY GR_PEN_COLO(IARG)
        ENTRY GR_PEN_DEFA

POINTS [Size] [/BLANKING Bval Eval]
        SUBROUTINE GR_POIN(NARG,ARG1)
        SUBROUTINE GR_POIN_BLAN(NARG,ARG1,ARG2)

RULE [X] [Y] [/MAJOR [/MINOR]
        SUBROUTINE GR_RULE(NAME)                        ! 28-Sep-1986
        ENTRY GR_RULE_MAJO
        ENTRY GR_RULE_MINO

SET Something [Value1 [Value2]...]]]
        SUBROUTINE GR_SET(NAME,NARG,ARG1,ARG2,ARG3,ARG4) ! 28-Sep-1986

SHOW
        SUBROUTINE GR_SHOW(NAME)                        ! 28-Sep-1986

TICKSPACE SmallX BigX SmallY BigY                       ! 28-Sep-1986
        SUBROUTINE GR_TICK(NARG,ARG1,ARG2,ARG3,ARG4)

The following commands correspond to the GREG2$\backslash$ Language.

EXTREMA [/BLANKING Bval Eval] [/PLOT]
        SUBROUTINE GR_EXTR                              ! 28-Sep-1986
        ENTRY GR_EXTR_BLAN(NARG,ARG1,ARG2)
        ENTRY GR_EXTR_PLOT

LEVELS List
        SUBROUTINE GR_LEVE(NAME)
        Coding the list in the required format may be funny.
        Use GR4_LEVELS or GR8_LEVELS instead, they are more convenient.

RGDATA File_Name [/SUBSET IX1 IY1 IX2 IY2]
        SUBROUTINE GR_RGDA(NAME)                        ! 28-Sep-1986
        ENTRY GR_RGDA_SUBS(NARG,IARG1,IARG2,IARG3,IARG4)

RGMAP [/ABSOLUTE Value] [/PERCENT Value] [/KEEP] [/BLANKING Bval Eval]
        [/GREY Colour Ntry] [/PENS Pos Neg]
        SUBROUTINE GR_RGMA                              ! 28-Sep-1986
        ENTRY GR_RGMA_ABSO(ARG)
        ENTRY GR_RGMA_PERC(ARG)
        ENTRY GR_RGMA_BLAN(NARG,ARG1,ARG2)
        ENTRY GR_RGMA_KEEP
        ENTRY GR_RGMA_PENS(NARG,IARG1,IARG2)
        No support is yet given for option /GREY because it is still
        rather experimental.

Remember that if anything available in interactive seems to be missing in the previous list, you can always use GR_EXEC to access it.