voplansi.tar

vopl/004075500017730000310000000000000700277400400114615ustar00dghels00001250000004vopl/Makefile010070000017730000310000000037010700110677000131060ustar00dghels00001250000004#
# Makefile for vopl
#
# Usage: make os
#
# You might have to set:
#
#	OS
#	RANLIB
#	MCFLAGS
#	MCFLAGS
#	LIBS
#	F77
#	MFFLAGS
#
############################################################
#
# You can set -DBSD or -DSYS5 here
#
#OS = -DBSD
#OS = -DSYS5

# If you set -DSYS5 then set RANLIB = "ar ts" or "echo"
RANLIB = ranlib

#
# Global CFLAGS can be set here. These are the ones we use on a sun.
#
# NOTE: change the -L bit or put libvogle.a 
# where the linker can find them....
WHERELIBS = -L/tmp -I/tmp
#

# Specify the default VOGLE device for gpp here.
#
DEFDEV = -DX11

MCFLAGS = -g $(OS) $(WHERELIBS)
#MCFLAGS = $(OS) -O $(WHERELIBS)
#MCFLAGS = $(OS) -O4 -fsingle -f68881 /usr/lib/libm.il
#
# Or on an apollo... (-Wp make it use the 'other cpp')
#MCFLAGS = $(OS) -O -Wp -M3000

#
# If we have fortran we have to say so.
#
F77 = xlf -qextname
# Global FFLAGS can be set here. These are the ones we use on a sun.
#
MFFLAGS = $(OS) -g $(WHERELIBS)
#MFFLAGS = $(OS) -O 

#
# The name of the library to install and where to put it.
#
LIB = libvopl.a
DEST = /usr/lib

#
# Any other libraries that are needed go here
#

SUNLIBS = -lsuntool -lsunwindow -lpixrect -lX11
X11LIBS = -L/usr/X11/lib -lX11
UNIXLIBS = 
APOLLOLIBS =

LIBS = -lvogle $(X11LIBS)


all:
	cd src; make -f Makefile \
			RANLIB="$(RANLIB)" \
			MCFLAGS="$(MCFLAGS)"

	if test -n "$(F77)" ; \
	then 	cd examples; \
		make -f Makefile.f77 \
			MFFLAGS="$(MFFLAGS)" \
			F77="$(F77)" \
			LIBS="$(LIBS)"; \
	fi; exit 0

	cd examples; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			LIBS="$(LIBS)"

	cd gpp; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			DEFDEV="$(DEFDEV)" \
			LIBS="$(LIBS)"

clean:
	cd src; make clean
	cd examples; make clean
	cd examples; make -f Makefile.f77 clean
	cd gpp; make clean

clobber:
	cd src; make clobber
	cd examples; make clobber
	cd examples; make -f Makefile.f77 clobber
	cd gpp; make clobber

install:
	cp src/$(LIB) $(DEST)
	chmod 644 $(DEST)/$(LIB)
	$(RANLIB) $(DEST)/$(LIB)
vopl/README010070000017730000310000000020170700277400300123260ustar00dghels00001250000004
The directories in this directory contain the source for the VOPL library,
and the graph plotting program gpp.

They are as follows:

	docs		contains the documentation such as there is.

	examples	some C and FORTRAN example programs.

	gpp		contains the source for the plotting program gpp.

	src		contains the source for the VOPL library and the
			source for the FORTRAN interfaces.

VOPL is a library of routines for doing fits and graph plots written using
the VOGLE graphics library. We are still developing VOPL so constructive 
comments and Beer are always welcome.

We wish to thank Felix Huber for contributing the histogram code.

This software is public domain and may be used for any purpose commercial or
otherwise. It is offered without any guarantee as to its suitability for any
purpose or as to the sanity of its writers. We do ask that the source is 
passed on to anyone that requests a copy.

As Godzilla once said,

			"Gad, what food these mortals are."

Regards,

	Eric H. Echidna

Email to 

	echidna@wumpus.com.au
vopl/build.bat010070000017730000310000000004060451256560400132450ustar00dghels00001250000004echo off
if "%1" == "" goto err
cd src
echo Making VOPL library
make F=%1 makefile.msc
cd ..\examples
echo Making C examples
make F=%1 makefile.msc
cd ..\gpp
echo Making the GPP program
make F=%1 makefile.msc
goto end
:err
echo "usage: build -FPc | -FPi87"
:end
vopl/buildtc.bat010070000017730000310000000002560451256560400135770ustar00dghels00001250000004echo off
cd src
echo Making VOPL library
make -fmakefile.tc
cd ..\examples
echo Making C examples
make -fmakefile.tc
cd ..\gpp
echo Making the GPP program
make -fmakefile.tc
vopl/clean.bat010070000017730000310000000003140451256560500132270ustar00dghels00001250000004del src\*.obj
del src\*.lib
del src\*.map
del src\msfort\*.asm
del src\msfort\*.exe
del src\msfort\*.obj
del examples\*.obj
del examples\*.exe
del examples\*.map
del gpp\*.obj
del gpp\*.exe
del gpp\*.map
vopl/cpfd.bat010070000017730000310000000005160451257113400130570ustar00dghels00001250000004echo off
echo Making directories
md %1\vopl
md %1\vopl\src
md %1\vopl\src\msfort
md %1\vopl\src\sunfort
md %1\vopl\examples
md %1\vopl\gpp
echo Copying
copy *.* %1\vopl
copy src\*.* %1\vopl\src
copy src\msfort\*.* %1\vopl\src\msfort
copy src\sunfort\*.* %1\vopl\src\sunfort
copy examples\*.* %1\vopl\examples
copy gpp\*.* %1\vopl\gpp
vopl/docs/004075500017730000310000000000000700226532600124135ustar00dghels00001250000004vopl/docs/vopl.3010070000017730000310000000133110700226526500134460ustar00dghels00001250000004.TH VOPL 3  "07 October 1993" "VOPL 1.2"
.UC 4
.SH NAME
VOPL \- A very ordinary plotting library.

.SH DESCRIPTION
.LP
.I VOPL
is a library of C routines for doing graph plots. It handles histograms and
 a variety
of fits and scalings, together with providing defaults for positioning graph
titles, axis titles, and labels. 
.I VOPL
may be called from C or FORTRAN.
.TP
.I adjustscale(points, number, axis)
Adjust the auto scaling on axis axis for the points in points.
.nf
                
	Fortran:
		subroutine adjustscale(points, number, axis)
		real points(number)
		integer number
		character *1 axis

	C:    
		adjustscale(points, number, axis)
			float	points[];
			int	number;
			char	axis;

.fi
.TP
.I range(min, max, axis)
Specify the range min to max for the axis axis.
.nf

	Fortran:
		subroutine range(min, max, axis)
		real min, max
		character *1 axis

	C:
		range(min, max, axis)
			float	min, max;
			char	axis;

.fi
.TP
.I graphtitle(title)
Specify the title for the graph.
.nf

	Fortran:
		subroutine graphtitle(title)
		character*(*) title

	C:
		graphtitle(title)
			char	*title;

.fi
.TP
.I drawtitle()
Draw the graph title. Note: this is done by drawaxes2, and drawaxes.
.nf

	Fortran:
		subroutine drawtitle()

	C:
		drawtitle()

.fi
.TP
.I axistitle(title, axis)
Specify the title for the axis axis.
.nf

	Fortran:
		subroutine axistitle(title, axis)
		character*(*) title
		character *1 axis

	C:
		axistitle(title, axis)
			char	*title, axis;

.fi
.TP
.I hist2(x, y, n)
Display the 2-d histogram described by
d. D
is an array of <ng> groups with <ns> species in each group. Names
is an array with name for each group.
.nf

	Fortran:
		subroutine hist2(d, ng, ns, names)
		real d(ns, ng)
		integer ng
		integer ns
		character*(*) names

	C:
		hist2(d, ng, ns, names)
			float	*d;
			int	ng;
			int	ns;
			char	*names[];

.fi
.TP
.I histskip(h)
The h argument points to an array of integers. The array size should
be the same as the number of groups, and a non-zero value in an array
element will result in the group with the same number as the elemts index
being skipped during the plot.
.nf

	Fortran:
		subroutine histskip(h)
		integer h(*)

	C:
		histskip(h)
			int	*h;

.fi
.TP
.I plot2(x, y, n)
Plot the n points in the array x and y.
.nf

	Fortran:
		subroutine plot2(x, y, n)
		real x(n), y(n)
		integer n

	C:
		plot2(x, y, n)
			float	x[], y[];
			int	n;

.fi
.TP
.I fit(type)
Specify the fit type used to plot the data. Default straight line fit.
.nf

	Fortran:
		subroutine fit(type)
		integer type

	C:
		fit(type)
			int type;

	Current fit types are:
		
		0	- 	No lines at all.
		1	-	Straight line fit.
		2	-	Cubic spline fit.
		3	-	Least squares fit.
		4	-	Power equation fit.
		5	-	Saturated growth rate fit.

.fi
.TP
.I scaling(type, axis)
Specify the scaling type for axis axis. Default linear.
.nf

	Fortran:
		subroutine scaling(type, axis)
		integer type
		character *1 axis

	C:
		scaling(type, axis)
			int	type;
			char	axis;

.fi
	Current scaling types are 0 for
.IR linear
scaling, 1 for
.IR logarithmic
scaling.

.TP
.I endslopes(a, b)
Specify the endslopes for a cubic spline fit.
.nf

	Fortran:
		subroutine endslopes(a, b)
		real a, b

	C:
		endslopes(a, b)
			float	a, b;

.fi
.TP
.I degree(deg)
Specify the degree for the least-squares fit. Default 3.
.nf

	Fortran:
		subroutine degree(deg)
		integer deg

	C:
		degree(deg)
			int	deg;

.fi
.TP
.I gridspacing(n, axis)
Specify at what n'th tickmarks the grid should be drawn at. Default
zero (no grid).
.nf

	Fortran:
		subroutine gridspacing(n, axis)
		integer n
		character *1 axis

	C:
		gridspacing(n, axis)
			int	n;
			char	axis;

.fi
.TP
.I tickmarks(number, axis)
Specify the number of tickmarks on the axis axis.
.nf

	Fortran:
		subroutine tickmarks(number, axis)
		integer number
		character *1 axis

	C:
		tickmarks(number, axis)
			int	number;
			char	axis;

.fi
.TP
.I minorticks(number, axis)
Specify the number of minor tickmarks between the major ticks on the axis axis.
.nf

	Fortran:
		subroutine minorticks(number, axis)
		integer number
		character *1 axis

	C:
		minorticks(number, axis)
			int	number;
			char	axis;

.fi
.TP
.I drawaxis(axis)
Draw the axis given by axis.
.nf

	Fortran:
		subroutine drawaxis(axis)
		character *1 axis

	C:
		drawaxis(axis)
			char	*axis;

.fi
.TP
.I drawaxes()
Draw the x, y, and z axes.
.nf

	Fortran:
		subroutine drawaxes()

	C:
		drawaxes()

.fi
.TP
.I drawaxes2()
Draw the x and y axes.
.nf

	Fortran:
		subroutine drawaxes2()

	C:
		drawaxes2()

.fi
.TP
.I annotation(format, axis)
Specify the format for the labels at the tickmarks on the axis. If no
annotation is specified the default is used. An empty string turns
it off. 
.nf

	Fortran:
		subroutine annotation(format, axis)
		character*(*) format
		character *1 axis

	C:
		annotation(format, axis)
			char	*format, axis

.fi
.TP
.I graphprecision(number)
Specify the number of line segments making up a curve in the graph.
.nf

	Fortran:
		subroutine graphprecision(number)
		integer number

	C:
		graphprecision(number)
			int	number;

.fi
.TP
.I marker(string)
Specify the current marker string which will be drawn centered over data points.
.nf

	Fortran:
		subroutine marker(string)
		character*(*) string

	C:
		marker(string)
			char	*string;

.fi
.TP
.I markerspacing(num)
Specify the marker spacing. Default 1.
.nf

	Fortran:
		subroutine markerspacing(num)
		integer num

	C:
		markerspacing(num)
			int	num;

.fi
.TP
.I markerscale(scale)
Specify a scaling factor for the size of markers. Default 1.0.
.nf

	Fortran:
		subroutine markscale(x, y)
		real x, y

	C:
		markscale(x, y)
			float	x, y;

.nf
.SH SEE ALSO
.IR VOGLE(3), GPP(3)
.LP
.nf
.SH BUGS
.LP
The manual page isn't finished.
There isn't really any Z-axis stuff yet.
The Whole thing isn't finished and could stand a total recode.
vopl/docs/gpp.doc010070000017730000310000000100740506600150700136550ustar00dghels00001250000004


GPP(1)                   USER COMMANDS                     GPP(1)



NAME
     gpp - a program for plotting graphs

SYNOPSIS
     gpp [ -l<d> ] [ -s <s1> <s2> ] [ -r<fact> ] [ -S ] [ -P ]
     [ -G ] [ -c ] [ -m<n> ] [ -w<n> ] [ -g ] [ -p<n> ] [ -L ]
     [ -x xmin xmax ] [ -y ymin ymax ] [ -X ] [ -Y ]
     [ -f<fontname> ] [ -d<device> ] file or -


DESCRIPTION
     This program displays multiple  graphs  with  various  curve
     fitting  and axis options.  The following options are avail-
     able:


     -l<d>
          Perform a least square fit of degree "d" on each curve.


     -s <s1> <s2>
          Perform a cubic spline fit  on  each  curve,  with  end
          slopes s1 and s2 (Ie. a clamped spline)


     -r <fact>
          Reduce (if fact < 1.0) or enlarge (if fact >  1.0)  the
          entire plot.


     -S   Perform a cubic spline fit on each curve using a cardi-
          nal  spline  and the VOGLE(3) routine curve().  The end
          slopes are calculated  as  the  tangent  to  the  curve
          formed  by  the  lines  connecting the first and second
          points and the last and next to last points.


     -P   Perform a power equation fit on each curve.


     -G   Perform a saturated growth rate fit on each curve.


     -m<n>
          Place a marker at every "n"th data point on each curve.


     -g<n>
          Place a grid over the graph, with grid spacing of every
          nth tickmark.





VOGLE 1.0          Last change: 05 June. 1989                   1






GPP(1)                   USER COMMANDS                     GPP(1)



     -p<n>
          Draws only markers at every <n>th data point


     -L   Print legends if they are provided.


     -x xmin xmax
          Specify absolute x  scaling  values.  This  option  by-
          passes the auto-scaling of the x-axis values.


     -y ymin ymax
          Specify absolute y  scaling  values.  This  option  by-
          passes the auto-scaling of the y-axis values.


     -X   Draw the X-axis using a logarithmic scale.


     -Y   Draw the Y-axis using a logarithmic scale.


     -f<fontname>
          Use font name  fontname  where  fontname  is  any  font
          available in the VOGLE(3) library.


     -d<device>
          Use the output device "device". These are  the  devices
          compiled  into the VOGLE(3) library. Some examples are:
          postscript, hpgl, tek, sun etc.


     file The name of the input file. If it is a minus '-'  stdin
          is assumed.

     The input file contains two lines at the type which describe
     the  graph.  The  first line gives the title, and the second
     line the type. At the moment  the  only  type  supported  is
     "xy".  The  axes titles appropriate to the type of the graph
     are on the lines following the  type  statement.  After  the
     axes  titles  the first legend title is given followed by an
     axes descriptor on the next line.  gpp then reads in  points
     appropriate  to  the axes descriptor until it reaches a plot
     statement. This tells it to save the  current  points  as  a
     seperate  plot. It then looks for another legend followed by
     an axes statement, and  the  cycle  continues.  Legends  and
     titles may be blank lines.

          A title for the graph
          type xy



VOGLE 1.0          Last change: 05 June. 1989                   2






GPP(1)                   USER COMMANDS                     GPP(1)



          A title for the x-axis
          A title for the y-axis
          legend for the first plot
          axes xy
          x y
          x y
          . .
          . .
          plot xy
          legend for the second plot
          axes x
          x
          x
          .
          .
          plot xy


FILES
     /usr/local/lib/hershey/*      Font files.

SEE ALSO
     VOGLE(3), VOPL(3).

BUGS
     There are too many options.  There may be only  1024  points
     per  trace.   Interpretation  of  Endslopes for splines when
     using logarithmic scalings is Sketchy.



























VOGLE 1.0          Last change: 05 June. 1989                   3



d" on each curve.


     -s <s1> <s2>
          Perform a cubic spline fit  on  each  curve,  with  end
          slopes s1 and s2 (Ie. a clamped spline)


     -r <fact>
          Reduce (if fact < 1.0) or enlarge (if fact >  1.0)  the
          entire plot.


     -S   Perform a cubic spline fit on each curve using a cardi-
          nal  spline  and the VOGLE(3) routine curve().  The end
          slopes are calculated  as  the  tangent  to  thevopl/docs/vopl.doc010070000017730000310000000252540700226532500140570ustar00dghels00001250000004


VOPL(3)                                                   VOPL(3)


NAME
       VOPL - A very ordinary plotting library.


DESCRIPTION
       VOPL  is a library of C routines for doing graph plots. It
       handles histograms and
        a variety of fits and scalings, together  with  providing
       defaults  for  positioning  graph titles, axis titles, and
       labels.  VOPL may be called from C or FORTRAN.

       adjustscale(points, number, axis)
              Adjust the auto scaling on axis axis for the points
              in points.

                   Fortran:
                        subroutine adjustscale(points, number, axis)
                        real points(number)
                        integer number
                        character *1 axis

                   C:
                        adjustscale(points, number, axis)
                             float     points[];
                             int  number;
                             char axis;


       range(min, max, axis)
              Specify the range min to max for the axis axis.

                   Fortran:
                        subroutine range(min, max, axis)
                        real min, max
                        character *1 axis

                   C:
                        range(min, max, axis)
                             float     min, max;
                             char axis;


       graphtitle(title)
              Specify the title for the graph.

                   Fortran:
                        subroutine graphtitle(title)
                        character*(*) title

                   C:
                        graphtitle(title)
                             char *title;





VOPL 1.2                 07 October 1993                        1





VOPL(3)                                                   VOPL(3)


       drawtitle()
              Draw  the  graph  title.  Note:  this  is  done  by
              drawaxes2, and drawaxes.

                   Fortran:
                        subroutine drawtitle()

                   C:
                        drawtitle()


       axistitle(title, axis)
              Specify the title for the axis axis.

                   Fortran:
                        subroutine axistitle(title, axis)
                        character*(*) title
                        character *1 axis

                   C:
                        axistitle(title, axis)
                             char *title, axis;


       hist2(x, y, n)
              Display the 2-d histogram described by d. D  is  an
              array  of  <ng>  groups  with  <ns> species in each
              group. Names is an array with name for each  group.

                   Fortran:
                        subroutine hist2(d, ng, ns, names)
                        real d(ns, ng)
                        integer ng
                        integer ns
                        character*(*) names

                   C:
                        hist2(d, ng, ns, names)
                             float     *d;
                             int  ng;
                             int  ns;
                             char *names[];


       histskip(h)
              The  h argument points to an array of integers. The
              array size should be the  same  as  the  number  of
              groups,  and  a  non-zero value in an array element
              will result in the group with the  same  number  as
              the elemts index being skipped during the plot.

                   Fortran:
                        subroutine histskip(h)
                        integer h(*)



VOPL 1.2                 07 October 1993                        2





VOPL(3)                                                   VOPL(3)


                   C:
                        histskip(h)
                             int  *h;


       plot2(x, y, n)
              Plot the n points in the array x and y.

                   Fortran:
                        subroutine plot2(x, y, n)
                        real x(n), y(n)
                        integer n

                   C:
                        plot2(x, y, n)
                             float     x[], y[];
                             int  n;


       fit(type)
              Specify the fit type used to plot the data. Default
              straight line fit.

                   Fortran:
                        subroutine fit(type)
                        integer type

                   C:
                        fit(type)
                             int type;

                   Current fit types are:

                        0    -    No lines at all.
                        1    -    Straight line fit.
                        2    -    Cubic spline fit.
                        3    -    Least squares fit.
                        4    -    Power equation fit.
                        5    -    Saturated growth rate fit.


       scaling(type, axis)
              Specify the scaling type  for  axis  axis.  Default
              linear.

                   Fortran:
                        subroutine scaling(type, axis)
                        integer type
                        character *1 axis

                   C:
                        scaling(type, axis)
                             int  type;
                             char axis;



VOPL 1.2                 07 October 1993                        3





VOPL(3)                                                   VOPL(3)


                   Current  scaling  types are 0 for linear scal-
              ing, 1 for logarithmic scaling.


       endslopes(a, b)
              Specify the endslopes for a cubic spline fit.

                   Fortran:
                        subroutine endslopes(a, b)
                        real a, b

                   C:
                        endslopes(a, b)
                             float     a, b;


       degree(deg)
              Specify  the  degree  for  the  least-squares  fit.
              Default 3.

                   Fortran:
                        subroutine degree(deg)
                        integer deg

                   C:
                        degree(deg)
                             int  deg;


       gridspacing(n, axis)
              Specify  at  what n'th tickmarks the grid should be
              drawn at. Default zero (no grid).

                   Fortran:
                        subroutine gridspacing(n, axis)
                        integer n
                        character *1 axis

                   C:
                        gridspacing(n, axis)
                             int  n;
                             char axis;


       tickmarks(number, axis)
              Specify the number of tickmarks on the axis axis.

                   Fortran:
                        subroutine tickmarks(number, axis)
                        integer number
                        character *1 axis

                   C:
                        tickmarks(number, axis)



VOPL 1.2                 07 October 1993                        4





VOPL(3)                                                   VOPL(3)


                             int  number;
                             char axis;


       minorticks(number, axis)
              Specify the number of minor tickmarks  between  the
              major ticks on the axis axis.

                   Fortran:
                        subroutine minorticks(number, axis)
                        integer number
                        character *1 axis

                   C:
                        minorticks(number, axis)
                             int  number;
                             char axis;


       drawaxis(axis)
              Draw the axis given by axis.

                   Fortran:
                        subroutine drawaxis(axis)
                        character *1 axis

                   C:
                        drawaxis(axis)
                             char *axis;


       drawaxes()
              Draw the x, y, and z axes.

                   Fortran:
                        subroutine drawaxes()

                   C:
                        drawaxes()


       drawaxes2()
              Draw the x and y axes.

                   Fortran:
                        subroutine drawaxes2()

                   C:
                        drawaxes2()


       annotation(format, axis)
              Specify  the format for the labels at the tickmarks
              on the axis. If  no  annotation  is  specified  the



VOPL 1.2                 07 October 1993                        5





VOPL(3)                                                   VOPL(3)


              default is used. An empty string turns it off.

                   Fortran:
                        subroutine annotation(format, axis)
                        character*(*) format
                        character *1 axis

                   C:
                        annotation(format, axis)
                             char *format, axis


       graphprecision(number)
              Specify  the  number  of  line segments making up a
              curve in the graph.

                   Fortran:
                        subroutine graphprecision(number)
                        integer number

                   C:
                        graphprecision(number)
                             int  number;


       marker(string)
              Specify the current marker  string  which  will  be
              drawn centered over data points.

                   Fortran:
                        subroutine marker(string)
                        character*(*) string

                   C:
                        marker(string)
                             char *string;


       markerspacing(num)
              Specify the marker spacing. Default 1.

                   Fortran:
                        subroutine markerspacing(num)
                        integer num

                   C:
                        markerspacing(num)
                             int  num;


       markerscale(scale)
              Specify  a  scaling factor for the size of markers.
              Default 1.0.




VOPL 1.2                 07 October 1993                        6





VOPL(3)                                                   VOPL(3)


                   Fortran:
                        subroutine markscale(x, y)
                        real x, y

                   C:
                        markscale(x, y)
                             float     x, y;


SEE ALSO
       VOGLE(3),GPP(3)


BUGS
       The manual page isn't finished.  There isn't really any Z-
       axis  stuff yet.  The Whole thing isn't finished and could
       stand a total recode.








































VOPL 1.2                 07 October 1993                        7


rtran:
                        subroutine axistitle(title, axis)
                        character*(*) title
                        character *1 axis

                   C:
                        axistitle(title, axis)
                             char *title, axis;


       hist2(x, y, n)
              Display the 2-d histogram describvopl/docs/gpp.1010070000017730000310000000071750545511666300132740ustar00dghels00001250000004.TH GPP 1 "07 October. 1993" "VOPL 1.2"
.UC 4 
.SH NAME
gpp \- a program for plotting graphs
.SH SYNOPSIS
.B gpp
[
.B \-l<d>
] [
.B \-s <s1> <s2>
] [
.B \-r<fact>
] [
.B \-S
] [
.B \-P
]
.br
[
.B \-G
] [
.B \-c
] [
.B \-m<n>
] [
.B \-w<n>
] [
.B \-g
] [
.B \-p<n>
] [
.B \-L
]
.br
[
.B \-x xmin xmax
] [
.B \-y ymin ymax
] [
.B \-X
] [
.B \-Y
] [
.B \-Mx<n>
]
.br 
[
.B \-My<n>
] [
.B \-D
] [
.B \-f<fontname>
] [
.B \-d<device>
]
.B file or -

.SH DESCRIPTION
This program displays multiple graphs with various curve fitting
and axis options.
.\" Options mentioned in-line
The following options are available:

.TP
.B \-l<d>
Perform a least square fit of degree "d" on each curve.

.TP
.B \-s <s1> <s2>
Perform a cubic spline fit on each curve, with end 
.B slopes s1 and s2 
(Ie. a clamped spline)

.TP
.B \-r <fact>
Reduce (if fact < 1.0) or enlarge (if fact > 1.0) the entire plot.

.TP
.B \-S
Perform a cubic spline fit on each curve using a cardinal
spline and the 
.IR VOGLE(3) 
routine curve().
The end slopes are calculated as the tangent to the curve
formed by the lines connecting the first and second points
and the last and next to last points.

.TP
.B \-P
Perform a power equation fit on each curve.

.TP
.B \-G
Perform a saturated growth rate fit on each curve.

.TP
.B \-m<n>
Place a marker at every "n"th data point on each curve.

.TP
.B \-g<n>
Place a grid over the graph, with grid spacing of every nth tickmark.

.TP
.B \-p<n>
Draws only markers at every <n>th data point

.TP
.B \-L
Print legends if they are provided.

.TP
.B "\-x xmin xmax"
Specify absolute x scaling values. This option by-passes the
auto-scaling of the x-axis values.

.TP
.B "\-y ymin ymax"
Specify absolute y scaling values. This option by-passes the
auto-scaling of the y-axis values.

.TP
.B \-X
Draw the X-axis using a 
.IR logarithmic
scale.

.TP
.B \-Y
Draw the Y-axis using a 
.IR logarithmic
scale.

.TP
.B \-Mx<n>
Sets the number of minor tickmarks between (and including) major tickmarks 
along the X axis.

.TP
.B \-My<n>
Sets the number of minor tickmarks between (and including) major tickmarks 
along the Y axis.

.TP
.B \-D
Each trace is drawn with a different linestyle (up to seven linestyles are
available).

.TP
.B \-f<fontname>
Use font name fontname where fontname is any font available in the
.IR VOGLE(3)
library.

.TP
.B \-d<device>
Use the output device "device". These are the devices compiled
into the
.IR VOGLE(3)
library. Some examples are: postscript, hpgl, tek, sun etc.

.TP
.B file
The name of the input file. If it is a minus '-' stdin is assumed.
.LP
The input file contains two lines at the
type which describe the graph. The first line gives the title, and
the second line the type. At the moment the only type supported is
"xy". The axes titles appropriate to the type of the graph are on the
lines following the type statement. After the axes titles the first
legend title is given followed by an axes descriptor on the next line.
gpp then reads in points appropriate to the axes descriptor until it
reaches a plot statement. This tells it to save the current points as a
seperate plot. It then looks for another legend followed by an axes
statement, and the cycle continues. Legends and titles may be blank
lines.
.nf

	A title for the graph
	type xy
	A title for the x-axis
	A title for the y-axis
	legend for the first plot
	axes xy
	x y
	x y 
	. .
	. .
	plot xy
	legend for the second plot
	axes x
	x
	x
	. 
	.
	plot xy

.SH FILES
/usr/local/lib/hershey/* 	Font files.
.SH SEE ALSO
.IR VOGLE(3),
.IR VOPL(3).
.SH BUGS
There are too many options.
There may be only 1024 points per trace.
Interpretation of Endslopes for splines when using logarithmic
scalings is Sketchy.

vopl/examples/004075500017730000310000000000000700226534500133025ustar00dghels00001250000004vopl/examples/makefile.tc010070000017730000310000000007230700225044700153740ustar00dghels00001250000004#
TESTS = cex1.exe cex2.exe cex3.exe

LIB = ..\src\vopl.lib
CFLAGS = -ml -I..\src -DPC

all: $(TESTS)

.c.obj:
	tcc  -c $(CFLAGS) $<

.obj.exe:
	tcc $(CFLAGS) $*.obj $(LIB) vogle.lib

cex1.exe: $(LIB) cex1.obj
	tcc $(CFLAGS) cex1.obj $(LIB) vogle.lib

cex2.exe: $(LIB) cex2.obj
	tcc $(CFLAGS) cex2.obj $(LIB) vogle.lib

cex3.exe: $(LIB) cex3.obj
	tcc $(CFLAGS) cex3.obj $(LIB) vogle.lib

histdemo.exe: $(LIB) histdemo.obj
	tcc $(CFLAGS) histdemo.obj $(LIB) vogle.lib
vopl/examples/cex2.c010070000017730000310000000037530700207470300143010ustar00dghels00001250000004#include <stdio.h>
#include <math.h>
#include "vopl.h"

#define	PI	3.14159265358979
#define	N	300

float	x[N], y[N];

/*
 *	Another very simple test program for vopl.
 *
 * 	This one also draws a graph of y = sin(x) 0 <= x <= 2 * PI
 *	but shows some of the axis and range setting stuff
 */
main()
{
	int	i;
	char	device[30];
	float	t, dt;

/*
 *	Get VOGLE device
 */
	printf("Enter VOGLE device: ");
	gets(device);

/*
 *	Generate the points
 */
	t = 0.0;
	dt = 2 * PI / N;

	for (i = 0; i != N; i++) {
		x[i] = t;
		y[i] = sin(t);
		t = t + dt;
	}

/*
 *	Set the X-scaling to be absolute 0 - 10 (ie no auto-scaling)
 */
	range(0.0, 10.0, 'x');
/*
 *	Autoscale the Y-axis
 */
	adjustscale(y, N, 'y');
/*
 *	Anyone for some axis titles?
 */
	axistitle("This one's for you", 'x');
	axistitle("This one's for me", 'y');
/*
 *	As we are now about to do some graphics we initialise VOGLE
 *	and clear to BLACK
 */
	vinit(device);
	color(0);
	clear();
/*
 *	Now set the color to GREEN
 */
	color(2);

/*
 *	Draw the default set of axes (in GREEN)
 */
	drawaxes2();
/*
 *	Set color to RED
 */
	color(1);
/*
 *	Draw the Graph
 */
	plot2(x, y, N);
/*
 *	Wait around a bit
 */
	getkey();
/*
 *	Now draw a little one in the top right hand corner
 *	by reseting the VOGLE viewport.
 */
	viewport(0.0, 1.0, 0.0, 1.0);
/*
 *	Draw it again, but do the plot first (in BLUE) then the axes
 *	(in YELLOW)
 */
	color(4);
	plot2(x, y, N);
	color(3);
	drawaxes2();
/*
 *	Hang around again
 */
	getkey();
/*
 *	Clear it all away
 */
	color(0);
	clear();
/*
 *	Reset the viewport to be a "long skinny one"
 */
	viewport(-1.0, 1.0, -0.5, 0.5);
/*
 *	Autoscale the X-axis again by first setting a ridicuous scale with
 *	range that adjustscale will change.
 */
	range(1000.0, -1000.0, 'x');
	adjustscale(x, N, 'x');
/*
 *	Change the X-axis title
 */
	axistitle("Blark Bonk Bloot", 'x');
/*
 *	And draw it all again...
 */
	color(5);
	drawaxes2();
	color(6);
	plot2(x, y, N);
/*
 *	Hang around again
 */
	getkey();
/*
 *	Bugger off...
 */

	vexit();
}
raw the default set ovopl/examples/fex2.f010070000017730000310000000037030451233437600143120ustar00dghels00001250000004c
c	Another very simple test program for vopl.
c
c 	This one also draws a graph of y = sin(x) 0 <= x <= 2*pi
c	but shows some of the axis and range setting stuff
c
	program test1
	parameter (pi = 3.14159265358979)
	parameter (n = 300)

	real x(n), y(n)

	character device*30
c
c	Get VOGLE device
c
	write(*,'(a,$)') 'Enter VOGLE device: '
	read(*,'(a)') device

c
c	Generate the points
c
	t = 0.0
	dt = 2 * pi / n

	do 10 i = 1, n
		x(i) = t
		y(i) = sin(t)
		t = t + dt
10	continue

c
c	Set the X-scaling to be absolute 0 - 10 (ie no auto-scaling)
c
	call range(0.0, 10.0, 'x')
c
c	Autoscale the Y-axis
c
	call adjustscale(y, n, 'y')
c
c	Anyone for some axis titles?
c
	call axistitle('This one''s for you', 'x')
	call axistitle('This one''s for me', 'y')
c
c	As we are now about to do some graphics we initialise VOGLE
c	and clear to BLACK
c
	call vinit(device)
	call color(0)
	call clear
c
c	Now set the color to GREEN
c
	call color(2)

c
c	Draw the default set of axes (in GREEN)
c
	call drawaxes2
c
c	Set color to RED
c
	call color(1)
c
c	Draw the Graph
c
	call plot2(x, y, n)
c
c	Wait around a bit
c
	call getkey
c
c	Now draw a little one in the top right hand corner
c	by reseting the VOGLE viewport.
c
	call viewport(0.0, 1.0, 0.0, 1.0)
c
c	Draw it again, but do the plot first (in BLUE) then the axes
c	(in YELLOW)
c
	call color(4)
	call plot2(x, y, n)
	call color(3)
	call drawaxes2
c
c	Hang around again
c
	call getkey
c
c	Clear it all away
c
	call color(0)
	call clear
c
c	Reset the viewport to be a "long skinny one"
c
	call viewport(-1.0, 1.0, -0.5, 0.5)
c
c	Autoscale the X-axis again by first setting a ridicuous scale with
c	range that adjustscale will change.
c
	call range(1000.0, -1000.0, 'x')
	call adjustscale(x, n, 'x')
c
c	Change the X-axis title
c
	call axistitle('Blark Bonk Bloot', 'x')
c
c	And draw it all again...
c
	call color(5)
	call drawaxes2
	call color(6)
	call plot2(x, y, n)
c
c	Hang around again
c
	call getkey
c
c	Bugger off...
c

	call vexit
	end
vopl/examples/cex3.c010070000017730000310000000034770700207474100143070ustar00dghels00001250000004#include <stdio.h>
#include <math.h>
#include "vopl.h"

#define	N	10

/*
 *	Another simple test program for vopl.
 *
 * 	This one tries to show the various "fit" options
 */
main()
{
	char		device[30];
	static float	x[N] = {
			1.0, 2.0, 3.0, 6.0,
			17.0, 19.0, 23.0, 45.0,
			50.0, 56.0
	};
	static float	y[N] = {
			1.0, 3.0, 5.0, 9.0,
			17.0, 45.0, 23.0, 99.0,
			50.0, 20.0
	};

/*
 *	Get VOGLE device
 */
	printf("Enter VOGLE device: ");
	gets(device);

/*
 *	First we'll do a linear least square fit.
 */
	fit(2);
	degree(1);
/*
 *	Adjust the scaling according to x and y arrays
 */
	adjustscale(x, N, 'x');
	adjustscale(y, N, 'y');
/*
 *	Give it a title
 */
	graphtitle("Linear Least square fit");
/*
 *	As we are now about to do some graphics we initialise VOGLE
 *	and clear to BLACK
 */
	vinit(device);
	color(0);
	clear();
/*
 *	Draw the title in CYAN
 */
	color(6);
	drawtitle();
/*
 *	Now set the color to GREEN
 */
	color(2);

/*
 *	Draw the default set of axes (in GREEN)
 */
	drawaxes2();
/*
 *	Set color to RED
 */
	color(1);
/*
 *	Change to the "markers" font and set the current marker string
 */
	font("markers");
	marker("a");
/*
 *	Draw the Graph
 */
	plot2(x, y, N);
/*
 *	Wait around a bit
 */
	getkey();
/*
 *	Now we'll do a second order fit.
 */
	degree(2);
	graphtitle("Second order least square fit");

	color(0);
	clear();

	color(7);
	plot2(x, y, N);
/*
 *	Change back to the "text" type font to draw the title and axes
 */
	font("futura.m");

	color(3);
	drawaxes2();

	color(6);
	drawtitle();
/*
 * 	Wait a bit
 */
	getkey();
/*
 *	Now do a Cubic spline fit (cardinal spline for this one)
 */
	fit(3);
	
	color(0);
	clear();

	color(5);
	drawaxes2();

	graphtitle("Cardinal Cubic Spline Fit");
	color(6);
	drawtitle();

/*
 *	Note, we haven't changed to the Marker font here
 */
	plot2(x, y, N);

	getkey();

	vexit();
}
vopl/examples/f_2_for.bat010070000017730000310000000002500451256601100152660ustar00dghels00001250000004echo off
if not exist fex1.f goto 1
rename fex1.f fex1.for
:1
if not exist fex2.f goto 2
rename fex2.f fex2.for
:2
if not exist fex3.f goto 3
rename fex3.f fex3.for
:3
vopl/examples/fex1.f010070000017730000310000000023320451233437600143060ustar00dghels00001250000004c
c	A very simple test program for vopl.
c
c 	This one draws a graph of y = sin(x) 0 <= x <= 2*pi
c
	program test1
	parameter (pi = 3.14159265358979)
	parameter (n = 300)

	real x(n), y(n)

	character device*30
c
c	Get VOGLE device
c
	write(*,'(a,$)') 'Enter VOGLE device: '
	read(*,'(a)') device

c
c	Generate the points
c
	t = 0.0
	dt = 2 * pi / n

	do 10 i = 1, n
		x(i) = t
		y(i) = sin(t)
		t = t + dt
10	continue

c
c	Adjust the scaling according to x and y arrays
c
	call adjustscale(x, n, 'x')
	call adjustscale(y, n, 'y')
c
c	As we are now about to do some graphics we initialise VOGLE
c	and clear to BLACK
c
	call vinit(device)
	call color(0)
	call clear
c
c	Now set the color to GREEN
c
	call color(2)

c
c	Draw the default set of axes (in GREEN)
c
	call drawaxes2
c
c	Set color to RED
c
	call color(1)
c
c	Draw the Graph
c
	call plot2(x, y, n)
c
c	Wait around a bit
c
	call getkey
c
c	Now draw a little one in the top right hand corner
c	by reseting the VOGLE viewport.
c
	call viewport(0.0, 1.0, 0.0, 1.0)
c
c	Draw it again, but do the plot first (in BLUE) then the axes
c	(in YELLOW)
c
	call color(4)
	call plot2(x, y, n)
	call color(3)
	call drawaxes2
c
c	Hang around again
c
	call getkey
c
c	Bugger off...
c

	call vexit
	end
vopl/examples/makefile.msc010070000017730000310000000004570700225042600155510ustar00dghels00001250000004F = -FPc

CFLAGS = -AL $(F) -I..\..\vogle\src

.c.obj:
	cl -c $(CFLAGS) $*.c

.obj.exe:
	link /NOE $*.obj,,,..\src\vopl.lib vogle.lib;

cex1.obj: cex1.c

cex1.exe: cex1.obj

cex2.obj: cex2.c

cex2.exe: cex2.obj

cex3.obj: cex3.c

cex3.exe: cex3.obj

histdemo.obj: histdemo.c

histdemo.exe: histdemo.obj
vopl/examples/fex3.f010070000017730000310000000035010451233437600143070ustar00dghels00001250000004c
c	Another simple test program for vopl.
c
c 	This one tries to show the various "fit" options
c
	program test3
	parameter (n = 10)

	real x(n), y(n)

	character device*30
	
	data x/1.0, 2.0, 3.0, 6.0, 17.0, 19.0, 23.0, 45.0, 50.0, 56.0/
	data y/1.0, 3.0, 5.0, 9.0, 17.0, 45.0, 23.0, 99.0, 50.0, 20.0/
c
c	Get VOGLE device
c
	write(*,'(a,$)') 'Enter VOGLE device: '
	read(*,'(a)') device

c
c	First we'll do a linear least square fit.
c
	call fit(2)
	call degree(1)
c
c	Adjust the scaling according to x and y arrays
c
	call adjustscale(x, n, 'x')
	call adjustscale(y, n, 'y')
c
c	Give it a title
c
	call graphtitle('Linear Least square fit')
c
c	As we are now about to do some graphics we initialise VOGLE
c	and clear to BLACK
c
	call vinit(device)
	call color(0)
	call clear
c
c	Draw the title in CYAN
c
	call color(6)
	call drawtitle
c
c	Now set the color to GREEN
c
	call color(2)

c
c	Draw the default set of axes (in GREEN)
c
	call drawaxes2
c
c	Set color to RED
c
	call color(1)
c
c	Change to the "markers" font and set the current marker string
c
	call font('markers')
	call marker('a')
c
c	Draw the Graph
c
	call plot2(x, y, n)
c
c	Wait around a bit
c
	call getkey
c
c	Now we'll do a second order fit.
c
	call degree(2)
	call graphtitle('Second order least square fit')

	call color(0)
	call clear

	call color(7)
	call plot2(x, y, n)
c
c	Change back to the "text" type font to draw the title and axes
c
	call font('futura.m')

	call color(3)
	call drawaxes2

	call color(6)
	call drawtitle
c
c 	Wait a bit
c
	call getkey
c
c	Now do a Cubic spline fit (cardinal spline for this one)
c
	call fit(3)
	
	call color(0)
	call clear

	call color(5)
	call drawaxes2

	call graphtitle('Cardinal Cubic Spline Fit')
	call color(6)
	call drawtitle

c
c	Note, we haven't changed to the Marker font here
c
	call plot2(x, y, n)
c
	call getkey

	call vexit
	end
vopl/examples/cex1.c010070000017730000310000000024140700207473400142750ustar00dghels00001250000004#include <stdio.h>
#include <math.h>
#include "vopl.h"

#define PI	3.14159265358979
#define	N	300

float	x[N], y[N];

/*
 *	A very simple test program for vopl.
 *
 * 	This one draws a graph of y = sin(x) 0 <= x <= 2 * PI
 */
main()
{
	float	t, dt;
	char	device[30];
	int	i;

/*
 *	Get VOGLE device
 */
	printf("Enter VOGLE device: ");
	gets(device);

/*
 *	Generate the points
 */
	t = 0.0;
	dt = 2 * PI / N;

	for (i = 0; i != N; i++) {
		x[i] = t;
		y[i] = sin(t);
		t = t + dt;
	}

/*
 *	Adjust the scaling according to x and y arrays
 */
	adjustscale(x, N, 'x');
	adjustscale(y, N, 'y');
/*
 *	As we are now about to do some graphics we initialise VOGLE
 *	and clear to BLACK
 */
	vinit(device);
	color(0);
	clear();
/*
 *	Now set the color to GREEN
 */
	color(2);

/*
 *	Draw the default set of axes (in GREEN)
 */
	drawaxes2();
/*
 *	Set color to RED
 */
	color(1);
/*
 *	Draw the Graph
 */
	plot2(x, y, N);
/*
 *	Wait around a bit
 */
	getkey();
/*
 *	Now draw a little one in the top right hand corner
 *	by reseting the VOGLE viewport.
 */
	viewport(0.0, 1.0, 0.0, 1.0);
/*
 *	Draw it again, but do the plot first (in BLUE) then the axes
 *	(in YELLOW)
 */
	color(4);
	plot2(x, y, N);
	color(3);
	drawaxes2();
/*
 *	Hang around again
 */
	getkey();
/*
 * bugger off
 */
	vexit();
}
vopl/examples/fmakefil.msc010070000017730000310000000003660451256601100155540ustar00dghels00001250000004F = -FPc

FFLAGS = -AL -4Nt $(F)

.for.obj:
	fl -c $(FFLAGS) $*.for

.obj.exe:
	link /NOE $*.obj,,,..\src\vopl.lib vogle.lib;

fex1.obj: fex1.for

fex1.exe: fex1.obj

fex2.obj: fex2.for

fex2.exe: fex2.obj

fex3.obj: fex3.for

fex3.exe: fex3.obj
vopl/examples/Makefile010070000017730000310000000010370700225055400147250ustar00dghels00001250000004TESTS = cex1 cex2 cex3 histdemo

LIB	= ../src/libvopl.a 
LIBS	= -lvogle -lX11

SRC = cex1.c cex2.c cex3.c histdemo.c

OBJS = cex1.o cex2.o cex3.o histdemo.o

MCFLAGS = -g

CFLAGS = -I../src $(MCFLAGS)

all: $(TESTS)

cex1: cex1.o $(LIB)
	cc -o $@ $@.o $(LIB) $(CFLAGS) $(LIBS) -lm

cex2: cex2.o $(LIB)
	cc -o $@ $@.o $(LIB) $(CFLAGS) $(LIBS) -lm

cex3: cex3.o $(LIB)
	cc -o $@ $@.o $(LIB) $(CFLAGS) $(LIBS) -lm

histdemo: histdemo.o $(LIB)
	cc -o $@ $@.o $(LIB) $(CFLAGS) $(LIBS) -lm

clean:
	rm -f *.o core

clobber:
	rm -f $(TESTS) *.o core
vopl/examples/Makefile.f77010070000017730000310000000007350547725652400153540ustar00dghels00001250000004TESTS = fex1 fex2 fex3

LIB	= ../src/libvopl.a 
LIBS	= -lvogle -lX11

FSRC = fex1.f fex2.f fex3.f

FOBJS = fex1.o fex2.o fex3.o

MFFLAGS = -g

FFLAGS = $(MFFLAGS)

.f.o:
	$(F77) $(FFLAGS) -c $*.f

all: $(TESTS)

fex1: fex1.o $(LIB)
	$(F77) $(FFLAGS) -o $@ $@.o $(LIB) $(LIBS) -lm

fex2: fex2.o $(LIB)
	$(F77) $(FFLAGS) -o $@ $@.o $(LIB) $(LIBS) -lm

fex3: fex3.o $(LIB)
	$(F77) $(FFLAGS) -o $@ $@.o $(LIB) $(LIBS) -lm

clean:
	rm -f *.o core

clobber:
	rm -f $(TESTS) *.o core
vopl/examples/histdemo.c010064400017730000310000000064230700225632200152570ustar00dghels00001250000004#include <stdio.h>
#include <string.h>
#include <vogle.h>
#include <vopl.h>

#define SPEC 5
#define GROUPS 8

char * names[GROUPS]= {
   "Name1", "Name2", "Name3", "Name4", "Name5", "Name6",
   "Name7", "Name8"
};
char * lnames[SPEC]= {
   "leg1", "leg2", "leg3", "leg4", "leg5"
};
char *title= {"Title"};

float hgt[GROUPS][SPEC]= {
     {	  8.648978 ,
	  8.821889 ,
	  4.645878 ,
	  8.531050 ,
	  9.036387
     } , {	  
	  8.170376 ,
	  8.999420 ,
	 10.740744 ,
	  6.942840 ,
	  6.663000
     } , {	  
	  9.782000 ,
	  8.204000 ,
	  10.16300 ,
	  12.86800 ,
	  10.62200
     } , {	  
	  9.364000 ,
	  12.08700 ,
	 11.972000 ,
	  2.663000 ,
	  4.782000
     } , {	  
	  8.999999 ,
	  4.204000 ,
	  1.86800 ,
	  0.62200 ,
	  3.364000
     } , {	  
	  5.08700 ,
	  7.972000 ,
	  3.833330 ,
     	  8.648978 ,
	  8.821889
     } , {	  
	  4.645878 ,
	  8.531050 ,
	  9.036387 ,
	  8.170376 ,
	  8.999420
     } , {	  
	 10.740744 ,
	  6.942840 ,
	  6.663000 ,
	  9.999999 ,
	  8.204000 
     }
};
float m0[SPEC]= {
      	  450.0000 ,
	  440.0000 ,
	  430.0000 ,
	  420.0000 ,
	  410.0000 ,
	};
float ms[SPEC]= {
      	  250.0000 ,
	  240.0000 ,
	  230.0000 ,
	  220.0000 ,
	  210.0000 ,
	};
float mn[SPEC]= {
      	  45.00000 ,
	  44.00000 ,
	  43.00000 ,
	  42.00000 ,
	  41.00000 ,
	};

void drawlegend( int ns, char *lnames[], char *title);
	
main()
{
  char device[20], strval[20], str[20], scalefact[20];
  float scale, width, heigh;
  float x0, y0, dy;
  int i;

/*
 *	Get VOGLE device
*/
  fprintf(stderr, "Enter VOGLE device: <X11>: [Rtn]");
  gets(device);
  if (strcmp(device,"") <= 0) {
    strcpy(device, "X11");
  }

  /*
   * Make a little bit room for the legend 
   */
  scale = .80;

  prefsize(768, 512);
  vinit(device);

  getfontsize(&width,&heigh);
  color(0);
  clear();
  color(7);

/* Clipping off */
  clipping(0);

  viewport(-scale,scale,-.90*scale,.90*scale);

  polyfill(1);

  /*
   * Draw the histogram
   */
  hist2(hgt, GROUPS, SPEC, names);

  /*
   * Plot the standard axes
   */
  axistitle("Y Axis",'y');     
  drawaxes2();
 
  /*
   * Adjust the scale for secondary y axis manually
   */
/*  adjustscale(hgt, GROUPS*SPEC, 't'); */
  axistitle("Sec. X Axis",'s');
  axistitle("Sec. Y Axis",'t');
  scaling(1,'s');
  scaling(1,'t');
  range((float)1.,(float)100000.,'t');
  range((float)0.00001,(float)1.,'s');
  drawaxis('s'); 
  drawaxis('t'); 

  /*
   * create a legend
   */
  drawlegend(SPEC, lnames, title); 

  getkey();

  vexit();

}

	
void drawlegend( int ns, char *lnames[], char *title)
{
  float	width, heigh, dy, dy2, x0, dx0, y0;
  int i, j;
	
  pushattributes();
  pushmatrix();
  pushviewport();

  getfontsize(&width,&heigh);
  ortho2(-1.0, 1.0, -1.0, 1.0);
  
  clipping(0);

  dy = (YMAX- YMIN)/25.0;
  dy2= dy/2.5;
  polyfill(1);
  x0=XMAX+0.20;
  dx0 = 0.05;
  y0 =YMIN-0.1;
  textsize(0.9*width,0.9*heigh); 
  leftjustify();
  bottomjustify();
  for (i=0 ; i<ns; i++) {
    j = ns-1-i;
    color(j%6+1);
    rect(x0,y0 +i*dy,x0+dx0,y0 +i*dy+dy2);
    move2(x0+1.5*dx0, y0 +i*dy);
    color(7);
    drawstr(lnames[j]);
  }  
  
  textsize(1.0*width,1.0*heigh); 
  move2(x0,y0 +ns*dy);
  drawstr("Legende");

/* draw the title */
  centertext(1);
  textsize(1.20*width,1.20*heigh); 
  move2(0.10, YMAX + 0.1);
  drawstr(title);
  
  popviewport();
  popmatrix();
  popattributes();
}

vopl/fbuild.bat010070000017730000310000000005340451256560500134160ustar00dghels00001250000004echo off
if "%1" == "" goto err
echo Making FORTRAN interfaces
cd src\msfort
make F=%1 makefile.msc
cd ..
echo Making VOPL library
make F=%1 fmakefil.msc
cd ..\examples
echo Making VOPL examples
command /c f_2_for
make F=%1 fmakefil.msc
cd ..\gpp
echo Making GPP program
make F=%1 makefile.msc
goto end
:err
echo "usage: fbuild -FPc | -FPi87"
:end
vopl/gpp/004075500017730000310000000000000700226534600122535ustar00dghels00001250000004vopl/gpp/data3010070000017730000310000000002250450334213300131500ustar00dghels00001250000004A least squares straight line fit
type xy
the x-axis
the y-axis
x vs y1
axes xy
5 17 
10 25
15 30 
20 33
25 36
30 38
35 39
40 40
45 41
50 42
plot xy
vopl/gpp/gpp.c010070000017730000310000000024230700206652000131650ustar00dghels00001250000004/*
 *   gpp
 *  
 *   Graph plotting programme. 
 *
 */
#include "vogle.h"
#include "gpp.h"

char	*styles[] = {
	"1100",
	"11110",
	"11010",
	"10",
	"10010",
	"10110",
	"0101100"
};

/*
 * main driver
 */
main(
	int	argc,
	char	**argv)
{
	int	i;
	char	cm[2];
	graph	*p;

	doenv();
	doargs(argc, argv);


	if (do_legend && !(do_dash || do_markers))
		do_markers = 1;

	markerspacing(do_markers);

	prefsize(768, 512);
	vinit(device);

	viewport(-wholescale, wholescale, -wholescale, wholescale);

	color(BLACK);
	clear();

	color(WHITE);

	if (fontname[0])
		font(fontname);

	readgraphs();
	
	if (!uxscale || !uyscale /* || !uzscale */) 
		for (p = gp; p != (graph *)NULL; p = p->nxt) {
			if (!uxscale)
				adjustscale(p->x, p->npnts, 'x');

			if (!uyscale)
				adjustscale(p->y, p->npnts, 'y');

			/*if (!uzscale)
				adjustscale(p->z, p->npnts, 'z');*/
		}

	axistitle(xlabel, 'x');
	axistitle(ylabel, 'y');
	/*axistitle(zlabel, 'z');*/

	drawaxes2();
	drawtitle();

	i = 0;
	cm[1] = '\0';

	font("markers");
	linewidth(THICK);


	for (p = gp; p != (graph *)NULL; p = p->nxt) {
		if (do_dash)
			linestyle(styles[i % 7]);

		color((i % 7) + 1);
		cm[0] = 'a' + (i++);
		marker(cm);
		plot2(p->x, p->y, p->npnts);
	}

	linewidth(THIN);

	if (do_legend)
		drawlegend();


	getkey();

	vexit();
}
vopl/gpp/data2010070000017730000310000000003060450334253100131510ustar00dghels00001250000004This is an example for gpp(1) using -X and -Y
type xy
This is the x-axis
This is the y-axis
x vs y1
axes xy
1 10
200 30
3000 50
4000 70
5000 90
6000 150
7000 120
9000 100
10000 1
100000 500
plot xy
vopl/gpp/data5010070000017730000310000000002200450334215400131500ustar00dghels00001250000004A saturation growth rate fit
type xy
the x-axis
the y-axis
x vs y1
axes xy
5 17 
10 25
15 30 
20 33
25 36
30 38
35 39
40 40
45 41
50 42
plot xy
vopl/gpp/makefile.tc010070000017730000310000000004530451256606100143510ustar00dghels00001250000004CFLAGS = -DPC -ml -I../src -I../../vogle/src

LIB = ..\src\vopl.lib

OBJS = gpp.obj doargs.obj legend.obj read.obj
.c.obj:
	tcc -c $(CFLAGS) $*.c

all: gpp.exe

gpp.obj: gpp.c

doargs.obj: doargs.c

legend.obj: legend.c

read.obj: read.c

gpp.exe: $(OBJS)
	tcc $(CFLAGS) $(OBJS) $(LIB) vogle.lib^M

vopl/gpp/gpp.h010070000017730000310000000016270700206777500132140ustar00dghels00001250000004#include <stdio.h>
#ifdef PC
#include <string.h>
#define rindex	strrchr
char	*malloc();
#else
#ifdef SYS5
#include <string.h>
#define rindex	strrchr
#else
#include <strings.h>
#endif
#endif

#define MAXPNTS	5000

#ifdef PC
#define DEFAULTDEV "ega"
#else
#ifdef DEFDEV
#define DEFAULTDEV DEFDEV
#else
#define DEFAULTDEV "X11"
#endif
#endif

#define	VERSION	"678-983-132773-1.1"

/*
 * graph types
 */
#define	X		1
#define	Y		2
#define	Z		4

/*
 * single graph structure
 */
typedef struct gr {
	int		type;
	char		*legend;
	int		npnts;
	float		*x, *y, *z;
	struct gr	*nxt;
} graph;

extern graph	*gp;

extern char	device[], fontname[];

extern char	*xlabel, *ylabel, *zlabel;

extern int	ngraphs, do_legend, do_dash, do_markers, uxscale, uyscale, uzscale;

extern FILE	*infile;

extern	float	wholescale;

extern	int	maxpnts;

extern void drawlegend(void);
extern void doargs(int, char *[]);
extern void readgraphs(void);
vopl/gpp/README010070000017730000310000000007060451205722100131160ustar00dghels00001250000004
Some of the data files in this directory need to have gpp
run on them with certain options. They are the following:

data2	- gpp needs to be run with -X and -Y	(log10 scaling)

data3	- gpp needs to be run with -l		(least squares fit)

data4	- gpp needs to be run with -P		(Power equation fit)

data5	- gpp needs to be run with -G		(Saturated growth fit)

data1 doesn't particulary need anything, but demos some of the
intricacies of the input language.
vopl/gpp/legend.c010070000017730000310000000024410700206653300136410ustar00dghels00001250000004
#include "gpp.h"
#include "vogle.h"
#include "vopl.h"

extern	float	strlength();
extern	char	*styles[];

#define D_DOT	0.01
#define D_LEN	0.1

/*
 * drawlegend
 *
 *	Draw a legend for gpp
 */
void
drawlegend(void)
{
	float	ydiff, x, y;
	char	buf[80];
	int	i = 0;
	graph	*p;

	ydiff = 2 * TEXTHEIGHT;
	y = YMAX;
	x =  XMAX + 3 * TEXTWIDTH;

	pushattributes();
	linestyle("");
	clipping(0);
	centertext(1);

	textsize(TEXTWIDTH * 1.2, TEXTWIDTH * 1.2);

	/*
 	 * First draw all the marker symbols
	 */
	/*
	linewidth(THICK);
	*/
	if (do_markers) {
		for (i = 0; i < ngraphs; i++) {
			color((i % 7) + 1);
			move2(x, y);
			drawchar('a' + i);
			y -= ydiff;
		}
		x += 1.4 * TEXTWIDTH;
	}

	/* 
	 * Now linestyles...
	 */
	y = YMAX;
	if (do_dash) {
		setdash(D_DOT);
		for (i = 0; i < ngraphs; i++) {
			color((i % 7) + 1);
			linestyle(styles[i % 7]);
			move2(x, y);
			rdraw2(D_LEN, 0.0);
			y -= ydiff;
		}
		x += 1.2 * D_LEN;
		linestyle("");
	}


	/*
	linewidth(THIN);
	 * Now fill in the legends
	 */

	if (fontname[0])
		font(fontname);
	else
		font("futura.l");

	textsize(TEXTWIDTH * 1.2, TEXTHEIGHT * 1.2);

	y = YMAX;
	i = 0;
 
	for (p = gp; p != (graph *)NULL; p = p->nxt) {
		color((i++ % 7) + 1);
		move2(x + strlength(p->legend) / 2, y);
		drawstr(p->legend);
		y -= ydiff;
	}

	popattributes();
}
vopl/gpp/read.c010070000017730000310000000106010700206647700133220ustar00dghels00001250000004#include "gpp.h"

char	*fmttable[] = {
	"",
	"%f ",
	"%f ",
	"%f %f ",
	"%f ",
	"%f %f ",
	"%f %f ",
	"%f %f %f "
};

extern	float	*newm1();

/*
 * getline
 *
 *	reads in a file from file in.
 */
char *
getline(
	FILE	*in)
{
	char	*p, line[BUFSIZ]; 
	int	c;

	p = line;

	while ((c = getc(in)) != '\n') {
		if (feof(in))
			return((char *)NULL);
		*p++ = c;
	}

	*p = 0;

	p = (char *)malloc(p - line + 1);
	strcpy(p, line);

	return(p);
}

/*
 * decode
 *
 *	converts string type into its X, Y, and Z code.
 */
int
decode(
	char	*type)
{
	int	itype;
	char	*sp;

	itype = 0;

	for (sp = type; *sp; sp++)
		switch (*sp) {
		case 'x':
			itype |= X;
			break;
		case 'y':
			itype |= Y;
			break;
		case 'z':
			itype |= Z;
			break;
		default:
			fprintf(stderr, "gpp: bad axes/type descriptor\n");
			exit(1);
		}

	return(itype);
}

/*
 * readgraphs
 *
 *	read in the graphs
 */
void
readgraphs(void)
{
	int		type;
	graph		*p, *lp;
	char		stype[4], *fmt, *title;
	int		atype, c;
	float		x, y, z, *xaxis, *yaxis, *zaxis;

	ngraphs = 0;

	/*  First we read the title */

	if ((title = getline(infile)) == NULL) {
		fprintf(stderr,"gpp: EOF when title was expected.\n");
		exit(1);
	}

	graphtitle(title);

	/* next the type */

	if (fscanf(infile, "type %s", stype) != 1) {
		fprintf(stderr,"gpp: EOF when type expected.\n");
		exit(1);
	}

	getc(infile);		/* skip single newline */

	type = decode(stype);

	if ((type & X) && (xlabel = getline(infile)) == NULL) {
		fprintf(stderr,"gpp: EOF when x-axis label expected.\n");
		exit(1);
	}
	if ((type & Y) && (ylabel = getline(infile)) == NULL) {
		fprintf(stderr,"gpp: EOF when y-axis label was expected.\n");
		exit(1);
	}
	if ((type & Z) && (zlabel = getline(infile)) == NULL) {
		fprintf(stderr,"gpp: EOF when z-axis label was expected.\n");
		exit(1);
	}

	/*  Now we should be reading coordinates */

	xaxis = (float *)NULL;
	yaxis = (float *)NULL;
	zaxis = (float *)NULL;

	p = gp = (graph *)malloc(sizeof(graph));
	if (gp == (graph *)NULL) {
		fprintf(stderr, "gpp: malloc returns NULL.\n");
		exit(1);
	}

	if ((gp->legend = getline(infile)) == NULL) {
		fprintf(stderr,"gpp: EOF when legend was expected.\n");
		exit(1);
	}

	while (!feof(infile)) {
		if (fscanf(infile, "axes %s ", stype) != 1) {
			fprintf(stderr,"EOF when axes expected.\n");
			exit(1);
		}

		p->x = xaxis;
		p->y = yaxis;
		p->z = zaxis;

		atype = decode(stype);

		fmt = fmttable[atype];

		switch (atype) {
		case X:
			xaxis = p->x = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &x) != 0) {
				p->x[p->npnts++] = x;
			}
			break;
		case Y:
			yaxis = p->y = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &y) != 0) {
				p->y[p->npnts++] = y;
			}
			break;
		case Z:
			zaxis = p->z = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &z) != 0) {
				p->z[p->npnts++] = z;
			}
			break;
		case X | Y:
			xaxis = p->x = newm1(maxpnts);
			yaxis = p->y = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &x, &y) != 0) {
				p->x[p->npnts] = x;
				p->y[p->npnts++] = y;
			}
			break;
		case X | Z:
			xaxis = p->x = newm1(maxpnts);
			zaxis = p->z = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &x, &z) != 0) {
				p->x[p->npnts] = x;
				p->z[p->npnts++] = z;
			}
			break;
		case Y | Z:
			yaxis = p->y = newm1(maxpnts);
			zaxis = p->z = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &y, &z) != 0) {
				p->y[p->npnts] = y;
				p->z[p->npnts++] = z;
			}
			break;
		case X | Y | Z:
			xaxis = p->x = newm1(maxpnts);
			yaxis = p->y = newm1(maxpnts);
			zaxis = p->z = newm1(maxpnts);
			p->npnts = 0;
			while (fscanf(infile, fmt, &x, &y, &z) != 0) {
				p->x[p->npnts] = x;
				p->y[p->npnts++] = y;
			}
			break;
		default:
			fprintf(stderr, "gpp: readgraphs - internal error.\n");
			exit(1);
		}
 
		if (fscanf(infile, "plot %s", stype) == 1) {
			p->type = decode(stype);
			if ((p->nxt = (graph *)malloc(sizeof(graph))) == (graph *)NULL) {
				fprintf(stderr, "readgraphs: malloc returns NULL\n");
				exit(1);
			}
			lp = p;
			p = p->nxt;

			/*
			 * skip newline after plot command
			 */
			while ((c = getc(infile)) != '\n' && !feof(infile))
				;

			p->legend = getline(infile);

			ngraphs++;

			/*
			 * skip extra characters before next axis keyword
			 */
			while ((c = getc(infile)) != 'a' && !feof(infile))
				;

			if (!feof(infile))
				ungetc(c, infile);
		}
	}

	/* finish off the last one */
	lp->nxt = NULL;
}
vopl/gpp/data1010070000017730000310000000006170437447215700131730ustar00dghels00001250000004This is an example for gpp(1)
type xy
This is the x-axis
This is the y-axis
x vs y1
axes xy
0 0 
1 10
2 30
3 50
4 70
5 90
6 150
7 120
9 100
10 10
plot xy
x vs y3
axes xy
0.0	70.0
1.0	30.0
2.0	50.0
3.0	45.0
4.0	31.0
5.0	15.0
6.0	29.0
7.0	98.0
9.0	52.0
10.0	30.0
12.0	65.0
plot xy
x vs y2
axes y
    50.0
    60.0
    50.0
    55.0
    31.0
    25.0
    29.0
    28.0
    32.0
   40.0
   55.0
plot xy
vopl/gpp/data4010070000017730000310000000002100450334214200131430ustar00dghels00001250000004A power equation fit
type xy
the x-axis
the y-axis
x vs y1
axes xy
5 17 
10 25
15 30 
20 33
25 36
30 38
35 39
40 40
45 41
50 42
plot xy
vopl/gpp/Makefile010070000017730000310000000006460700111116700136750ustar00dghels00001250000004#
LIBS = -lvogle -L/usr/X11/lib -lX11

SRCS = gpp.c read.c legend.c doargs.c

OBJS = gpp.o read.o legend.o doargs.o

MCFLAGS = -g

DEFDEV = -DX11

CFLAGS = $(DEFDEV) $(MCFLAGS) -I../src

all:	gpp

gpp:     $(OBJS) gpp.h ../src/libvopl.a
	cc $(CFLAGS) -o gpp $(OBJS) ../src/libvopl.a $(LIBS) -lm
	
$(OBJS): gpp.h

lint: $(SRCS)
	lint -I../vogle/src $(SRCS) > gpp.lint

clean:
	rm -f *.o core

clobber:
	rm -f gpp *.o core

vopl/gpp/doargs.c010070000017730000310000000157720700225005200136640ustar00dghels00001250000004
#include "vopl.h"
#include "gpp.h"

graph	*gp;

int	ngraphs = 0,
	do_legend = 0,
	do_markers = 0,
	do_dash = 0,
	points_only = 0,
	uxscale = 0,
	uyscale = 0,
	uzscale = 0,
	maxpnts = MAXPNTS;

char	*xlabel,
	*ylabel,
	*zlabel,
	*title,
	fontname[100],			/* name of the font we use */
	device[20];			/* name of the device we use */

static	char	*myname;		/* Me */
static	int	fromenv = 0;

FILE	*infile;			/* current input file */

float	wholescale = 1.0;

/*
 * usage
 *
 *	Print a usage message
 */
void
usage(void)
{
	fprintf(stderr, "\nUsage: %s [-X] [-Y] [-x min max] [-y min max] [-S] [-P] [-G] [-l<n>]\n", myname);
	fprintf(stderr,"       [-s s0 sn] [-r<fact>] [-m<n>] [-g<n>] [-p<n>] [-L] [-n]\n");
	fprintf(stderr,"       [-D] [-Mx<n>] [-My<n>] [-a<maxsize>]\n");
	fprintf(stderr,"       [-d<device>] [-f<fontname>] [- or filename]\n\n");

#ifdef PC
	fprintf(stderr,"Press a key for more info....\n");
	getch();
#endif
	fprintf(stderr,"Where:\n");
	fprintf(stderr,"-X, -Y specifies logscaling of x and y axes\n");
	fprintf(stderr,"-x, -y specifies optional min and max  of x and y axes\n");
	fprintf(stderr,"-S uses a cardinal spline fit\n");
	fprintf(stderr,"-P uses a power equation fit\n");
	fprintf(stderr,"-G uses a saturated growth fit\n");
	fprintf(stderr,"-l uses a least squares fit of degree <n>\n");
	fprintf(stderr,"-s uses a 'clamped' spline fit with endslopes s0 and sn\n");
	fprintf(stderr,"-r reduces (enlarges) the plot by fact\n");
	fprintf(stderr,"-m places markers at every <n> data points\n");
	fprintf(stderr,"-g places a grid spaced every <n> data points over the plot\n");
	fprintf(stderr,"-p draws markers only at each <n>th point (ie. no lines)\n");
	fprintf(stderr,"-L draws a legend (if any are provided)\n");
	fprintf(stderr,"-n means don't draw any axis anotation\n");
	fprintf(stderr,"-D means Draw each graph with a different linestyle.\n");
	fprintf(stderr,"-Mx set number of minor tickmarks on X axis (def: 10).\n");
	fprintf(stderr,"-My set number of minor tickmarks on Y axis (def: 10).\n");
	fprintf(stderr,"-Tx set number of major tickmarks on X axis.\n");
	fprintf(stderr,"-Ty set number of major tickmarks on Y axis.\n");
	fprintf(stderr,"-a set max number of points per graph (def: %d).\n", MAXPNTS);
	fprintf(stderr,"-d uses VOGLE device <device>\n");
	fprintf(stderr,"-f uses VOGLE font <fontname>\n");
	fprintf(stderr,"- by itself uses standard input for input\n");
	fprintf(stderr,"filename by itself uses filename for input\n");
	
	exit(1);
}

/*
 * getone
 *
 *	Returns one floating point number form the argument list.
 */
float
getone(
	char	c,
	char	*arg)
{
	float	a;

	if (sscanf(arg, "%f", &a) != 1) {
		fprintf(stderr,"-%c option expects one number\n", c);
		usage();
	}
	return (a);
}

/*
 * gettwo
 *
 *	grabs two floating point numbers from the argument list
 */
static void
gettwo(
	char	**argv,
	char	c,
	float	*a,
	float	*b)
{	
	if (*(argv + 2) != (char *)NULL) {
		if (sscanf(*(++argv), "%f", a) != 1) {
			fprintf(stderr, "-%c option expects two numbers\n", c);
			usage();
		}
		if (sscanf(*(++argv), "%f", b) != 1) {
			fprintf(stderr, "-%c option expects two numbers\n", c);
			usage();
		}
	} else {
		fprintf(stderr, "-%c option expects two numbers\n", c);
		usage();
	}
}

/*
 * doargs
 *
 * 	Interpret command line args.
 */
void
doargs(
	int	argc,
	char	*argv[])
{
	float	a, b;
	char	c;
	int	i, gotinfile = 0;

	if (fromenv) {
		device[0] = '\0';
		fontname[0] = '\0';
	}

#ifdef PC
	if ((myname = rindex(argv[0],'\\')) == NULL)
#else
	if ((myname = rindex(argv[0],'/')) == NULL)
#endif
		myname = argv[0];
	else
		*myname++;

#ifdef PC
	*rindex(myname,'.') = '\0';
#endif

	while (argc > 1) 
		if (*(*++argv) == '-')
			switch(*(*argv+1)) {
			case 'x':
			case 'y':
			case 'z':
				c = *(*argv+1);
				gettwo(argv, c, &a, &b);
				argc -= 3;
				argv += 2;
				range(a, b, c);
				if (c == 'x')
					uxscale = 1;
				else if (c == 'y')
					uyscale = 1;
				else
					uzscale = 1;
				break;
			case 'X': 
				scaling(1, 'x');
				argc--;
				break;
			case 'Y': 
				scaling(1, 'y');
				argc--;
				break;
			case 's':
				fit(CUBIC_SPLINE);
				gettwo(argv, 's', &a, &b);
				endslopes(a, b);
				argc -= 3;
				argv += 2;
				break;
			case 'r':
				if (*(*argv + 2)) {
					a = getone('r', *argv + 2);
					argc--;
				} else {
					a = getone('r', *(++argv));
					argc -= 2;
				}
				/*graphscale(a);*/
				wholescale = a;
				break;
			case 'l':
				fit(LEAST_SQUARE);
				if (*(*argv + 2) != 0)
					degree(atoi(*argv + 2));
				argc--;
				break;
			case 'S':
				fit(CUBIC_SPLINE);
				argc--;
				break;
			case 'P':
				fit(POWER_EQN);
				argc--;
				break;
			case 'G':
				fit(SGR_FIT);
				argc--;
				break;
			case 'm':
				if ((do_markers = atoi(*argv + 2)) <= 0)
					do_markers = 1;

				argc--;
				break;
			case 'p':
				if ((i = atoi(*argv + 2)) <= 0)
					i = 1;

				do_markers = i;
				fit(NO_LINES);
				argc--;
				break;
			case 'a':
				if ((maxpnts = atoi(*argv + 2)) <= 0)
					maxpnts = MAXPNTS;

				argc--;
				break;
			case 'n':
				annotate("", 'x');
				annotate("", 'y');
				annotate("", 'z');
				argc--;
				break;
			case 'D':
				do_dash = 1;
				argc--;
				break;
			case 'M':
				if ((i = atoi(*argv + 3)) < 0)
					i = 0;

				minorticks(i, *(*argv + 2));

				argc--;
				break;
			case 'T':
				if ((i = atoi(*argv + 3)) < 0)
					i = 0;

				tickmarks(i, *(*argv + 2));

				argc--;
				break;
			case 'v':
				/* Print the version of gpp */
				printf("This is version %s of gpp\n", VERSION);
				exit(0);
			case 'g':
				if ((i = atoi(*argv + 2)) <= 0)
					i = 1;

				gridspacing(i);
				argc--;
				break;
			case 'L':
				do_legend = 1;
				argc--;
				break;
			case 'f' :
				if (*(*argv+2)) {
					strcpy(fontname, *argv + 2);
					argc--;
				} else {
					strcpy(fontname, *(++argv));
					argc -= 2;
				}
				break;
			case 'd':
				if (*(*argv + 2)) {
					strcpy(device,*argv + 2);
					argc--;
				} else {
					strcpy(device,*(++argv));
					argc -= 2;
				}
				break;
			case 0:			/* single - read stdin */
				gotinfile = 1;
				infile = stdin;
				argc--;
				break;
			default:
				fprintf(stderr, "Unknown flag: %s\n",*argv);
				usage();
				exit(-1);
			}
		else {   	/* the input file */
			if ((infile = fopen(*argv,"r")) == NULL) {
				fprintf(stderr, "Can't open: %s\n",*argv);
				usage();
				exit(-1);
			} else {
				gotinfile = 1;
				argc--;
			}
		}

	if (!fromenv && !gotinfile) 
		usage();

	if (!device[0]) {
		char	*d, *getenv();
		if (!(d = getenv("GPPDEV")))
			strcpy(device, DEFAULTDEV);
		else
			strcpy(device, d);
	}

}

/*
 * Parse the environment variable GPPENV for other common
 * command line args.
 */
void
doenv(void)
{

	char	*p, *e;
	char	*av[30], *getenv();	/* should be enuf */
	int	ac;

	if ((e = getenv("GPPENV")) == NULL)
		return;

	ac = 1;
	av[0] = (char *)malloc(4);
	strcpy(av[0], "gpp");

	while (*e) {
		for (p = e; *p && *p != ' '; p++)
			;

		av[ac] = (char *)malloc(p - e + 1);
		strncpy(av[ac], e, p - e + 1);
		av[ac][p - e] = 0;
		ac++;

		e = p;
		if (*p)
			e++;
	}

	fromenv = 1;
	doargs(ac, av);
	fromenv = 0;

	while(ac >= 0)
		free(av[ac--]);
}
vopl/gpp/makefile.msc010070000017730000310000000004560451256606000145270ustar00dghels00001250000004F = -FPc
CFLAGS = -DPC -DMSC -c -AL -I../src -I../../vogle/src $(F)

LIBS = ..\src\vopl.lib vogle.lib

OBJS = gpp.obj doargs.obj legend.obj read.obj
.c.obj:
	cl $(CFLAGS) $*.c

gpp.obj: gpp.c

doargs.obj: doargs.c

legend.obj: legend.c

read.obj: read.c

gpp.exe: $(OBJS)
	link /NOE $(OBJS),,,$(LIBS);
vopl/gpp/in010070000017730000310000000001550545413001400125630ustar00dghels00001250000004This is an example for gpp(1)
type xy
This is the x-axis
This is the y-axis
x vs y1
axes xy
0 0 
1 1
plot xy
vopl/readme.pc010070000017730000310000000004750451253611300132360ustar00dghels00001250000004
	To build a straight C version of the library use the build.bat
	file. If you want the Fortran interfaces then use fbuild.bat.

	In the makefiles (ie the ones ending in .msc), you'll have to 
	change where -I option looks for the header file vogle.h. Also
	you should have the vogle.lib in your library search path.
vopl/send_beer010070000017730000310000000017630463707154500133420ustar00dghels00001250000004#!/bin/sh
#
# send_beer	- very ordinary beer submission
#
# Create a  beer submission report and mail to `eric@munnari.oz.au'
# The sender will be placed in `vi' with a copy of the beer submission
# template. When complete, simply exit the editor, and the report will be
# mailed automatically.
#
#

ericmail=echidna@munnari.oz.au

mailer=/usr/ucb/mail
ed=/usr/ucb/vi
tool=`basename $0`
vobs=/tmp/$tool.$$
vobsb=${vobs}b
trap "rm -f $vobs $vobsb; exit" 0 1 2 3 15

sed -e "1,/^#SEND_BEER_FORMAT/d" < $0 > $vobs
cp $vobs $vobsb
$ed $vobs

cmp -s $vobs $vobsb
 
if (test $? -eq 0 -o `cat $vobs | wc -c` -le 1) then
    echo "$tool: cancelled"
else
    $mailer $ericmail <$vobs
    echo "$tool: sent"
fi

exit 0

#SEND_BEER_FORMAT

Dear Eric,
I thank you kindly for your free software and hope that you continue
to produce work of this  kind. To support you I am sending you 
<ENTER QUANTITY> cans of <ENTER BRAND>. 


Best Regards,

<ENTER NAME>,
<ENTER COMPANY>,
<ENTER CONTACT>,
<ENTER ADDRESS>,
<ENTER PHONE>

vopl/src/004075500017730000310000000000000700226534500122535ustar00dghels00001250000004vopl/src/sunfort/004075500017730000310000000000000700226534500137535ustar00dghels00001250000004vopl/src/sunfort/fplot.c010070000017730000310000000001740700207521500152260ustar00dghels00001250000004#include "vopl.h"

extern	double log10();

/*
 * plot2_
 */
plot2_(x, y, n)
	float	x[], y[];
	int	*n;
{
	plot2(x, y, *n);
}
vopl/src/sunfort/fsadjust.c010070000017730000310000000002150444313755700157370ustar00dghels00001250000004
#include "vopl.h"

/*
 *	adjustscale
 *
 */
void
adjustscale_(x, n, axis)
	float	x[];
	int	*n;
	char	*axis;
{
	adjustscale(x, *n, *axis);
}
vopl/src/sunfort/fswitch.c010070000017730000310000000035360700206365600155640ustar00dghels00001250000004#include <stdio.h>
#include "vopl.h"

/*
 * fit_
 */
void
fit_(type)
	int	*type;
{
	fit(*type);
}

/*
 * skip_
 */
skip_(n)
	int	*n;
{
	skip(n);
}

/*
 * endslopes_
 */
void
endslopes_(a, b)
	float	*a, *b;
{
	endslopes(*a, *b);
}

/*
 * gridspacing_
 */
void
gridspacing_(spacing)
	int	*spacing;
{
	gridspacing(*spacing);
}

/*
 * scaling_
 */
void
scaling_(type, axis)
	int	*type;
	char	*axis;
{
	scaling(*type, *axis);
}

/*
 * tickmarks_
 */
void
tickmarks_(num, axis)
	int	*num;
	char	*axis;
{
	tickmarks(*num, *axis);
}

/*
 * tickspacing_
 */
void
tickspacing_(num, axis)
	int	*num;
	char	*axis;
{
	tickspacing(*num, *axis);
}

/*
 * minorticks_
 */
void
minorticks_(num, axis)
	int     *num;
	char    *axis;
{
	minorticks(*num, *axis);
}


/*
 * annotate_
 */
void
annotate_(format, axis, len)
	char	*format;
	char	*axis;
	int	len;
{
	char		buf[BUFSIZ];
	register char	*p;

	strncpy(buf, format, len);
	buf[len] = 0;

	for (p = &buf[len - 1]; *p == ' '; p--)
		;

	*++p = 0;

	annotate(buf, *axis);
}

/*
 * arrayindex_
 */
void
arrayindex_(i)
	int	*i;
{
	arrayindex(*i);
}

/*
 * marker_
 */
void
marker_(string, len)
	char	*string;
	int	len;
{
	char		buf[BUFSIZ];
	register char	*p;

	strncpy(buf, string, len);
	buf[len] = 0;

	for (p = &buf[len - 1]; *p == ' '; p--)
		;

	*++p = 0;

	marker(buf);
}
		
/*
 * markerspacing_
 */
void
markerspacing_(spacing)
	int	*spacing;
{
	markerspacing(*spacing);
}

/*
 * markerscale_
 */
void
markerscale_(s)
	float	*s;
{
	markerscale(*s);
}

/*
 * graphtitle_
 */
void
graphtitle_(s, len)
	char	*s;
	int	len;
{
	char		buf[BUFSIZ];
	register char	*p;

	strncpy(buf, s, len);
	buf[len] = 0;

	for (p = &buf[len - 1]; *p == ' '; p--)
		;

	*++p = 0;

	graphtitle(buf);
}

/*
 * drawtitle_
 */
void
drawtitle_()
{
	drawtitle();
}

/*
 * range_
 */
void
range_(min, max, axis)
	float	*min, *max;
	char	*axis;
{
	range(*min, *max, *axis);
}

vopl/src/sunfort/flsfit.c010070000017730000310000000001200444237745400153770ustar00dghels00001250000004#include "vopl.h"

/*
 * degree_
 */
degree_(ord)
	int	*ord;
{
	degree(*ord);
}
vopl/src/sunfort/faxis.c010070000017730000310000000010720700207520700152130ustar00dghels00001250000004#include <stdio.h>
#include <string.h>
#include "vopl.h"

/*
 * axistitle_
 *
 *	Draws an x, y or z axis, with or without annotation, tickmarks etc
 */
void
axistitle_(title, ax, len)
	char	*title;
	char	*ax;
	int	len;
{
	char		buf[BUFSIZ];
	register char	*p;

	strncpy(buf, title, len);
	buf[len] = 0;

	for (p = &buf[len - 1]; *p == ' '; p--)
		;

	*++p = 0;

	axistitle(buf, *ax);
}

/*
 * drawaxis_
 */
void
drawaxis_(ax)
	char	*ax;
{
	drawaxis(*ax);
}

/*
 * drawaxes2_
 */
void
drawaxes2_()
{
	drawaxes2();
}

/*
 * drawaxes_
 */
void
drawaxes_()
{
	drawaxes();
}
vopl/src/sunfort/Makefile010070000017730000310000000003620700225706000153750ustar00dghels00001250000004#

SRCS = faxis.c flsfit.c fplot.c fhist.c fsadjust.c fswitch.c

OBJS = faxis.o flsfit.o fplot.o fhist.o fsadjust.o fswitch.o

MCFLAGS = -fsingle -f68881 -g

CFLAGS = $(MCFLAGS) -I..

all:	$(OBJS)

$(OBJS): ../vopl.h

clean:
	rm -f *.o core

vopl/src/sunfort/fhist.c010070000017730000310000000003050700225723700152210ustar00dghels00001250000004#include "vopl.h"

/*
 * hist2_
 */
hist2_(d, ng, ns, names)
	float	*d;
	int	ng;
	int	ns;
	char	*names[];
{
	hist2(d, ng, ns, names);
}

/*
 * histskip_
 */
histskip_(h)
	int	*h;
{
	histskip(h);
}
vopl/src/msfort/004075500017730000310000000000000700225712400135615ustar00dghels00001250000004vopl/src/msfort/fplot.for010070000017730000310000000002720451256573700154230ustar00dghels00001250000004	interface to subroutine C_plot2[c](x[reference], 
     +	y[reference], n)
	real	x(1), y(1)
	integer *2 n
	end

	subroutine plot2(x, y, n)
	real x(n), y(n)
	
	call C_plot2(x, y, n)
	end
vopl/src/msfort/fsadjust.for010070000017730000310000000003130451256573700161160ustar00dghels00001250000004	interface to subroutine C_adjustscale[c](x[reference], n, a)
	real x(1)
	integer *2 n
	character *1 a
	end

	subroutine adjustscale(x, n, a)
	real x(n)
	character *1 a
	call C_adjustscale(x, n, a)
	end
vopl/src/msfort/fswitch.for010070000017730000310000000044620545512601300157360ustar00dghels00001250000004	interface to subroutine C_fit[c](type)
	integer *2 type
	end

	interface to subroutine C_skip[c](i)
	integer *2 i
	end

	interface to subroutine C_endslopes[c](a, b)
	real *8 a, b
	end

	interface to subroutine C_gridspacing[c](i)
	integer *2 i
	end

	interface to subroutine C_scaling[c](i, a)
	integer *2 i
	character *1 a
	end

	interface to subroutine C_tickmarks[c](i, a)
	integer *2 i
	character *1 a
	end

	interface to subroutine C_tickspacing[c](i, a)
	integer *2 i
	character *1 a
	end

	interface to subroutine C_minorticks[c](i, a)
	integer *2 i
	character *1 a
	end

	interface to subroutine C_annotate[c](f[reference], a)
	character *(*) f
	character *1 a
	end

	interface to subroutine C_arrayindex[c](i)
	integer *2 i
	end

	interface to subroutine C_marker[c](s[reference])
	character *(*) s
	end

	interface to subroutine C_markerspacing[c](i)
	integer *2 i
	end

	interface to subroutine C_markerscale[c](i)
	real *8 i
	end

	interface to subroutine C_graphtitle[c](s[reference])
	character *(*) s
	end

	interface to subroutine C_drawtitle[c]
	end

	interface to subroutine C_range[c](a, b, ax)
	real *8 a, b
	character *1 ax
	end

	subroutine fit(i)
	call C_fit(i)
	end

	subroutine skip(i)
	call C_fit(i)
	end

	subroutine endslopes(a, b)
	call C_endslopes(a, b)
	end

	subroutine gridspacing(i)
	call C_gridspacing(i)
	end

	subroutine scaling(i, ax)
	character *1 ax
	call C_scaling(i, ax)
	end

	subroutine tickmarks(i, ax)
	character *1 ax
	call C_tickmarks(i, ax)
	end

	subroutine tickspacing(i, ax)
	character *1 ax
	call C_tickspacing(i, ax)
	end

	subroutine minorticks(i, ax)
	character *1 ax
	call C_minorticks(i, ax)
	end

	subroutine annotate(f, ax)
	character *(*) f
	character *1 ax
	character *128 t_string
	call C_annotate(t_string(f), ax)
	end

	subroutine arrayindex(i)
	call C_arrayindex(i)
	end

	subroutine axisintersection(a, b)
	call C_axisintersection(a, b)
	end

	subroutine marker(s)
	character *(*) s
	character *128 t_string
	call C_marker(t_string(s))
	end

	subroutine markerspacing(i)
	call C_markerspacing(i)
	end

	subroutine markerscale(a)
	call C_markerscale(a)
	end

	subroutine graphtitle(s)
	character *(*) s
	character *128 t_string
	call C_graphtitle(t_string(s))
	end

	subroutine drawtitle
	call C_drawtitle
	end

	subroutine range(a, b, ax)
	character *1 ax
	call C_range(a, b, ax)
	end
vopl/src/msfort/flsfit.asm010070000017730000310000000011610444267605700155560ustar00dghels00001250000004;	Static Name Aliases
;
	TITLE   flsfit.for
	NAME    flsfit

	.8087
FLSFIT_TEXT	SEGMENT  BYTE PUBLIC 'CODE'
FLSFIT_TEXT	ENDS
_DATA	SEGMENT  WORD PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT  WORD PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT  WORD PUBLIC 'BSS'
_BSS	ENDS
DGROUP	GROUP	CONST, _BSS, _DATA
	ASSUME  CS: FLSFIT_TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
EXTRN	__acrtused:ABS
EXTRN	_degree:FAR
FLSFIT_TEXT      SEGMENT
; Line 6
	PUBLIC	DEGREE
DEGREE	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _degree
; Line 7
	mov	sp,bp
	pop	bp
	ret	4

DEGREE	ENDP
FLSFIT_TEXT	ENDS
END
vopl/src/msfort/fplot.asm010070000017730000310000000015740444267606200154170ustar00dghels00001250000004;	Static Name Aliases
;
	TITLE   fplot.for
	NAME    fplot

	.8087
FPLOT_TEXT	SEGMENT  BYTE PUBLIC 'CODE'
FPLOT_TEXT	ENDS
_DATA	SEGMENT  WORD PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT  WORD PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT  WORD PUBLIC 'BSS'
_BSS	ENDS
DGROUP	GROUP	CONST, _BSS, _DATA
	ASSUME  CS: FPLOT_TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
EXTRN	__acrtused:ABS
EXTRN	_plot2:FAR
FPLOT_TEXT      SEGMENT
; Line 10
	PUBLIC	PLOT2
PLOT2	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,4
	push	si
;	X = 14
;	Y = 10
;	N = 6
;	__V23 = 65532
;	__V24 = 65534
	les	bx,DWORD PTR [bp+6]	;N
	mov	si,WORD PTR es:[bx]
	mov	ax,si
	shl	ax,1
	shl	ax,1
	mov	WORD PTR [bp-4],ax
	mov	WORD PTR [bp-2],ax
	push	si
	push	WORD PTR [bp+12]
	push	WORD PTR [bp+10]	;Y
	push	WORD PTR [bp+16]
	push	WORD PTR [bp+14]	;X
	call	FAR PTR _plot2
	add	sp,10
; Line 11
	pop	si
	mov	sp,bp
	pop	bp
	ret	12

PLOT2	ENDP
FPLOT_TEXT	ENDS
END
vopl/src/msfort/fsadjust.asm010070000017730000310000000016370444267606300161170ustar00dghels00001250000004;	Static Name Aliases
;
	TITLE   fsadjust.for
	NAME    fsadjust

	.8087
FSADJUST_TEXT	SEGMENT  BYTE PUBLIC 'CODE'
FSADJUST_TEXT	ENDS
_DATA	SEGMENT  WORD PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT  WORD PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT  WORD PUBLIC 'BSS'
_BSS	ENDS
DGROUP	GROUP	CONST, _BSS, _DATA
	ASSUME  CS: FSADJUST_TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
EXTRN	__acrtused:ABS
EXTRN	_adjustscale:FAR
EXTRN	__FCclenv:DWORD
FSADJUST_TEXT      SEGMENT
; Line 10
	PUBLIC	ADJUSTSCALE
ADJUSTSCALE	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,2
	push	si
;	X = 14
;	N = 10
;	A = 6
;	__V23 = 65534
	les	bx,DWORD PTR [bp+10]	;N
	mov	si,WORD PTR es:[bx]
	mov	ax,si
	shl	ax,1
	shl	ax,1
	mov	WORD PTR [bp-2],ax
	les	bx,DWORD PTR [bp+6]	;A
	push	WORD PTR es:[bx]
	push	si
	push	WORD PTR [bp+16]
	push	WORD PTR [bp+14]	;X
	call	FAR PTR _adjustscale
	add	sp,8
; Line 11
	pop	si
	mov	sp,bp
	pop	bp
	ret	12

ADJUSTSCALE	ENDP
FSADJUST_TEXT	ENDS
END
vopl/src/msfort/fswitch.asm010070000017730000310000000144270451206757300157420ustar00dghels00001250000004;	Static Name Aliases
;
	TITLE   fswitch.for
	NAME    fswitch

	.8087
FSWITCH_TEXT	SEGMENT  BYTE PUBLIC 'CODE'
FSWITCH_TEXT	ENDS
_DATA	SEGMENT  WORD PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT  WORD PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT  WORD PUBLIC 'BSS'
_BSS	ENDS
DGROUP	GROUP	CONST, _BSS, _DATA
	ASSUME  CS: FSWITCH_TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
EXTRN	__acrtused:ABS
EXTRN	_markerscale:FAR
EXTRN	_graphtitle:FAR
EXTRN	T_STRING:FAR
EXTRN	_fit:FAR
EXTRN	_drawtitle:FAR
EXTRN	_range:FAR
EXTRN	_endslopes:FAR
EXTRN	_gridspacing:FAR
EXTRN	_scaling:FAR
EXTRN	_tickmarks:FAR
EXTRN	__elds:FAR
EXTRN	__dcvt:FAR
EXTRN	__fstdp:FAR
EXTRN	_tickspacing:FAR
EXTRN	_annotate:FAR
EXTRN	_arrayindex:FAR
EXTRN	_marker:FAR
EXTRN	_markerspacing:FAR
EXTRN	__FCclenv:DWORD
FSWITCH_TEXT      SEGMENT
; Line 70
	PUBLIC	FIT
FIT	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _fit
; Line 71
	mov	sp,bp
	pop	bp
	ret	4

FIT	ENDP
; Line 74
	PUBLIC	SKIP
SKIP	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _fit
; Line 75
	mov	sp,bp
	pop	bp
	ret	4

SKIP	ENDP
; Line 78
	PUBLIC	ENDSLOPES
ENDSLOPES	PROC FAR
	push	bp
	mov	bp,sp
;	A = 10
;	B = 6
	les	bx,DWORD PTR [bp+6]	;B
	call	FAR PTR __elds
	call	FAR PTR __dcvt
	sub	sp,8
	mov	bx,sp
	call	FAR PTR __fstdp
	les	bx,DWORD PTR [bp+10]	;A
	call	FAR PTR __elds
	call	FAR PTR __dcvt
	sub	sp,8
	mov	bx,sp
	call	FAR PTR __fstdp
	call	FAR PTR _endslopes
; Line 79
	mov	sp,bp
	pop	bp
	ret	8

ENDSLOPES	ENDP
; Line 82
	PUBLIC	GRIDSPACING
GRIDSPACING	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _gridspacing
; Line 83
	mov	sp,bp
	pop	bp
	ret	4

GRIDSPACING	ENDP
; Line 87
	PUBLIC	SCALING
SCALING	PROC FAR
	push	bp
	mov	bp,sp
;	I = 10
;	AX = 6
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	les	bx,DWORD PTR [bp+10]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _scaling
; Line 88
	mov	sp,bp
	pop	bp
	ret	8

SCALING	ENDP
; Line 92
	PUBLIC	TICKMARKS
TICKMARKS	PROC FAR
	push	bp
	mov	bp,sp
;	I = 10
;	AX = 6
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	les	bx,DWORD PTR [bp+10]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _tickmarks
; Line 93
	mov	sp,bp
	pop	bp
	ret	8

TICKMARKS	ENDP
; Line 97
	PUBLIC	TICKSPACING
TICKSPACING	PROC FAR
	push	bp
	mov	bp,sp
;	I = 10
;	AX = 6
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	les	bx,DWORD PTR [bp+10]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _tickspacing
; Line 98
	mov	sp,bp
	pop	bp
	ret	8

TICKSPACING	ENDP
; Line 104
	PUBLIC	ANNOTATE
ANNOTATE	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,268
	push	di
	push	si
;	F = 10
;	AX = 6
	mov	ax,WORD PTR __FCclenv
	mov	dx,WORD PTR __FCclenv+2
	mov	WORD PTR [bp-12],ax
	mov	WORD PTR [bp-10],dx
	mov	WORD PTR [bp-2],128
	les	bx,DWORD PTR [bp-12]
	mov	ax,WORD PTR es:[bx+2]
	mov	WORD PTR [bp-6],ax
	push	WORD PTR [bp+12]
	push	WORD PTR [bp+10]	;F
	lea	ax,WORD PTR [bp-140]
	push	ax
	mov	WORD PTR [bp-8],128
	lea	ax,WORD PTR [bp-8]
	mov	dx,ss
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,dx
	call	FAR PTR T_STRING
	lea	di,WORD PTR [bp-268]
	mov	si,ax
	push	ss
	pop	es
	mov	cx,64
	rep	movsw
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	lea	ax,WORD PTR [bp-268]
	push	ss
	push	ax
	lea	ax,WORD PTR [bp-4]
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,ss
	call	FAR PTR _annotate
	add	sp,6
; Line 105
	pop	si
	pop	di
	mov	sp,bp
	pop	bp
	ret	8

ANNOTATE	ENDP
; Line 108
	PUBLIC	ARRAYINDEX
ARRAYINDEX	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _arrayindex
; Line 109
	mov	sp,bp
	pop	bp
	ret	4

ARRAYINDEX	ENDP
; Line 118
	PUBLIC	MARKER
MARKER	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,268
	push	di
	push	si
;	S = 6
	mov	ax,WORD PTR __FCclenv
	mov	dx,WORD PTR __FCclenv+2
	mov	WORD PTR [bp-12],ax
	mov	WORD PTR [bp-10],dx
	mov	WORD PTR [bp-2],128
	les	bx,DWORD PTR [bp-12]
	mov	ax,WORD PTR es:[bx+2]
	mov	WORD PTR [bp-6],ax
	push	WORD PTR [bp+8]
	push	WORD PTR [bp+6]	;S
	lea	ax,WORD PTR [bp-140]
	push	ax
	mov	WORD PTR [bp-8],128
	lea	ax,WORD PTR [bp-8]
	mov	dx,ss
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,dx
	call	FAR PTR T_STRING
	lea	di,WORD PTR [bp-268]
	mov	si,ax
	push	ss
	pop	es
	mov	cx,64
	rep	movsw
	lea	ax,WORD PTR [bp-268]
	push	ss
	push	ax
	lea	ax,WORD PTR [bp-4]
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,ss
	call	FAR PTR _marker
	add	sp,4
; Line 119
	pop	si
	pop	di
	mov	sp,bp
	pop	bp
	ret	4

MARKER	ENDP
; Line 122
	PUBLIC	MARKERSPACING
MARKERSPACING	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _markerspacing
; Line 123
	mov	sp,bp
	pop	bp
	ret	4

MARKERSPACING	ENDP
; Line 126
	PUBLIC	MARKERSCALE
MARKERSCALE	PROC FAR
	push	bp
	mov	bp,sp
;	A = 6
	les	bx,DWORD PTR [bp+6]	;A
	call	FAR PTR __elds
	call	FAR PTR __dcvt
	sub	sp,8
	mov	bx,sp
	call	FAR PTR __fstdp
	call	FAR PTR _markerscale
; Line 127
	mov	sp,bp
	pop	bp
	ret	4

MARKERSCALE	ENDP
; Line 132
	PUBLIC	GRAPHTITLE
GRAPHTITLE	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,268
	push	di
	push	si
;	S = 6
	mov	ax,WORD PTR __FCclenv
	mov	dx,WORD PTR __FCclenv+2
	mov	WORD PTR [bp-12],ax
	mov	WORD PTR [bp-10],dx
	mov	WORD PTR [bp-2],128
	les	bx,DWORD PTR [bp-12]
	mov	ax,WORD PTR es:[bx+2]
	mov	WORD PTR [bp-6],ax
	push	WORD PTR [bp+8]
	push	WORD PTR [bp+6]	;S
	lea	ax,WORD PTR [bp-140]
	push	ax
	mov	WORD PTR [bp-8],128
	lea	ax,WORD PTR [bp-8]
	mov	dx,ss
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,dx
	call	FAR PTR T_STRING
	lea	di,WORD PTR [bp-268]
	mov	si,ax
	push	ss
	pop	es
	mov	cx,64
	rep	movsw
	lea	ax,WORD PTR [bp-268]
	push	ss
	push	ax
	lea	ax,WORD PTR [bp-4]
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,ss
	call	FAR PTR _graphtitle
	add	sp,4
; Line 133
	pop	si
	pop	di
	mov	sp,bp
	pop	bp
	ret	4

GRAPHTITLE	ENDP
; Line 136
	PUBLIC	DRAWTITLE
DRAWTITLE	PROC FAR
	push	bp
	mov	bp,sp
	call	FAR PTR _drawtitle
; Line 137
	mov	sp,bp
	pop	bp
	ret	

DRAWTITLE	ENDP
; Line 141
	PUBLIC	RANGE
RANGE	PROC FAR
	push	bp
	mov	bp,sp
;	A = 14
;	B = 10
;	AX = 6
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	les	bx,DWORD PTR [bp+10]	;B
	call	FAR PTR __elds
	call	FAR PTR __dcvt
	sub	sp,8
	mov	bx,sp
	call	FAR PTR __fstdp
	les	bx,DWORD PTR [bp+14]	;A
	call	FAR PTR __elds
	call	FAR PTR __dcvt
	sub	sp,8
	mov	bx,sp
	call	FAR PTR __fstdp
	call	FAR PTR _range
; Line 142
	mov	sp,bp
	pop	bp
	ret	12

RANGE	ENDP
FSWITCH_TEXT	ENDS
END
e 70
	PUBLIC	FIT
FIT	PROC FAR
	push	bp
	mov	bp,sp
;	I = 6
	les	bx,DWORD PTR [bp+6]	;I
	push	WORD PTR es:[bx]
	call	FAR PTR _fit
; Line 71
	mov	sp,bp
	pop	bp
	ret	4

FIT	ENDP
; Line 74
	PUBLIC	SKIP
SKIP	PROC FAR
	push	bp
	mov	bp,sp
;	vopl/src/msfort/make.msc010070000017730000310000000013110451256573700152030ustar00dghels00001250000004
zap_c.exe: zap_c.c
	cl zap_c.c

F = -FPi87
FFLAGS = -Ox -4Nt -Fa -Fonul -c -AL $(F)

OBJS = test.obj ctest.obj faxis.obj fplot.obj fsadjust.obj \
       flsfit.obj fswitch.obj

.for.asm:
	fl $(FFLAGS) $*.for
	zap_c < $*.asm > tmp.asm
	del $*.asm
 	ren tmp.asm $*.asm


.asm.obj:
	masm -Mx $*;

faxis.asm: faxis.for

fplot.asm: fplot.for

fsadjust.asm: fsadjust.for

flsfit.asm: flsfit.for

fswitch.asm: fswitch.for

faxis.obj: faxis.asm

fplot.obj: fplot.asm

fsadjust.obj: fsadjust.asm

flsfit.obj: flsfit.asm

fswitch.obj: fswitch.asm

test.obj: test.for
	fl -Ox -4Nt -c $(F) test.for

ctest.obj: ctest.c
	cl -AL -c ctest.c

test.exe: $(OBJS)
	link /NOE test+ctest+faxis+fplot+fsadjust+flsfit+fswitch,,,vogle;
vopl/src/msfort/zap_c.c010070000017730000310000000005400451256574000150170ustar00dghels00001250000004#include <stdio.h>

main()
{
	int	c1, c2, c3;

	while ((c1 = getchar()) != EOF) {
		if (c1 == '_') {
			if ((c2 = getchar()) == 'c') {
				if ((c3 = getchar()) == '_') {
					putchar(c3);
				} else {
					putchar(c1);
					putchar(c2);
					putchar(c3);
				}
			} else {
				putchar(c1);
				putchar(c2);
			}
		} else {
			putchar(c1);
		}
	}
}
			
vopl/src/msfort/faxis.asm010070000017730000310000000035760444267605600154140ustar00dghels00001250000004;	Static Name Aliases
;
	TITLE   faxis.for
	NAME    faxis

	.8087
FAXIS_TEXT	SEGMENT  BYTE PUBLIC 'CODE'
FAXIS_TEXT	ENDS
_DATA	SEGMENT  WORD PUBLIC 'DATA'
_DATA	ENDS
CONST	SEGMENT  WORD PUBLIC 'CONST'
CONST	ENDS
_BSS	SEGMENT  WORD PUBLIC 'BSS'
_BSS	ENDS
DGROUP	GROUP	CONST, _BSS, _DATA
	ASSUME  CS: FAXIS_TEXT, DS: DGROUP, SS: DGROUP, ES: DGROUP
EXTRN	__acrtused:ABS
EXTRN	_axistitle:FAR
EXTRN	_drawaxis:FAR
EXTRN	_drawaxes2:FAR
EXTRN	_drawaxes:FAR
EXTRN	T_STRING:FAR
EXTRN	__FCclenv:DWORD
FAXIS_TEXT      SEGMENT
; Line 22
	PUBLIC	AXISTITLE
AXISTITLE	PROC FAR
	push	bp
	mov	bp,sp
	sub	sp,268
	push	di
	push	si
;	T = 10
;	AX = 6
	mov	ax,WORD PTR __FCclenv
	mov	dx,WORD PTR __FCclenv+2
	mov	WORD PTR [bp-12],ax
	mov	WORD PTR [bp-10],dx
	mov	WORD PTR [bp-2],128
	les	bx,DWORD PTR [bp-12]
	mov	ax,WORD PTR es:[bx+2]
	mov	WORD PTR [bp-6],ax
	push	WORD PTR [bp+12]
	push	WORD PTR [bp+10]	;T
	lea	ax,WORD PTR [bp-140]
	push	ax
	mov	WORD PTR [bp-8],128
	lea	ax,WORD PTR [bp-8]
	mov	dx,ss
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,dx
	call	FAR PTR T_STRING
	lea	di,WORD PTR [bp-268]
	mov	si,ax
	push	ss
	pop	es
	mov	cx,64
	rep	movsw
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	lea	ax,WORD PTR [bp-268]
	push	ss
	push	ax
	lea	ax,WORD PTR [bp-4]
	mov	WORD PTR __FCclenv,ax
	mov	WORD PTR __FCclenv+2,ss
	call	FAR PTR _axistitle
	add	sp,6
; Line 23
	pop	si
	pop	di
	mov	sp,bp
	pop	bp
	ret	8

AXISTITLE	ENDP
; Line 27
	PUBLIC	DRAWAXIS
DRAWAXIS	PROC FAR
	push	bp
	mov	bp,sp
;	AX = 6
	les	bx,DWORD PTR [bp+6]	;AX
	push	WORD PTR es:[bx]
	call	FAR PTR _drawaxis
; Line 28
	mov	sp,bp
	pop	bp
	ret	4

DRAWAXIS	ENDP
; Line 31
	PUBLIC	DRAWAXES2
DRAWAXES2	PROC FAR
	push	bp
	mov	bp,sp
	call	FAR PTR _drawaxes2
; Line 32
	mov	sp,bp
	pop	bp
	ret	

DRAWAXES2	ENDP
; Line 35
	PUBLIC	DRAWAXES
DRAWAXES	PROC FAR
	push	bp
	mov	bp,sp
	call	FAR PTR _drawaxes
; Line 36
	mov	sp,bp
	pop	bp
	ret	

DRAWAXES	ENDP
FAXIS_TEXT	ENDS
END
vopl/src/msfort/test.for010070000017730000310000000062760451256574000152620ustar00dghels00001250000004
	program test
c
c Test vopl Fortran interfaces
c
	character *40 title
	character *1 ax

	real x(5), y(5)
	data x/0.0, 1.0, 2.0, 3.0, 4.0/
	data y/10.0, 11.0, 12.0, 13.0, 14.0/

	title = 'A Simple Test Title'
	ax = 'x'
	n = 5

	print*,'Calling axistitle(title, ax)'
	call axistitle(title, ax)

	print*,'Calling drawaxis(ax)'
	call drawaxis(ax)

	print*,'Calling axistitle(''Bonky'', ax)'
	call axistitle('Bonky', ax)

	print*,'Calling drawaxis(''x'')'
	call drawaxis('x')
	
	print*,'Calling drawaxes2'
	call drawaxes2

	print*,'Calling drawaxes'
	call drawaxes

	print*,'Calling plot2(x, y, n)'
	call plot2(x, y, n)

	print*,'Calling adjustscale(x, n, ax)'
	call adjustscale(x, n, ax)

	print*,'Calling adjustscale(x, 5, ''y'')'
	call adjustscale(y, 5, 'y')

	print*,'Calling fit(2)'
	call fit(2)

	print*,'Calling fit(n)'
	call fit(n)

	print*,'Calling skip(2)'
	call skip(2)

	print*,'Calling skip(n)'
	call skip(n)

	print*,'Calling endslopes(1.0, 11.0)'
	call endslopes(1.0, 11.0)

	a = 2.0
	b = 33.3
	print*,'Calling endslopes(a = 2.0, b = 33.3)'
	call endslopes(a, b)

	print*,'Calling gridspacing(2)'
	call gridspacing(2)

	print*,'Calling gridspacing(n)'
	call gridspacing(n)

	print*,'Calling scaling(2, ax)'
	call scaling(2, ax)

	print*,'Calling scaling(n, ax)'
	call scaling(n, ax)

	print*,'Calling scaling(n, ''x'')'
	call scaling(n, 'x')

	print*,'Calling scaling(3, ''x'')'
	call scaling(3, 'x')

	print*,'Calling tickmarks(2, ax)'
	call tickmarks(2, ax)

	print*,'Calling tickmarks(n, ax)'
	call tickmarks(n, ax)

	print*,'Calling stickmarks(n, ''x'')'
	call tickmarks(n, 'x')

	print*,'Calling tickmarks(3, ''x'')'
	call tickmarks(3, 'x')

	print*,'Calling tickspacing(2, ax)'
	call tickspacing(2, ax)

	print*,'Calling tickspacing(n, ax)'
	call tickspacing(n, ax)

	print*,'Calling stickspacing(n, ''x'')'
	call tickspacing(n, 'x')

	print*,'Calling tickspacing(3, ''x'')'
	call tickspacing(3, 'x')

	print*,'Calling annotate(''%f.3'', ax)'
	call annotate('%f.3', ax)

	print*,'Calling annotate(title, ax)'
	call annotate(title, ax)

	print*,'Calling annotate(title, ''x'')'
	call annotate(title, 'x')

	print*,'Calling arrayindex(10)'
	call arrayindex(10)

	print*,'Calling arrayindex(n)'
	call arrayindex(n)

	print*,'Calling axisintersection(1.0, 11.0)'
	call axisintersection(1.0, 11.0)

	a = 2.0
	b = 33.3
	print*,'Calling axisintersection(a = 2.0, b = 33.3)'
	call axisintersection(a, b)

	print*,'Calling marker(''Hello there'')'
	call marker('Hello there')

	print*,'Calling marker(title)'
	call marker(title)

	print*,'Calling markerspacing(10)'
	call markerspacing(10)

	print*,'Calling markerspacing(n)'
	call markerspacing(n)

	print*,'Calling markerscale(11.5)'
	call markerscale(11.5)

	print*,'Calling markerscale(a)'
	call markerscale(a)

	print*,'Calling graphtitle(''Hello there'')'
	call graphtitle('Hello there')

	print*,'Calling graphtitle(title)'
	call graphtitle(title)

	print*,'Calling drawtitle'
	call drawtitle

	print*,'Calling range(a, b, ax)'
	call range(a, b, ax)

	print*,'Calling range(22.3, 44.2, ax)'
	call range(22.3, 44.2, ax)

	print*,'Calling range(22.3, 44.2, ''y'')'
	call range(22.3, 44.2, 'y')


	print*,'Calling degree(10)'
	call degree(10)

	print*,'Calling degree(n)'
	call degree(n)

	stop
	end
vopl/src/msfort/faxis.for010070000017730000310000000010640451256573600154100ustar00dghels00001250000004	interface to subroutine C_axistitle[c]
     + (title[reference], ax)
	character *(*) title
	character *1 ax
	end

	interface to subroutine C_drawaxis[c](ax)
	character *1 ax
	end

	interface to subroutine C_drawaxes2[c]
	end

	interface to subroutine C_drawaxes[c]
	end

	subroutine axistitle(t, ax)
	character *(*) t
	character *128 t_string
	character *1 ax
	
	call C_axistitle(t_string(t), ax)
	end

	subroutine drawaxis(ax)
	character *1 ax
	call C_drawaxis(ax)
	end

	subroutine drawaxes2
	call C_drawaxes2
	end

	subroutine drawaxes
	call C_drawaxes
	end


vopl/src/msfort/flsfit.for010070000017730000310000000001510451256573600155610ustar00dghels00001250000004	interface to subroutine C_degree[c](i)
	integer *2 i
	end

	subroutine degree(i)
	call C_degree(i)
	end
vopl/src/msfort/ctest.c010070000017730000310000000035510451256573600150570ustar00dghels00001250000004#include <stdio.h>

/*
 * C routines to test vopl Fortran/C interface
 */

void
axistitle(t, ax)
	char	*t, ax;
{
	printf("\naxistitle: %s, %c\n", t, ax);
}

void
drawaxis(ax)
	char	ax;
{
	printf("\ndrawaxis: %c\n", ax);
}

void
drawaxes()
{
	printf("\ndrawaxes:\n");
}
	
void
drawaxes2()
{
	printf("\ndrawaxes2:\n");
}

void
plot2(x, y, n)
	float	x[], y[];
	int	n;
{
	int	i;
	printf("\nplot2: n = %d\n", n);

	for (i = 0; i < n; i++)
		printf("x[%d] = %f, y[%d] = %f\n", i, x[i], i, y[i]);
}

void
adjustscale(x, n, ax)
	float	x[];
	int	n;
	char	ax;
{
	int	i;

	printf("\nadjustscale: n = %d, ax = %c\n", n, ax);
	for (i = 0; i < n; i++)
		printf("x[%d] = %f\n", i, x[i]);
}

void
fit(i)
	int	i;
{
	printf("\nfit: %d\n", i);
}

void
skip(i)
	int	i;
{
	printf("\nskip: %d\n", i);
}

void
endslopes(a, b)
	float	a, b;
{
	printf("\nendslopes: %f %f\n", a, b);
}

void
gridspacing(i)
	int	i;
{
	printf("\ngridspacing: %d\n", i);
}

void
scaling(i, ax)
	int	i;
	char	ax;
{
	printf("\nscaling: %d, %c\n", i, ax);
}

void
tickmarks(i, ax)
	int	i;
	char	ax;
{
	printf("\ntickmarks: %d, %c\n", i, ax);
}

void
tickspacing(i, ax)
	int	i;
	char	ax;
{
	printf("\ntickspacing: %d, %c\n", i, ax);
}

void
annotate(s, ax)
	char	*s;
	char	ax;
{
	printf("\nannotate: %s, %c\n", s, ax);
}

void
arrayindex(i)
	int	i;
{
	printf("\narrayindex: %d\n", i);
}

void
axisintersection(a, b)
	float	a, b;
{
	printf("\naxisintersection: %f %f\n", a, b);
}

void
marker(s)
	char	*s;
{
	printf("\nmarker: %s\n", s);
}

void
markerspacing(i)
	int	i;
{
	printf("\nmarkerspacing: %d\n", i);
}

void
markerscale(i)
	float	i;
{
	printf("\nmarkerscale: %f\n", i);
}

void
graphtitle(s)
	char	*s;
{
	printf("\ngraphtitle: %s\n", s);
}

void
drawtitle()
{
	printf("\ndrawtitle:\n");
}

void
range(a, b, ax)
	float	a, b;
	char	ax;
{
	printf("\nrange: %f %f %c\n", a, b, ax);
}

void
degree(i)
	int	i;
{
	printf("\ndegree: %d\n", i);
}
vopl/src/msfort/makefile.msc010070000017730000310000000004510451256574000160410ustar00dghels00001250000004zap_c.exe: zap_c.c
	cl zap_c.c

F = -FPi87
FFLAGS = -Ox -4Nt -Fa -Fonul -c -AL $(F)

.for.asm:
	fl $(FFLAGS) $*.for
	zap_c < $*.asm > tmp.asm
	del $*.asm
 	ren tmp.asm $*.asm

faxis.asm: faxis.for

fplot.asm: fplot.for

fsadjust.asm: fsadjust.for

flsfit.asm: flsfit.for

fswitch.asm: fswitch.for
vopl/src/axis.c010070000017730000310000000373520700224310700133530ustar00dghels00001250000004#include <stdio.h>
#include <string.h>
#include "vopl.h"

void	log_axis(), lin_axis();

extern	double log10();
extern	double alog10();
extern	double pow();

/*
 * formatlabel
 *
 *	chose a "nice" format for an axis label, awful at the moment.
 */
void
formatlabel(
	float	alabel,
	char	*form)
{
	int	i, j;

	if (ABS(alabel) < 1.0e-9)
		alabel = 0.0;

	if ((ABS(alabel) > 999999.0) || (ABS(alabel) < 0.000001))
		sprintf(form, "%.4g", alabel);
	else 
		sprintf(form, "%f", alabel);

	/*
	 * if there is no 'e' in there or there is a dot then
	 * eat trailing zeros.....
	 */
	if ((strchr(form, 'e') == (char *)NULL &&
	    strchr(form, 'E') == (char *)NULL) &&
	    strchr(form, '.') != (char *)NULL) {
		i = strlen(form) - 1;
		while (i >= 0 && form[i] == '0') 
			i--;

		if (form[i] == '.')
			i--;

		form[++i] = '\0';
		if (form[0] == '\0') {
			form[0] = '0';
			form[1] = '\0';
		}
	}
}

/*
 * axistitle
 *
 *	Draws an x, y or z axis, with or without annotation, tickmarks etc
 */
void
axistitle(
	char	*title,
	char	ax)
{
	char	**s, err_buf[EBUF_SIZE];

	/*
	 * save the goddam title somewhere....
	 */
	switch (ax) {
	case 'x':
	case 'X':
		s = &plotdev.axes[XIND].title;
		break;
	case 'y':
	case 'Y':
		s = &plotdev.axes[YIND].title;
		break;
	case 'z':
	case 'Z':
		s = &plotdev.axes[ZIND].title;
		break;
	case 's':
	case 'S':
		s = &plotdev.axes[XSEC].title;
		break;
	case 't':
	case 'T':
		s = &plotdev.axes[YSEC].title;
		break;
	default:
		sprintf(err_buf, "axistitle: unknown axis '%c'", ax);
		vopl_error(err_buf);
	}

	*s = savestr(*s, title);
}

/*
 * drawaxis
 *
 *	Draws an x, y or z axis, with or without annotation, tickmarks etc
 */
void
drawaxis(
	char	axis)
{
	int	ind;
	char	err_buf[EBUF_SIZE];

	switch (axis) {
	case 'x':
	case 'X':
		ind = XIND;
		break;
	case 'y':
	case 'Y':
		ind = YIND;
		break;
	case 'z':
	case 'Z':
		ind = ZIND;
		break;
	case 's':
	case 'S':
		ind = XSEC;
		break;
	case 't':
	case 'T':
		ind = YSEC;
		break;
	default:
		sprintf(err_buf, "drawaxis: unknown axis '%c'", axis);
		vopl_error(err_buf);
	}

	if (!plotdev.axes[ind].scaleset) { 
		plotdev.axes[ind].min = -1.0;
		plotdev.axes[ind].max = 1.0;
	}

	if (plotdev.axes[ind].scaling == LOGARITHMIC)
		log_axis(ind);
	else
		lin_axis(ind);
}

/*
 * drawaxes2
 *
 *	Draws the x and y axes, with or without annotation, tickmarks etc
 */
void
drawaxes2(void)
{
	int	axis;

	for (axis = 0; axis < AXES; axis++)
		if (!plotdev.axes[axis].scaleset) { 
			plotdev.axes[axis].min = -1.0;
			plotdev.axes[axis].max = 1.0;
		}

	if (plotdev.axes[XIND].scaling == LOGARITHMIC) 
		log_axis(XIND);
	else
		lin_axis(XIND);

	if (plotdev.axes[YIND].scaling == LOGARITHMIC) 
		log_axis(YIND);
	else 
		lin_axis(YIND);
}

/*
 * drawaxes
 *
 *	Draws an x, y, and z axes, with or without annotation, tickmarks etc
 */
void
drawaxes(void)
{
	int	axis;

	for (axis = 0; axis < AXES; axis++) {
		if (!plotdev.axes[axis].scaleset) { 
			plotdev.axes[axis].min = -1.0;
			plotdev.axes[axis].max = 1.0;
		}

		if (plotdev.axes[axis].scaling == LOGARITHMIC) 
			log_axis(axis);
		else
			lin_axis(axis);
	}
}

/*
 * lin_axis
 *
 *	draw a linear axis
 */
void
lin_axis(
	int	axis)
{
	float 		x, y, sx, sy;
	float		ssx, ssy, tinc, alabel;
	int 		i, j, count;
        char		form[50], err_buf[EBUF_SIZE];
	axisdata	ax;

	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	clipping(0);

	switch (axis) {
	case XIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMIN);
		draw2(XMAX, YMIN);

		textang(0.0);
		centertext(1);

		ax = plotdev.axes[XIND];

		x = ax.max - ax.min;
		count = x / ax.div + 0.5;

		xcentertext();
		topjustify();

		tinc = (XMAX - XMIN) / x * ax.div;
		for (i = 0; i <= count; i++) {
			sx = i * tinc + XMIN;

			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssx = sx + tinc * j / ax.minorticks;

					move2(ssx, YMIN);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(ssx, YMIN - 0.75 * LINELEN);
					else
						draw2(ssx, YMIN - 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}
		

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMIN);
				draw2(sx, YMIN - LINELEN);
			}
		
			if (ax.annotate) {
				alabel = ax.min + ax.div * (ax.mod ? (i % ax.mod) : i);
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				move2(sx, YMIN - 1.2 * LINELEN);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			textang(0.0);
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMIN - 6.0 * TEXTWIDTH);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			move2(x, y);
			drawstr(ax.title);
		}
		break;
	case YIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMIN, YMIN);
		draw2(XMIN, YMAX);

		textjustify(0);
		ycentertext();
		rightjustify();

		ax = plotdev.axes[YIND];

		y = ax.max - ax.min;
		tinc = (YMAX - YMIN) / y * ax.div;
		count = y / ax.div + 0.5;

		for (i = 0; i <= count; i++) {
			sy = i * tinc + YMIN;
			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssy = sy + tinc * j / ax.minorticks;

					move2(XMIN, ssy);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(XMIN - 0.75 * LINELEN, ssy);
					else
						draw2(XMIN - 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMIN, sy);
				draw2(XMIN - LINELEN, sy);
			}

			if (ax.annotate) {
				alabel = ax.min + ax.div * i;
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(XMIN - strlength(form) - 2 * LINELEN, sy - TEXTHEIGHT / 2);
				*/
				move2(XMIN - 1.2 * LINELEN, sy);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			x = XMIN - 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
			textang(0.0);
		}
		break;
	case ZIND:
		vopl_error("Z-Axis not yet implemented");
		break;
	case XSEC:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMAX);
		draw2(XMAX, YMAX);

		textang(0.0);
		centertext(1);

		ax = plotdev.axes[XSEC];

		x = ax.max - ax.min;
		count = x / ax.div + 0.5;

		xcentertext();
		bottomjustify();

		tinc = (XMAX - XMIN) / x * ax.div;
		for (i = 0; i <= count; i++) {
			sx = i * tinc + XMIN;

			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssx = sx + tinc * j / ax.minorticks;

					move2(ssx, YMAX);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(ssx, YMAX + 0.75 * LINELEN);
					else
						draw2(ssx, YMAX + 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}
		

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMAX);
				draw2(sx, YMAX + LINELEN);
			}
		
			if (ax.annotate) {
				alabel = ax.min + ax.div * i;
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(sx, YMIN - LINELEN - 1.1 * TEXTHEIGHT / 2);
				*/
				move2(sx, YMAX + 1.2 * LINELEN);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			textang(0.0);
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMAX - 6.0 * TEXTWIDTH);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			move2(x, y);
			drawstr(ax.title);
		}
		break;
	case YSEC:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMAX, YMIN);
		draw2(XMAX, YMAX);

		textjustify(0);
		ycentertext();
		leftjustify();

		ax = plotdev.axes[YSEC];

		y = ax.max - ax.min;
		tinc = (YMAX - YMIN) / y * ax.div;
		count = y / ax.div + 0.5;

		for (i = 0; i <= count; i++) {
			sy = i * tinc + YMIN;
			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssy = sy + tinc * j / ax.minorticks;

					move2(XMAX, ssy);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(XMAX + 0.75 * LINELEN, ssy);
					else
						draw2(XMAX + 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMAX, sy);
				draw2(XMAX + LINELEN, sy);
			}

			if (ax.annotate) {
				alabel = ax.min + ax.div * i;
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(XMIN - strlength(form) - 2 * LINELEN, sy - TEXTHEIGHT / 2);
				*/
				move2(XMAX + 1.2 * LINELEN, sy);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			x = XMAX + 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
			textang(0.0);
		}
		break;
	default:
		sprintf(err_buf, "axis: unknown axis: %d", axis);
		vopl_error(err_buf);
	}

	popviewport();
	popmatrix();
	popattributes();
	clipping(1);
}


/*
 * log_axis
 *
 *	Does a logarithmic axis with exponential style annotation
 */
void
log_axis(
	int	axis)
{

	float 		x, y, sx, sy;
	float		ssx, ssy, tinc, mtinc, alabel, ldiv;
	int 		i, j;
        char		form[21], err_buf[EBUF_SIZE];
	axisdata	ax;
	
	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	clipping(0);

	switch (axis) {
	case XIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMIN);
		draw2(XMAX, YMIN);

		textang(0.0);
		centertext(0);

		ax = plotdev.axes[XIND];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		tinc = (XMAX - XMIN) / (ax.nticks);
		for (i = 0; i <= ax.nticks; i++) {

			sx = i * tinc + XMIN;
			/* Minor ticks */
			if (i < ax.nticks && ax.minorticks) 
				for (j = 1; j < 10; j++) {
					ssx = sx + tinc * log10((double)j);

					move2(ssx, YMIN);
					if (j == 5)
						draw2(ssx, YMIN - 0.75 * LINELEN);
					else
						draw2(ssx, YMIN - 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid)
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMIN);
				draw2(sx, YMIN - LINELEN);
			}
			
			if (ax.annotate) {
				formatlabel(alabel, form);

				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(sx + 0.5 * TEXTWIDTH, YMIN - LINELEN - 0.8 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), 0.0);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.3 * TEXTWIDTH, -0.9 * TEXTHEIGHT);
				drawstr("10");
			}
			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMIN - 6.0 * TEXTWIDTH);
			move2(x, y);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	case YIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMIN, YMIN);
		draw2(XMIN, YMAX);

		ax = plotdev.axes[YIND];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		centertext(0);

		tinc = (YMAX - YMIN) / (ax.nticks);

		for (i = 0; i <= ax.nticks; i++) {
			sy = i * tinc + YMIN;

			if (i < ax.nticks && ax.minorticks)
				for (j = 1; j < 10; j++) {
					ssy = sy + tinc * log10((double)j);

					move2(XMIN, ssy);
					if (j == 5)
						draw2(XMIN - 0.75 * LINELEN, ssy);
					else
						draw2(XMIN - 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMIN, sy);
				draw2(XMIN - LINELEN, sy);
			}

			if (ax.annotate) {
				formatlabel(alabel, form);
				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(XMIN - strlength(form) -1.5 * LINELEN, sy + 0.5 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), -0.75 * TEXTHEIGHT);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.1 * TEXTWIDTH, 0.0);
				drawstr("10");
			}

			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			x = XMIN - 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	case ZIND:
		vopl_error("Z-Axis not yet implemented");
		break;
	case XSEC:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMAX);
		draw2(XMAX, YMAX);

		textang(0.0);
		centertext(0);

		ax = plotdev.axes[XSEC];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		tinc = (XMAX - XMIN) / (ax.nticks);
		for (i = 0; i <= ax.nticks; i++) {

			sx = i * tinc + XMIN;
			/* Minor ticks */
			if (i < ax.nticks && ax.minorticks) 
				for (j = 1; j < 10; j++) {
					ssx = sx + tinc * log10((double)j);

					move2(ssx, YMAX);
					if (j == 5)
						draw2(ssx, YMAX + 0.75 * LINELEN);
					else
						draw2(ssx, YMAX + 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid)
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMAX);
				draw2(sx, YMAX + LINELEN);
			}
			
			if (ax.annotate) {
				formatlabel(alabel, form);

				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(sx + 0.5 * TEXTWIDTH, YMAX + LINELEN + 0.8 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), 0.0);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.3 * TEXTWIDTH, -0.9 * TEXTHEIGHT);
				drawstr("10");
			}
			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMAX + 6.0 * TEXTWIDTH);
			move2(x, y);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	case YSEC:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMAX, YMIN);
		draw2(XMAX, YMAX);

		ax = plotdev.axes[YSEC];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		centertext(0);

		tinc = (YMAX - YMIN) / (ax.nticks);

		for (i = 0; i <= ax.nticks; i++) {
			sy = i * tinc + YMIN;

			if (i < ax.nticks && ax.minorticks)
				for (j = 1; j < 10; j++) {
					ssy = sy + tinc * log10((double)j);

					move2(XMAX, ssy);
					if (j == 5)
						draw2(XMAX + 0.75 * LINELEN, ssy);
					else
						draw2(XMAX + 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMAX, sy);
				draw2(XMAX +LINELEN, sy);
			}

			if (ax.annotate) {
				formatlabel(alabel, form);
				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(XMAX + strlength(form) +1.5 * LINELEN, sy + 0.5 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), -0.75 * TEXTHEIGHT);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.1 * TEXTWIDTH, 0.0);
				drawstr("10");
			}

			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			x = XMAX + 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	default:
		sprintf(err_buf, "axis: unknown axis: %d", axis);
		vopl_error(err_buf);
	}

	popviewport();
	popmatrix();
	popattributes();
	clipping(1);
}
form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(XMIN - strlength(form) - 2 * LINELEN, sy - TEXTHEIGHT / 2);
				*/
				move2(XMIN - 1.2 * LINELEN, sy);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			x = XMIN - 7.0 * TEXTWIvopl/src/spline.c010070000017730000310000000042150700111570100136660ustar00dghels00001250000004#include "vopl.h"

/* 
 *  spline
 *
 *     calculates a cubic spline through the data points
 *     
 */
void 
spline(
	float 	*x,
	float	*y,
	int 	np)
{
	float 	*l, *u, *z, *a, *b, *c, *d, *h, *xx;
	float	*alpha;
	int 	delta;
	float 	*newm1();
	float 	**newm2();

	float 	t, xdivm, ax, ay, xdiv;
	int 	n, i, j;

	/* get memory for variables */

	h = newm1(np);
	l = newm1(np);
	u = newm1(np);
	z = newm1(np);
	a = newm1(np);
	b = newm1(np);
	c = newm1(np);
	d = newm1(np);
	xx = newm1(np);
	alpha = newm1(np);

	n = np - 2;
	for (i = 0; i <= n; i++) {
		xx[i] = WhatX(x[i]);
		h[i] = WhatX(x[i + 1]) - xx[i];
		a[i] = WhatY(y[i]);
	}

	n = np - 1;
	xx[n] = WhatX(x[n]);
	a[n] = WhatY(y[n]);

	if (plotdev.splinetype == CLAMPED) {
		alpha[0] = 3 * (a[1] - a[0]) / h[0] - 3 * plotdev.s1;
		alpha[n] = 3 * plotdev.sn - 3 * (a[n] - a[n - 1]) / h[n - 1];
	}

	for (i = 1; i < n; i++) 
		alpha[i] = 3 * (a[i + 1] * h[i - 1] - a[i] * (xx[i + 1] - xx[i - 1])  
			   + a[i - 1] * h[i]) / (h[i - 1] * h[i]);
	
	if (plotdev.splinetype == CLAMPED) {
		l[0] = 2 * h[0];
		u[0] = 0.5;
		z[0] = alpha[0] / l[0];
	} else {
		l[0] = 1.0;
		u[0] = 0.0;
		z[0] = 0.0;
	}

	for (i = 1; i <= n; i++) {
		l[i] = 2 * (xx[i + 1] - xx[i - 1]) - h[i - 1] * u[i - 1];
		u[i] = h[i] / l[i]; 
		z[i] = (alpha[i] - (h[i - 1] * z[i - 1])) / l[i];
	}

	if (plotdev.splinetype == CLAMPED) {
		l[n] = h[n- 1] * (2.0 - u[n - 1]);
		z[n] = (alpha[n] - h[n - 1] * z[n - 1]) / l[n];
		c[n] = z[n];
	} else {
		l[n] = 1.0;
		z[n] = 0.0;
		c[n] = 0.0;
	}

	for (j = n - 1; j >= 0; j--) {
		c[j] = z[j] - (u[j] * c[j + 1]);
		b[j] = (a[j + 1] - a[j]) / h[j] - (h[j] * (c[j + 1] + 2 * c[j]) / 3.0);
		d[j] = (c[j + 1] - c[j]) / (3.0 * h[j]);
	}


	/*
	 * Draw the trace
	 */

	delta = (int)((float)plotdev.precision / (np - 1));
	ay = a[0]; /*  + b[0] * t + c[0] * t * t + d[0] * t * t * t;*/
	move2(xx[0], ay);

	for (j = 0; j <= n - 1; j++ ) {
		xdiv = h[j] / (float)delta;
		for (t = 0.0; t <= h[j]; t += xdiv) {
			ax = xx[j] + t;
			ay = a[j]  + b[j] * t + c[j] * t * t + d[j] * t * t * t;
			draw2(ax, ay);
		}
	}

	free(h);
	free(l);
	free(u);
	free(z);
	free(a);
	free(b);
	free(c);
	free(d);
	free(xx);
	free(alpha);
}
vopl/src/cubicsp.c010070000017730000310000000020110700146522100140210ustar00dghels00001250000004#include "vopl.h"

/*
 * 	cubicsp
 *
 *	Fit cubic splines using Cardinal splines and vogle "curve" routine
 */
void
cubicsp(
	float	*x,
	float	*y,
	int   	n)
{
	float	geom[4][3], x0, y0, xnp1, ynp1;
	int	i, j;

	/*
	 *  Make fake end points
	 */
	x0 = 2.0 * WhatX(x[0]) - WhatX(x[1]);
	y0 = 2.0 * WhatY(y[0]) - WhatY(y[1]);
	xnp1 = 2.0 * WhatX(x[n-1]) - WhatX(x[n-2]);
	ynp1 = 2.0 * WhatY(y[n-1]) - WhatY(y[n-2]);

	/*
	 *  Do first segment
	 */
	for (i = 0; i < 3; i++)
		for (j = 0; j < 4; j++)
			geom[j][i] = 0.0;

	geom[0][0] = x0;
	geom[0][1] = y0;
	for (i = 1; i < 4; i++) {
		geom[i][0] = WhatX(x[i-1]);
		geom[i][1] = WhatY(y[i-1]);
	}

	curve(geom);

	/*
         * In between curve segments
	 */
	for (j = 0; j < n-3; j++) {
		for (i = 0; i < 4; i++) {
			geom[i][0] = WhatX(x[i+j]);
			geom[i][1] = WhatY(y[i+j]);
		}

		curve(geom);
	}

	/*
     	 *  Last segment
	 */
	for (i = 0; i < 3; i++) {
		geom[i][0] = WhatX(x[n+i-3]);
		geom[i][1] = WhatY(y[n+i-3]);
	}

	geom[3][0] = xnp1;
	geom[3][1] = ynp1;
	curve(geom);
}
vopl/src/err.c010070000017730000310000000002740700224727600132030ustar00dghels00001250000004#include "vopl.h"

/*
 * vopl_error
 *
 *	Prints an error message.
 */
void
vopl_error(
	char	*str)
{
	if (vdevice.initialised)
		vexit();

	fprintf(stderr,"vopl: %s\n", str);
	exit(1);
}
vopl/src/flib.in010070000017730000310000000002640451256566600135230ustar00dghels00001250000004vopl.lib
Y
+adjustsc &
+axis &
+cubicsp &
+err &
+lsfit &
+mem &
+plot &
+savestr &
+ilinfit &
+scalers &
+spline &
+switches &
+faxis &
+fplot &
+fsadjust &
+fswitch &
+flsfit



vopl/src/plot.c010070000017730000310000000062350700224530200133600ustar00dghels00001250000004#include "vopl.h"

extern		double log10();
extern		double sqrt();

/*
 * plot2
 *
 *	display the 2-d graph described by x and y;
 */
void
plot2(
	float	x[],
	float	y[],
	int	n)
{
	int	i;
	char	err_buf[EBUF_SIZE];
	float	tx, ty, left, right, bottom, top;
	float	dashlen, a, b, c, d;

	/*
	 * Set the view up so that clipping happens...
	 */

	pushmatrix();
	pushviewport();
	pushattributes();

	getviewport(&left, &right, &bottom, &top);

	viewport(left + (1.0 + XMIN) / 2.0 * (right - left),
		right - (1.0 - XMAX) / 2.0 * (right - left),
		bottom + (1.0 + YMIN) / 2.0 * (top - bottom),
		top - (1.0 - YMAX) / 2.0 * (top - bottom));

	if (!plotdev.axes[XIND].scaleset)
		adjustscale(x, n, 'x');

	if (!plotdev.axes[YIND].scaleset)
		adjustscale(y, n, 'y');

	ortho2(WhatX(plotdev.axes[XIND].min),
	       WhatX(plotdev.axes[XIND].max),
	       WhatY(plotdev.axes[YIND].min),
	       WhatY(plotdev.axes[YIND].max));

	/*
	 * Set dash len so that we get about 200 dashes in one plot
	 */
	a = WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min);
	b = WhatY(plotdev.axes[YIND].max) - WhatY(plotdev.axes[YIND].min);

	dashlen = sqrt(a*a + b*b) / 100.0;
	dashlen = 0.015;
	setdash(dashlen);

	/*
	 * Do whatever type of fit is required....
	 */
	switch (plotdev.fit) {
	case NO_LINES:
		/*
		 * Don't do a sniveling thing......
		 */
		break;

	case STRAIGHT_LINE:
		/*
		 * Just draw it.....
		 */

		move2(WhatX(x[0]), WhatY(y[0]));
		for (i = 1; i < n; i++)
			draw2(WhatX(x[i]), WhatY(y[i]));

		break;
	case LEAST_SQUARE:
		/*
		 * Do an orthogonal polynomial fit.....
		 */

		/*
		 * If degree is zero then simply plot a line y = average y
		 */
		if (plotdev.degree == 0)
			avefit(x, y, n);
		/*
		 * If degree is 1 then it's a simple linear least square fit...
		 */
		else if (plotdev.degree == 1)
			llsfit(x, y, n);
		else
			orthofit(x, y, plotdev.degree, n);
		break;
	case CUBIC_SPLINE:
		/*
		 * Do cubic spline fits......
		 */
		/*
		 * If no endslopes have been used then use VOGLE curve
		 * routine with cardinal splines.
		 */
		if (plotdev.splinetype == FREE) {
			curvebasis(cardinal);
			curveprecision(20);
			cubicsp(x, y, n);
		} else
			spline(x, y, n);
		break;
	case POWER_EQN:
		/*
		 * do power equation fit
		 */
		pefit(x, y, n);
		break;
	case SGR_FIT:
		/*
		 * do a saturated growth rate fit
		 */
		sgrfit(x, y, n);
		break;
	default:
		sprintf(err_buf, "plot2: unknown fit type %d", plotdev.fit);
		vopl_error(err_buf);
	}

	/*
	 * Set up the marker size
	 */

	if (plotdev.markerspacing && plotdev.marker != (char *)NULL) {
		if (plotdev.markerscale != 0.0) {
			pushattributes();
			centertext(1);
			/*clipping(0);*/
			tx = plotdev.markerscale * TEXTWIDTH * (WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min));
			ty = plotdev.markerscale * TEXTHEIGHT * (WhatY(plotdev.axes[YIND].max) - WhatY(plotdev.axes[YIND].min));

			textsize(tx, ty);

			linestyle("");
			for (i = 0; i < n; i += plotdev.markerspacing) {
				move2(WhatX(x[i]), WhatY(y[i]) + 0.15 * ty);
				drawstr(plotdev.marker);
			}
			popattributes();
		} else
			for (i = 0; i < n; i += plotdev.markerspacing)
				point2(WhatX(x[i]), WhatY(y[i]));

	}

	popattributes();
	popviewport();
	popmatrix();
}
vopl/src/savestr.c010070000017730000310000000004720700224557300141000ustar00dghels00001250000004#include "vogle.h"
#include "vopl.h"
#include <string.h>

/*
 * savestr
 *
 *	Save a string of characters somewhere
 */
char *
savestr(
	char	*old,
	char	*string)
{
	char	*p;

	if (string == (char *)NULL)
		return ((char *)NULL);

	p = old;

	if (p != (char *)NULL)
		free(p);

	p = strdup(string);

	return(p);
}
vopl/src/switches.c010070000017730000310000000231150700224653100142340ustar00dghels00001250000004#include <stdio.h>
#include <math.h>
#include "vopl.h"

static	char	charbuf[10];

float	cardinal[4][4] = {
	{-0.5,	1.5,	-1.5,	0.5},
	{1.0,	-2.5,	2.0,	-0.5},
	{-0.5,	0.0,	0.5,	0.0},
	{0.0,	1.0,	0.0,	0.0}
};

/*
 * the initial structure
 */
vopldev plotdev = {
	0.0, 0.0,		/* s1, sn */
	45.0,			/* Hist hatch ang */
	0.75,			/* markerscale */
	STRAIGHT_LINE,		/* fit */
	2,			/* degree */
	0,			/* spline type */
	0,			/* hatch histograms? */
	0,			/* grid? */
	0, 1,			/* startind, arrayind */
	256, 1,			/* precision, markerspacing*/
	(char *)0,		/* marker */
	(char *)0,		/* graphtitle */
	{						/* x axis */
		{
			BLOODYBIG,	/* min */
			-BLOODYBIG, 	/* max */
			1.0,		/* div */
			LINEAR,		/* scaling */
			1,		/* annotate? */
			5,		/* nticks */
			1,		/* ntspacing */
			10,		/* minorticks */
			0,		/* scaleset */
			0,		/* forceticks */
			0,		/* mod */
			(char *)0,	/* format */
			(char *)0	/* title */
		},
		{						/* y axis */
			BLOODYBIG,	/* min */
			-BLOODYBIG, 	/* max */
			1.0,		/* div */
			LINEAR,		/* scaling */
			1,		/* annotate? */
			5,		/* nticks */
			1,		/* ntspacing */
			10,		/* minorticks */
			0,		/* scaleset */
			0,		/* forceticks */
			0,		/* mod */
			(char *)0,	/* format */
			(char *)0	/* title */
		},
		{						/* z axis */
			BLOODYBIG,	/* min */
			-BLOODYBIG, 	/* max */
			1.0,		/* div */
			LINEAR,		/* scaling */
			1,		/* annotate? */
			5,		/* nticks */
			1,		/* ntspacing */
			10,		/* minorticks */
			0,		/* scaleset */
			0,		/* forceticks */
			0,		/* mod */
			(char *)0,	/* format */
			(char *)0	/* title */
		},
    	        {					/* sec x axis */
			BLOODYBIG,	/* min */
			-BLOODYBIG, 	/* max */
			1.0,		/* div */
			LINEAR,		/* scaling */
			1,		/* annotate? */
			5,		/* nticks */
			1,		/* ntspacing */
			10,		/* minorticks */
			0,		/* scaleset */
			0,		/* forceticks */
			0,		/* mod */
			(char *)0,	/* format */
			(char *)0	/* title */
		},
		{						/* sec y axis */
			BLOODYBIG,	/* min */
			-BLOODYBIG, 	/* max */
			1.0,		/* div */
			LINEAR,		/* scaling */
			1,		/* annotate? */
			5,		/* nticks */
			1,		/* ntspacing */
			10,		/* minorticks */
			0,		/* scaleset */
			0,		/* forceticks */
			0,		/* mod */
			(char *)0,	/* format */
			(char *)0	/* title */
		}
	}
};

/*
 * fit
 *
 *	Specify the type of fit for a graph
 */
void
fit(
	int	type)
{
	char	err_buf[EBUF_SIZE];

	if (type < 0 || type > MAX_FIT) {
		sprintf(err_buf, "fit: unknown fit type: %d", type);
		vopl_error(err_buf);
	}

	plotdev.fit = type;
}

/*
 * skip
 *
 *	causes scaling and plotting to skip every n data points
 */
void
skip(
	int	n)
{
	plotdev.arrayind = n;
}

/*
 * endslopes
 *
 *	Specify the end slopes for a cubic spline fit.
 *	If No slopes have been specified, then we'll use
 *	the VOGLE curve routine.
 */
void
endslopes(
	float	a,
	float	b)
{
	plotdev.s1 = a;
	plotdev.sn = b;
	plotdev.splinetype = CLAMPED;
}

/*
 * gridspacing
 *
 *	Turns grids on or off
 */
void
gridspacing(
	int	spacing)
{
	plotdev.grid = spacing;
}

/*
 * scaling
 *
 *	Specify the type of scaling to be used for axis drawing
 * and graph plotting.
 */
void
scaling(
	int	type,
	char	axis)
{
	char	err_buf[EBUF_SIZE];

	switch (axis) {
	case 'x':
	case 'X':
		plotdev.axes[XIND].scaling = type;
		break;
	case 'y':
	case 'Y':
		plotdev.axes[YIND].scaling = type;
		break;
	case 'z':
	case 'Z':
		plotdev.axes[ZIND].scaling = type;
		break;
	case 's':
	case 'S':
		plotdev.axes[XSEC].scaling = type;
		break;
	case 't':
	case 'T':
		plotdev.axes[YSEC].scaling = type;
		break;
	default:
		sprintf(err_buf, "scaling: unknown axis '%c'", axis);
		vopl_error(err_buf);
	}
}

/*
 * tickmarks
 *
 *	Specify the number of tickmarks on an axis. For autoscaled
 *	axes (ie those using "adjustscale"), the number of tick marks
 *	may not come out exactly as specified.
 */
void
tickmarks(
	int	num,
	char	axis)
{
	char	err_buf[EBUF_SIZE];

	if (num < 0) {
		sprintf(err_buf,"tickmarks: number of tickmarks on axis '%c' must be >= 0 - was %d", axis, num);
		vopl_error(err_buf);
	} else {
		switch (axis) {
		case 'x':
		case 'X':
			plotdev.axes[XIND].nticks = num;
			plotdev.axes[XIND].forceticks = num ? 1 : 0;		
			break;
		case 'y':
		case 'Y':
			plotdev.axes[YIND].nticks = num;
			plotdev.axes[YIND].forceticks = num ? 1 : 0;		
			break;
		case 'z':
		case 'Z':
			plotdev.axes[ZIND].nticks = num;
			plotdev.axes[ZIND].forceticks = num ? 1 : 0;		
			break;
		case 's':
		case 'S':
			plotdev.axes[XSEC].nticks = num;
			plotdev.axes[XSEC].forceticks = num ? 1 : 0;		
			break;
		case 't':
		case 'T':
			plotdev.axes[YSEC].nticks = num;
			plotdev.axes[YSEC].forceticks = num ? 1 : 0;		
			break;
		default:
			sprintf(err_buf,"tickmarks: unknown axis '%c'", axis);
			vopl_error(err_buf);
		}

	}
}

/*
 * tickspacing
 *
 *	Specify the spacing of tickmarks on an axis. For autoscaled
 *	axes (ie those using "adjustscale"), the number of tick marks
 *	may not come out exactly as specified.
 */
void
tickspacing(
	int	num,
	char	axis)
{
	char	err_buf[EBUF_SIZE];

	if (num < 0) {
		sprintf(err_buf,"tickmarks: number of tickmarks on axis '%c' must be >= 0 - was %d", axis, num);
		vopl_error(err_buf);
	} else {
		switch (axis) {
		case 'x':
		case 'X':
			plotdev.axes[XIND].ntspacing = num;
			break;
		case 'y':
		case 'Y':
			plotdev.axes[YIND].ntspacing = num;
			break;
		case 'z':
		case 'Z':
			plotdev.axes[ZIND].ntspacing = num;
			break;
		case 's':
		case 'S':
			plotdev.axes[XSEC].ntspacing = num;
			break;
		case 't':
		case 'T':
			plotdev.axes[YSEC].ntspacing = num;
			break;
		default:
			sprintf(err_buf, "tickspacing: unknown axis '%c'", axis);
			vopl_error(err_buf);
		}
	}
}


/*
 * minorticks
 *
 *	Specify the number of minortickmarks bewteen each tick on an axis. 
 * 	On a log scaled axis, this simply says to draw/not draw the minor
 *	minor tick marks ... their number being always set to 10.
 */
void
minorticks(
	int	num,
	char	axis)
{
	char	err_buf[EBUF_SIZE];

	if (num < 0) {
		sprintf(err_buf,"minorticks: number of minor tickmarks on axis '%c' must be >= 0 - was %d", axis, num);
		vopl_error(err_buf);
	} else {
		switch (axis) {
		case 'x':
		case 'X':
			plotdev.axes[XIND].minorticks = num;
			break;
		case 'y':
		case 'Y':
			plotdev.axes[YIND].minorticks = num;
			break;
		case 'z':
		case 'Z':
			plotdev.axes[ZIND].minorticks = num;
			break;
		case 's':
		case 'S':
			plotdev.axes[XSEC].minorticks = num;
			break;
		case 't':
		case 'T':
			plotdev.axes[YSEC].minorticks = num;
			break;
		default:
			sprintf(err_buf,"minorticks: unknown axis '%c'", axis);
			vopl_error(err_buf);
		}
	}
}

/*
 * annotate
 *
 *	Turn on or off labeling of the drawn axes
 */
void
annotate(
	char	*format,
	char	axis)
{
	axisdata	*ax;
	char		err_buf[EBUF_SIZE];


	/*
	 * wooh Jimmy!
	 */
	switch (axis) {
	case 'x':
	case 'X':
		ax = &plotdev.axes[XIND];
		break;
	case 'y':
	case 'Y':
		ax = &plotdev.axes[YIND];
		break;
	case 'z':
	case 'Z':
		ax = &plotdev.axes[ZIND];
		break;
	case 's':
	case 'S':
		ax = &plotdev.axes[XSEC];
		break;
	case 't':
	case 'T':
		ax = &plotdev.axes[YSEC];
		break;
	default:
		sprintf(err_buf, "annotate: unknown axis '%c'", axis);
		vopl_error(err_buf);
	}

	ax->annotate = (format ? 1 : 0);
	ax->format = savestr(ax->format, format);
}

void
anotatemod(
	int	i,
	char	a)
{
	axisdata	*ax;

	switch(a) {
	case 'x':
	case 'X':
		ax = &plotdev.axes[XIND];
		break;
	case 'y':
	case 'Y':
		ax = &plotdev.axes[YIND];
		break;
	case 'z':
	case 'Z':
		ax = &plotdev.axes[ZIND];
		break;
	}

	ax->mod = i;
}

/*
 * arrayindex
 *
 *	How to index into the arrays passed to adjustscale and plot
 *	eg, increment the index by one or by more.
 *
 */
void
arrayindex(
	int	i)
{
	plotdev.arrayind = i;
}

/*
 * marker
 *
 *	Defines the current marker string to be used on subsequent
 *	plot calls.
 */
void
marker(
	char	*string)
{
	plotdev.marker = savestr(plotdev.marker, string);
}
		
/*
 * markerspacing
 *
 *	Sets the spacing for the markers.
 */
void
markerspacing(
	int	spacing)
{
	plotdev.markerspacing = spacing;
}

/*
 * markerscale
 *
 *	Defines a multiplicative scale factor (from the default) for
 *	the size of markers drawn.
 */
void
markerscale(
	float	s)
{
	plotdev.markerscale = s;
}


/*
 * graphtitle
 *
 *	sets the title for the graph
 */
void
graphtitle(
	char	*s)
{
	plotdev.graphtitle = savestr(plotdev.graphtitle, s);
}
		

/*
 * drawtitle
 *
 * 	Draws a title for the graph.
 */
void
drawtitle(void)
{
	if (plotdev.graphtitle == (char *)NULL)
		return;

	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	textsize(TEXTWIDTH * 1.5, TEXTHEIGHT * 1.5);

	move2(0.5 * (XMAX - XMIN) + XMIN, YMAX + 2 * TEXTHEIGHT);
	centertext(1);

	drawstr(plotdev.graphtitle);

	centertext(0);
	popviewport();
	popmatrix();
	popattributes();
}


/*
 * range
 *
 *	explicitly set the range of an axis
 */
void
range(
	float	min,
	float	max,
	char	axis)
{
	axisdata	*ax;
	char		err_buf[EBUF_SIZE];


	switch (axis) {
	case 'x':
	case 'X':
		ax = &plotdev.axes[XIND];
		ax->div = (WhatX(max) - WhatX(min)) / ax->nticks;
		break;
	case 'y':
	case 'Y':
		ax = &plotdev.axes[YIND];
		ax->div = (WhatY(max) - WhatY(min)) / ax->nticks;
		break;
	case 'z':
	case 'Z':
		ax = &plotdev.axes[ZIND];
		ax->div = (WhatZ(max) - WhatZ(min)) / ax->nticks;
		break;
	case 's':
	case 'S':
		ax = &plotdev.axes[XSEC];
		ax->div = (WhatXs(max) - WhatXs(min)) / ax->nticks;
		break;
	case 't':
	case 'T':
		ax = &plotdev.axes[YSEC];
		ax->div = (WhatYs(max) - WhatYs(min)) / ax->nticks;
		break;
	default:
		sprintf(err_buf, "range: unknown axis '%c'", axis);
		vopl_error(err_buf);
	}

	ax->min = min;
	ax->max = max;

	if (ax->scaling == LINEAR)
		ax->div = (max - min) / ax->nticks;
	else
		ax->div = (log10((double)max) - log10((double)min)) / ax->nticks;

	ax->scaleset = 1;
}
: unknown axis '%c'", axis);
			vopl_error(err_buf);
		}

	}
}

/*
 * tickspacing
 *
 *	Specify the spacing of tickmarks on an axis. For autoscaled
 *	axes (ie those using "adjustscale"), the number of tick marks
 *	may not come out exactly as specified.
 */
void
tickspacing(
	int	num,
	char	axis)
{
	char	err_buf[EBUF_SIZE];

	if (num < 0) {
		sprintf(err_buf,"tickmarks: number of tickmarks on axis '%c' must be >= 0 - was %d", axisvopl/src/lsfit.c010070000017730000310000000112720700224363600135300ustar00dghels00001250000004#include "vopl.h"

/*
 * degree
 *
 *	set the order for a least-squares fit
 */
void
degree(
	int	ord)
{
	plotdev.degree = ord;
}

/*
 * avefit
 * 
 *	Draw a line y = average y[i] - used for degree 0
 */
void
avefit(
	float	x[],
	float	y[],
	int	n)
{
	float	a;
	int	i, na;
	
	a = 0.0;
	na = 0;
	for (i = plotdev.startind; i < n; i += plotdev.arrayind) {
		na++;
		a += WhatY(y[i]);
	}

	if (na > 0)
		a /= (float)na;

	move2(WhatX(plotdev.axes[XIND].min), a);
	draw2(WhatY(plotdev.axes[XIND].max), a);
}

/*
 * llsfit
 *
 *	linear least square fit - used for degree 1
 *
 *	y = a + b.x
 *
 *	b =    n.SUM(xi.yi) - SUM(xi).SUM(yi)
 *             -------------------------------
 *	       n.SUM(xi.xi) - SUM(xi).SUM(xi)
 *
 *	a =    yave - b.xave
 */
void
llsfit(
	float	x[],
	float	y[],
	int	n)
{
	float	sumx, sumy, sumxy, sumxx, a, b, yave, xave, an;
	int	i;
	
	sumx = sumy = sumxy = sumxx = 0.0;

	for (i = plotdev.startind; i < n; i += plotdev.arrayind) {
		sumx += WhatX(x[i]);
		sumy += WhatY(y[i]);
		sumxy += WhatX(x[i]) * WhatY(y[i]);
		sumxx += WhatX(x[i]) * WhatY(x[i]);
	}

	b = (n * sumxy - sumx * sumy) / (n * sumxx - sumx * sumx);
	yave = sumy / n;
	xave = sumx / n;
	a = yave - b * xave;

	yave = a + WhatX(plotdev.axes[XIND].min) * b;
	move2(WhatX(plotdev.axes[XIND].min), yave);
	yave = a + WhatX(plotdev.axes[XIND].max) * b;
	draw2(WhatX(plotdev.axes[XIND].max), yave);
}

static float 	*b, *c, *d;

/*
 *  orthofit
 *
 *   Calculate the orthogonal polynomial of the given degree 
 *   through the data set (x, y) - used for degree 2 and above.
 *
 */
int
orthofit(
	float 	*xx,
	float	*yy,
	int 	degree,
	int	npnts)
{
	
	float	*x, *y, *pjm1, *pj;
	float	ax, ay, xdiv; 
	int	j;
	
	/* get memory for variables */

	b = newm1(degree + 1);
	c = newm1(degree + 1);
	d = newm1(degree + 1);
	pjm1 = newm1(npnts);
	pj = newm1(npnts);
	x = newm1(npnts);
	y = newm1(npnts);

	for (j = 0; j < npnts; j++) {
		x[j] = WhatX(xx[j]);
		y[j] = WhatY(yy[j]);
	}

	ortpol(npnts, x, y, pjm1, pj, degree);

	xdiv = (WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min)) / (float)plotdev.precision;
	ax = WhatX(plotdev.axes[XIND].min);

	ay = ortval(ax, degree);
	move2(ax, ay);
	for (j = 0; j <= plotdev.precision; j++) {
	 	ax += xdiv;
		ay = ortval(ax, degree);
		draw2(ax, ay);
	}
	
	free(b);
	free(c);
	free(d);
	free(pjm1);
	free(pj);
	free(x);
	free(y);

	return(j);
}

/*
 * ortpol
 *
 *    coeficients for orthogonal polynomial 
 *
 */
int 
ortpol(
	int	npnts,
	float	*x,
	float	*y,
	float	*pjm1,
	float	*pj,
	int	degree)
{
	float	*s, *w;
	float	p;
	int	i, j;

	s = newm1(degree + 1);
	w = newm1(npnts);

	for (j = 0; j <= degree; j++) {
		b[j] = 0.0;
		s[j] = 0.0;
		d[j] = 0.0;
	}

	for (i = 0; i < npnts; i++)
		w[i] = 1.0;

	c[0] = 0.0;

	for (i = 0; i < npnts; i++) {
		d[0] += y[i] * w[i];
		b[0] += x[i] * w[i];
		s[0] += w[i];
	}

	d[0] /= s[0];

	if (degree == 1)
		return(1);

	b[0] /= s[0];
	for (i = 0; i < npnts; i++) {
		pjm1[i] = 1.0;
		pj[i] = x[i] - b[0];
	}

	j = 0;

	for (;;) {
		j++;
		for(i = 0; i < npnts; i++) {
			p = pj[i] * w[i];
			d[j] +=  (y[i] - d[0]) * p;
			p *= pj[i];
			b[j] += x[i] * p;
			s[j] += p;
		}

	        d[j] /= s[j];

		if (j == degree)
			return(1);

		b[j] /= s[j];
		c[j] = s[j] / s[j - 1];
		for (i = 0; i < npnts; i++) {
			p = pj[i];
			pj[i] = (x[i] - b[j]) * pj[i] - c[j] * pjm1[i];
			pjm1[i] = p;
		}
	}
}

/*
 * ortval
 *
 *    calculates the value of the othogonal polynomial
 *    at the point x.
 *
 */
float
ortval(
	float 	x,
	int	degree)
{
	int 	k;
	float 	prev, prev2,  val;
	
	k = degree;
	val = d[k];
	prev = 0.0;
	while (k != 0) {
		k--;
		prev2 = prev;
		prev = val;
		val = d[k] + (x - b[k]) * prev - c[k + 1] * prev2;
	}
	return(val);
}

/*
 * calc_coef
 *   
 *     Note that the following two routines are not used to 
 *     to interpolate for the polynomial fit of the function. They merely
 *     to elicit the values of the coeficients of the polynomial.
 *     
 */
void
calc_coef(
	int	degree,
	float	*coef)
{
		
	float	**p;
	int	i, j;

	p = newm2(degree + 1, degree + 1);

	for (i = 0; i <= degree; i++)
		coef[i] = 0.0;

	p[0][0] = 1.0;
	p[1][0] = -b[0];
	p[1][1] = 1.0;

	coef[0] += d[0] * p[0][0] + d[1] * p[1][0];
	coef[1] += d[1] * p[1][1];

	for (i = 2; i <= degree; i++) {
		bp(i, b[i - 1], c[i - 1], p[i], p[i - 1], p[i - 2]);
		for(j = 0; j <= i; j++) 
			coef[j] += d[i] * p[i][j];
	}

	fprintf(stderr, "coef:");
	for (i = 0; i <= degree; i++)
		fprintf(stderr, " %e\n", coef[i]);
	fprintf(stderr, "\n");

	for (i = 0; i < degree + 1; i++)
		free(p[i]);
	
	free(p);
}

/*
 * bp
 *
 */
void
bp(
	int 	degree,
	float	b,
	float	c,
	float	*p3,
	float	*p2,
	float	*p1)
{
	int i;

	p3[0] = -b * p2[0] - c * p1[0];
	for (i = 1; i <= degree; i++) 
		p3[i] = p2[i - 1] - b * p2[i] - c * p1[i];
}
 for degree 0
 */
void
avefit(
	float	x[],
	float	y[],
	int	n)
{
	float	a;
	int	i, na;
	
	a = 0.0;
	na = 0;
	for (i = plotdev.startind; i < n; i += plotdev.arrayind) {
		na++;
		a += WhatY(y[i]);
	}

	if (na > 0)
		a /= (float)na;

	move2(WhatX(plotdev.axes[XIND].min), a);
	draw2(WhatY(plotdev.axes[XIND].max), a);
}

/*
 * lvopl/src/tlib.in010070000017730000310000000001740700224720700135220ustar00dghels00001250000004+adjustsc &
+axis &
+cubicsp &
+err &
+lsfit &
+mem &
+plot &
+hist &
+savestr &
+scalers &
+spline &
+ilinfit &
+switches 
vopl/src/ilinfit.c010070000017730000310000000035440700111717400140440ustar00dghels00001250000004#include "vopl.h"
#include "math.h"

/*
 * pefit
 *
 *	power equation fit	
 *
 *	ln y = ln a + b.ln x
 *
 */
void
pefit(
	float	x[], 
	float	y[],
	int	n)
{
	float	xval, xstep, yval, sumx, sumy, sumxy, sumxx, a, b, yave, xave;
	int	i;
	
	sumx = sumy = sumxy = sumxx = 0.0;

	for (i = plotdev.startind; i < n; i += plotdev.arrayind) {
		sumx += WhatX(log(x[i]));
		sumy += WhatY(log(y[i]));
		sumxy += WhatX(log(x[i])) * WhatY(log(y[i]));
		sumxx += WhatX(log(x[i])) * WhatY(log(x[i]));
	}

	yave = sumy / n;
	xave = sumx / n;

	b = (n * sumxy - sumx * sumy) / (n * sumxx - sumx * sumx);
	a = exp(yave - b * xave);

	xval = WhatX(plotdev.axes[XIND].min);
	yave = a * pow(xval, b);

	move2(xval, yave);

	xstep = (WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min)) / (2 * n);
	for (i = plotdev.startind; i < 2 * n; i += plotdev.arrayind) {
		xval += xstep;
		yval = a * pow(xval, b); 
		draw2(xval, yval);
	}
}

/*
 * sgrfit
 *
 *	saturated growth rate fit
 *
 *	y = c * x / (d + x)
 *
 *      invert 
 *
 *      1/y = d/c . 1/x + 1/c 
 *
 *
 */
void
sgrfit(
	float	x[],
	float	y[],
	int	n)
{
	float	xval, xstep, yval, sumx, sumy, sumxy, sumxx, a, b, yave, xave;
	float	a3, b3;
	int	i;
	
	sumx = sumy = sumxy = sumxx = 0.0;

	for (i = plotdev.startind; i < n; i += plotdev.arrayind) {
		sumx += 1.0 / x[i];
		sumy += 1.0 / y[i];
		sumxy += (1.0 / x[i]) * (1.0 / y[i]);
		sumxx += (1.0 / x[i]) * (1.0 / x[i]);
	}

	yave = sumy / n;
	xave = sumx / n;

	b = (n * sumxy - sumx * sumy) / (n * sumxx - sumx * sumx);
	a = yave - b * xave;

	a3 = 1.0 / a;
	b3 = b * a3; 

	xval = WhatX(plotdev.axes[XIND].min);
	yval = a3 * xval / (b3 + xval);
	move2(xval, yave);

	xstep = (WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min)) / (2 * n);

	for (i = plotdev.startind; i < 2 * n; i += plotdev.arrayind) {
		xval += xstep;
		yval = a3 * xval / (b3 + xval);
		draw2(xval, yval);
	}
}
vopl/src/makefile.tc010070000017730000310000000011110700224717600143420ustar00dghels00001250000004#
CFLAGS = -c -ml -DPC -I..\..\vogle\src

OBJS = adjustsc.obj err.obj  mem.obj  scalers.obj \
ilinfit.obj axis.obj  plot.obj  hist.obj spline.obj \
cubicsp.obj lsfit.obj  savestr.obj switches.obj 

all: vopl.lib

adjustsc.obj: adjustsc.c

axis.obj: axis.c

cubicsp.obj: cubicsp.c

ilinfit.obj: ilinfit.c

err.obj: err.c

lsfit.obj: lsfit.c

mem.obj: mem.c

plot.obj: plot.c

hist.obj: hist.c

savestr.obj: savestr.c

scalers.obj: scalers.c

spline.obj: spline.c

switches.obj: switches.c

vopl.lib: $(OBJS)
	del vopl.lib
	tlib vopl.lib @tlib.in, vopl.lst

.c.obj:
	tcc $(CFLAGS) $*.c

vopl/src/vopl.h010070000017730000310000000100000700224702600133550ustar00dghels00001250000004#ifndef ___VOPL_INC

#define ___VOPL_INC 1

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <vogle.h>

#define MAX(a,b)	((a) > (b) ? (a) : (b))
#define MIN(a,b)	((a) < (b) ? (a) : (b))
#define ABS(a)		((a) < 0.0 ? (-a) : (a))

#define	EBUF_SIZE	100		/* size of error message buffer */
#define	LABEL_LEN	50		/* max length of an axis label */

/*
 * fits
 */
#define	NO_LINES	0
#define	STRAIGHT_LINE	1
#define LEAST_SQUARE	2
#define CUBIC_SPLINE	3
#define	POWER_EQN	4
#define	SGR_FIT		5

#define	MAX_FIT		5		/* must be maximum fit number */

/*
 * spline types
 */
#define	FREE		0
#define	CLAMPED		1

/*
 * scalings
 */
#define	LINEAR		0
#define	LOGARITHMIC	1

/*
 * boundaries in which the graph is plotted
 */
#define	XMIN		-0.7
#define	YMIN		-0.7
#define	XMAX		1.0
#define	YMAX		0.8

/*
 * size of line-markers on axes
 */
#define	LINELEN		0.02

/*
 * textsizes
 */
#define	TEXTHEIGHT	0.05
#define	TEXTWIDTH	0.035

/*
 * marker size
 */
#define	MARKERSIZE	0.05

/*
 * A big number (Some PC things don't seem to have this in math.h)
 */
#define BLOODYBIG	1.0e38

extern float	*newm1(), **newm2();

extern float	cardinal[4][4];

/*
 * axis indexes
 */
#define	XIND		0
#define	YIND		1
#define	ZIND		2

#define XSEC            3	/* Index for secondary axes */
#define YSEC            4

#define	AXES		3	/* number of axes */

typedef struct AXISDATA {
	float	min,
		max,
		div;
	int	scaling,
		annotate,
		nticks,
		ntspacing,
		minorticks,
		scaleset,
		forceticks,
		mod;
	char	*format,
		*title;
} axisdata;

typedef struct VOPL {
	float		s1, sn,
			histhatchang,
			markerscale;

	int		fit, 
			degree,
			splinetype,
			histhatch,
			grid, 
			startind, arrayind,
			precision,
			markerspacing;
	char		*marker,
			*graphtitle;

	axisdata	axes[AXES+2];
} vopldev;

extern vopldev	plotdev;

extern	double	log10(double);

extern	char	*savestr();


#define WhatX(x) (plotdev.axes[XIND].scaling == LINEAR ? \
				(x) : (float)log10((double)(x)))
#define WhatY(y) (plotdev.axes[YIND].scaling == LINEAR ? \
				(y) : (float)log10((double)(y)))
#define WhatZ(z) (plotdev.axes[ZIND].scaling == LINEAR ? \
				(z) : (float)log10((double)(z)))
#define WhatXs(z) (plotdev.axes[XSEC].scaling == LINEAR ? \
				(z) : (float)log10((double)(z)))
#define WhatYs(z) (plotdev.axes[YSEC].scaling == LINEAR ? \
				(z) : (float)log10((double)(z)))


void adjustscale(float x[], int n, char axis);
void formatlabel(float alabel, char *form);
void axistitle(char *title, char ax);
void drawaxis(char axis);

void drawaxes2(void);
void drawaxes(void);
void lin_axis(int axis);
void log_axis(int axis);
void cubicsp(float *x, float *y, int n);
void vopl_error(char *str);
void hist2(float *d, int ng, int ns, char *names[]);
void pefit(float *x, float *y, int n);
void sgrfit(float *x, float *y, int n);
void degree(int ord);
void avefit(float *x, float *y, int n);
void llsfit(float *x, float *y, int n);
int orthofit(float *xx, float *yy, int degree, int npnts);
int ortpol(int npnts, float *x, float *y, float *pjm1, float *pj, int degree);
float ortval(float x, int degree);
void calc_coef(int degree, float *coef);
void bp(int degree, float b, float c, float *p3, float *p2, float *p1);
float * newm1(int n);
float ** newm2(int m, int n);
void plot2(float *x, float *y, int n);
char * savestr(char *old, char *string);
void logscale(float xmin, float xmax, int n , float *xminp, float *xmaxp, float *dist);
void linscale2(float xmin, float xmax, int n , float *xminp, float *xmaxp, float *dist);
void linscale1(float min, float max, int n, float *minp, float *maxp, float *dist);
void spline(float *x, float *y, int np);
void skip(int n);
void endslopes(float a, float b);
void gridspacing(int spacing);
void scaling(int type, char axis);
void tickmarks(int num, char axis);
void tickspacing(int num, char axis);
void annotate(char *format, char axis);
void anotatemod(int i, char a);
void arrayindex(int i);
void marker(char *string);
void markerspacing(int spacing);
void markerscale(float s);
void graphtitle(char *s);
void drawtitle(void);
void range(float min, float max, char axis);
#endif
vopl/src/mem.c010070000017730000310000000013530700111550000131470ustar00dghels00001250000004#include "vopl.h"

/*
 * newm1
 *
 *	allocate a one dimensional array
 */
float *
newm1(
	int	n)
{
	float	*p;

	if ((p = (float *)malloc(sizeof(float) * n)) == (float *)NULL) {
		fprintf(stderr, "newm1: request for %d bytes returns NULL\n", n);
		exit(1);
	}

	return(p);
}

/*
 * newm2
 *
 *	allocate an array of arrays
 */
float **
newm2(
	int	m,
	int	n)
{
	float  **mat;
	int i;

	if ((mat = (float **)malloc((unsigned)sizeof(float *) * m)) == (float **)NULL) {
		fprintf(stderr, "newm2: request for %d bytes returns NULL\n", n);
		exit(1);
	}

	for (i = 0; i < m; i++)
		if ((mat[i] = (float *)malloc(n * sizeof(float))) == (float *)NULL) {
			fprintf(stderr, "newm2: request for %d bytes returns NULL\n", n);
			exit(1);
		}

	return(mat);
}
vopl/src/lib.in010070000017730000310000000002020451256566600133450ustar00dghels00001250000004vopl.lib
Y
+adjustsc &
+axis &
+cubicsp &
+err &
+lsfit &
+mem &
+plot &
+savestr &
+scalers &
+spline &
+ilinfit &
+switches 



vopl/src/fmakefil.msc010070000017730000310000000015450451256566500145430ustar00dghels00001250000004F = -FPc
CFLAGS = -AL $(F) -c -I..\..\vogle\src

OBJS = adjustsc.obj err.obj  mem.obj  scalers.obj \
ilinfit.obj axis.obj  plot.obj  spline.obj \
cubicsp.obj lsfit.obj  savestr.obj switches.obj \
faxis.obj fplot.obj fswitch.obj flsfit.obj fsadjust.obj 

.c.obj:
	cl $(CFLAGS) $*.c

adjustsc.obj: adjustsc.c

axis.obj: axis.c

cubicsp.obj: cubicsp.c

ilinfit.obj: ilinfit.c

err.obj: err.c

lsfit.obj: lsfit.c

mem.obj: mem.c

plot.obj: plot.c

savestr.obj: savestr.c

scalers.obj: scalers.c

spline.obj: spline.c

switches.obj: switches.c

faxis.obj: msfort\faxis.asm
	masm -MX msfort\faxis;

fplot.obj: msfort\fplot.asm
	masm -MX msfort\fplot;

fsadjust.obj: msfort\fsadjust.asm
	masm -MX msfort\fsadjust;

fswitch.obj: msfort\fswitch.asm
	masm -MX msfort\fswitch;

flsfit.obj: msfort\flsfit.asm
	masm -MX msfort\flsfit;

vopl.lib: $(OBJS)
	del vopl.lib
	lib @flib.in
vopl/src/makefile.msc010070000017730000310000000010360700224715400145200ustar00dghels00001250000004F = -FPc
CFLAGS = -AL $(F) -c -I..\..\vogle\src

OBJS = adjustsc.obj err.obj  mem.obj  scalers.obj \
axis.obj  plot.obj  hist.obj spline.obj \
cubicsp.obj lsfit.obj  savestr.obj switches.obj 

.c.obj:
	cl $(CFLAGS) $*.c

adjustsc.obj: adjustsc.c

axis.obj: axis.c

cubicsp.obj: cubicsp.c

ilinfit.obj: ilinfit.c

err.obj: err.c

lsfit.obj: lsfit.c

mem.obj: mem.c

plot.obj: plot.c

hist.obj: plot.c

savestr.obj: savestr.c

scalers.obj: scalers.c

spline.obj: spline.c

switches.obj: switches.c

vopl.lib: $(OBJS)
	del vopl.lib
	lib @lib.in
vopl/src/scalers.c010070000017730000310000000145120700224573200140420ustar00dghels00001250000004#include "vopl.h"

extern double	pow();
extern double	log10();
static	float	del = 0.000002;

/*
 * ten2pow
 *
 *	Computes 10 to the power of i
 */
static float
ten2pow(
	int	i)
{
	float	a = 1.0;
	int	j;

	if (i > 0)
		for (j = 0; j < i; j++)
			a *= 10.0;
	else if (i < 0) 
		for (j = 0; j > i; j--)
			a /= 10.0;

	return (a);
}
	
/*
 * Algorithm 463 - scale3. (From CACM)
 *
 * given xmin , xmax and n, where n is greater than 1, scale3
 * finds a new range xminp and xmaxp divisible into exactly
 * n LOGARITHMIC intervals, where the ratio of adjacent
 * uniformly spaced scale values is dist.
 */
void
logscale(
	float	xmin,
	float	xmax,
	int	n,
	float	*xminp,
	float	*xmaxp,
	float	*dist)
{
	static	float vint[11] = {
		10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.5
	};

	float	xminl, xmaxl, fn, a, al, b, distl, fm1, fm2;
	int	nal, i, m1, m2, np, nx;

	/*
	 * Check whether proper input values were supplied.
	 */
	if (xmin >= xmax || n <= 0 || xmin <= 0.0) {
		fprintf(stderr, "logscale: Improper values supplied as input\n");
		if (xmin <= 0.0)
			fprintf(stderr, "Zero or negative minimum value input: %f\n", xmin);

		exit(1);
	}

	/*
	 * Values are translated from the linear region to the logarithmic
	 */
	
	xminl = (float)log10((double)xmin);
	xmaxl = (float)log10((double)xmax);
	fn = (float)n;

	/*
	 * Find approximate interval size a
	 */

	a = (xmaxl - xminl) / fn;
	al = (float)log10((double)a);
	nal = (int)al;
	if (a < 1.0)
		nal--;

	/*
	 * A is scaled into the variable named b between 1 and 10
	 */

	b = a / ten2pow(nal);

	/*
	 * The closest permissible value for b is found
	 */
	
/*
	for (i = 0; i < 9 && b < (10.0 / vint[i] + del); i++)
		;
*/
	for (i = 0; i < 9; i++)
		if (b < (10.0 / vint[i] + del)) goto l1;

	i = 9;
l1:
	/*
	 * The interval size is computed
	 */
	
	do {
		distl = ten2pow(nal + 1) / vint[i];
		fm1 = xminl / distl;
		m1 = (int)fm1;
	
		if (fm1 < 0.0) 
			m1--;

		if (ABS((float)m1 + 1.0 - fm1) < del)
			m1--;

		/*
		 * The new minimum and maximum limits are found
		 */

		*xminp = distl * (float)m1;

		fm2 = xmaxl / distl;
		m2 = (int)(fm2 + 1.0);
		if (fm2 < -1.0)
			m2--;
	
		if (ABS(fm2 + 1.0 - (float)m2) < del)
			m2--;

		*xmaxp = distl * (float)m2;


		/*
		 * Check whether another pass is necessary
		 */
		np = m2 - m1;
		i++;
	} while (np > n);

	nx = (n - np) / 2;
	*xminp = *xminp - (float)nx * distl;
	*xmaxp = *xminp + (float)n * distl;

	/*
	 * Values are translated from the logarithmic into the
	 * linear region.
	 */
	
	/**dist = (float)pow((double)10.0, (double)distl);*/
	*dist = distl;
	*xminp = (float)pow((double)10.0, (double)*xminp);
	*xmaxp = (float)pow((double)10.0, (double)*xmaxp);

	/*
	 * Adjust limits to account for round-off if necessary
	 */

	if (*xminp > xmin)
		*xminp = xmin;

	if (*xmaxp < xmax)
		*xmaxp = xmax;

}


/*
 * Algorithm 463 - scale2. (From CACM)
 *
 * given xmin , xmax and n, where n is greater than 1, scale2
 * finds a new range xminp and xmaxp divisible into exactly
 * n LINEAR intervals of size dist, where n is greater than 1.
 */
void
linscale2(
	float	xmin,
	float	xmax,
	int	n,
	float	*xminp,
	float	*xmaxp,
	float	*dist)
{
	static	float vint[5] = {
		1.0, 2.0, 5.0, 10.0, 20.0
	};

	float	fn, a, al, b, fm1, fm2;
	int	nal, i, m1, m2, np, nx;

	/*
	 * Check whether proper input values were supplied.
	 */
	if (xmin >= xmax || n <= 0) {
		fprintf(stderr, "linscale2: improper values supplied as input\n");
		exit(1);
	}

	fn = (float)n;

	/*
	 * Find approximate interval size a
	 */

	a = (xmax - xmin) / fn;
	al = (float)log10((double)a);
	nal = (int)al;
	if (a < 1.0)
		nal--;

	/*
	 * A is scaled into the variable named b between 1 and 10
	 */

	b = a / ten2pow(nal);

	/*
	 * The closest permissible value for b is found
	 */
	
	for (i = 0; i < 3 && b < (vint[i] + del); i++)
		;

	/*
	 * The interval size is computed
	 */
	
	do {
		*dist = ten2pow(nal) * vint[i];
		fm1 = xmin / *dist;
		m1 = (int)fm1;
	
		if (fm1 < 0.0) 
			m1--;

		if (ABS((float)m1 + 1.0 - fm1) < del)
			m1--;

		/*
		 * The new minimum and maximum limits are found
		 */

		*xminp = *dist * (float)m1;

		fm2 = xmax / *dist;
		m2 = (int)(fm2 + 1.0);
		if (fm2 < -1.0)
			m2--;
	
		if (ABS(fm2 + 1.0 - (float)m2) < del)
			m2--;

		*xmaxp = *dist * (float)m2;


		/*
		 * Check whether another pass is necessary
		 */
		np = m2 - m1;
		i++;
	} while (np > n);

	nx = (n - np) / 2;
	*xminp = *xminp - (float)nx * *dist;
	*xmaxp = *xminp + (float)n * *dist;

	/*
	 * Adjust limits to account for round-off if necessary
	 */

	if (*xminp > xmin)
		*xminp = xmin;

	if (*xmaxp < xmax)
		*xmaxp = xmax;
}

/*
 *	Algorithm 463 scale1 (from CACM)
 *	given min, max and n, scaleaxis finds a new range minp and
 *	maxp divisible into approximately n linear intervals
 *	of size dist
 *	vint is an array of acceptable values for dis (times
 *	an integer power of 10)
 *	sqr is an array of geometric neans of adjacent values
 *	of vint, it is used as break points to determine
 *	which vint value to assign to dist
 *
 */
void
linscale1(
	float	min,
	float	max,
	int	n,
	float	*minp,
	float	*maxp,
	float	*dist)
{
	static float	vint[] = { 1.0, 2.0, 5.0, 10.0 };
	static float	sqr[] = { 1.414214, 3.162278, 7.071068 };
	float		fn, a, al, b, fm1;
	int		i,nal,m1;

	/*
	 *	check whether proper input values were supplied 
	 */

	if (min > max || n < 0) {
	    fprintf(stderr," improper input supplied to linscale1 %f %f %d\n",
		    min, max, n);
	    exit(1);
	}

	fn = (float) n;

	/*
	 *	find approximate interval size a 
	 */

	a = (max - min) / fn;
	if (fabs(a) < 0.000001) {
		max += 1.0;
		min -= 1.0;
		a = (max - min) / fn;
	}

	al = log10((double)a);
	nal = (int) al;
	if (a < 1.0) 
	    nal -= 1;

	/*
	 *	a is scaled into variable named b between 1 and 10 
	 */

	b = a / ten2pow(nal);

	/*	
	 *	the closest permissible value for b is found 
	 */

	for (i = 0; b > sqr[i] && i < 3; i++)
		;

	/*
	 *	the interval size is computed  
	 */

  	*dist = vint[i] * ten2pow(nal);
	fm1 = min / *dist;

	m1 = fm1;

	if (fm1 < 0.0) 
	    m1 -= 1;

	if (ABS((m1 + 1.0 - fm1)) < del) 
	    m1 += 1;

	/*
	 *	the new minimum and maximum limits are found
	 */

	*minp = *dist * (float)m1;

	fm1 = max / *dist;
	m1 = (int)(fm1 + 1.0);

	if (fm1 < -1.0 || ABS((fm1 + 1.0 - (float)m1)) < del)
	    m1 -= 1;

	*maxp = *dist * (float)m1;

	/*
	 *	adjust limits to account for round-off if necessary 
	 */

	if (*minp > min) 
	    *minp = min;
	if (*maxp < max)
	    *maxp = max;

}
tl;
	*xmaxp = *xminp + (float)n * distl;

	/*
	 * Values are translated from the logarithmic into the
	 * linear region.
	 */
	
	/**dist = (float)pow((double)10.0, (double)distl);*/
vopl/src/Makefile010070000017730000310000000016060700224713100136750ustar00dghels00001250000004#

LIBS = libvopl.a -lvogle -lsuntool -lsunwindow -lpixrect -lm

SRCS =  axis.c adjustscale.c switches.c mem.c spline.c \
	cubicsp.c plot.c err.c hist.c lsfit.c ilinfit.c scalers.c savestr.c

OBJS =  axis.o adjustscale.o switches.o mem.o spline.o \
	cubicsp.o plot.o err.o hist.o lsfit.o ilinfit.o scalers.o savestr.o

FSRCS = sunfort/faxis.c sunfort/flsfit.c sunfort/fplot.c \
	sunfort/fsadjust.c sunfort/fswitch.c

FOBJS = sunfort/faxis.o sunfort/flsfit.o sunfort/fplot.o \
	sunfort/fsadjust.o sunfort/fswitch.o

MCFLAGS = -g -I/tmp

CFLAGS = $(MCFLAGS)

RANLIB = ranlib

all:	libvopl.a 

libvopl.a:	$(OBJS) $(FOBJS)
	rm -f libvopl.a
	ar rcv	libvopl.a $(OBJS) $(FOBJS)
	$(RANLIB) libvopl.a
	
$(OBJS): vopl.h

$(FOBJS): vopl.h
	cd sunfort; make MCFLAGS="$(MCFLAGS)"

clean:
	rm -f *.o sunfort/*.o core

lint:
	lint -I. $(SRCS) $(FSRCS) -lm > vopl.lint

clobber:
	rm -f libvopl.a *.o sunfort/*.o core

vopl/src/adjustscale.c010070000017730000310000000023720700224244300147050ustar00dghels00001250000004
#include "vopl.h"

/*
 *	adjustscale
 *
 *	Adjust the scaling for the specified axis according to the
 *	values in the array x.
 */
void
adjustscale(
	float		x[],
	int		n,
	char		axis)
{
	int		i, nticks;
	float		min, max, a, b, c, d, div;
	axisdata	*ax;

	switch (axis) {
	case 'x':
	case 'X':
		ax = &plotdev.axes[XIND];
		break;
	case 'y':
	case 'Y':
		ax = &plotdev.axes[YIND];
		break;
	case 'z':
	case 'Z':
		ax = &plotdev.axes[ZIND];
		break;
	case 's':
	case 'S':
		ax = &plotdev.axes[XSEC];
		break;
	case 't':
	case 'T':
		ax = &plotdev.axes[YSEC];
		break;
	default:
		vopl_error("Unknown axis in adjust scale");
	}

	nticks = ax->nticks;
	min = ax->min;
	max = ax->max;
	ax->scaleset = 1;

	/*
	 * Find min and max of array x.
	 */

	a = b = x[0];
	for (i = plotdev.arrayind; i < n; i += plotdev.arrayind) {
		a = MIN(a, x[i]);
		b = MAX(b, x[i]);
	}

	if (a < min || b > max) {	/* We only do this if we have to */

		if (a < min) 
			min = a;

		if (b > max)
			max = b;

		if (!nticks)
			nticks = 5;

		if (ax->scaling == LOGARITHMIC)
			logscale(min, max, nticks, &a, &b, &div);
		else if (ax->forceticks)  {
			linscale2(min, max, nticks, &a, &b, &div);
		} else
			linscale1(min, max, 5, &a, &b, &div);

		ax->min = a;
		ax->max = b;
		ax->div = div;
	}
}
vopl/src/adjustscale.c.orig010070000017730000310000000022040700111507300156330ustar00dghels00001250000004
#include "vopl.h"

/*
 *	adjustscale
 *
 *	Adjust the scaling for the specified axis according to the
 *	values in the array x.
 */
void
adjustscale(
	float		x[],
	int		n,
	char		axis)
{
	int		i, nticks;
	float		min, max, a, b, c, d, div;
	axisdata	*ax;

	switch (axis) {
	case 'x':
	case 'X':
		ax = &plotdev.axes[XIND];
		break;
	case 'y':
	case 'Y':
		ax = &plotdev.axes[YIND];
		break;
	case 'z':
	case 'Z':
		ax = &plotdev.axes[ZIND];
		break;
	default:
		vopl_error("Unknown axis in adjust scale");
	}

	nticks = ax->nticks;
	min = ax->min;
	max = ax->max;
	ax->scaleset = 1;

	/*
	 * Find min and max of array x.
	 */

	a = b = x[0];
	for (i = plotdev.arrayind; i < n; i += plotdev.arrayind) {
		a = MIN(a, x[i]);
		b = MAX(b, x[i]);
	}

	if (a < min || b > max) {	/* We only do this if we have to */

		if (a < min) 
			min = a;

		if (b > max)
			max = b;

		if (!nticks)
			nticks = 5;

		if (ax->scaling == LOGARITHMIC)
			logscale(min, max, nticks, &a, &b, &div);
		else if (plotdev.forceticks) 
			linscale2(min, max, nticks, &a, &b, &div);
		else
			linscale1(min, max, 5, &a, &b, &div);

		ax->min = a;
		ax->max = b;
		ax->div = div;
	}
}
vopl/src/axis.c.orig010070000017730000310000000232440700207513700143130ustar00dghels00001250000004#include <stdio.h>
#include <string.h>
#include "vopl.h"

void	log_axis(), lin_axis();

/*
 * formatlabel
 *
 *	chose a "nice" format for an axis label, awful at the moment.
 */
void
formatlabel(
	float	alabel,
	char	*form)
{
	int	i, j;

	if (ABS(alabel) < 1.0e-9)
		alabel = 0.0;

	if ((ABS(alabel) > 999999.0) || (ABS(alabel) < 0.000001))
		sprintf(form, "%.4g", alabel);
	else 
		sprintf(form, "%f", alabel);

	/*
	 * if there is no 'e' in there or there is a dot then
	 * eat trailing zeros.....
	 */
	if ((strchr(form, 'e') == (char *)NULL &&
	    strchr(form, 'E') == (char *)NULL) &&
	    strchr(form, '.') != (char *)NULL) {
		i = strlen(form) - 1;
		while (i >= 0 && form[i] == '0') 
			i--;

		if (form[i] == '.')
			i--;

		form[++i] = '\0';
		if (form[0] == '\0') {
			form[0] = '0';
			form[1] = '\0';
		}
	}
}

/*
 * axistitle
 *
 *	Draws an x, y or z axis, with or without annotation, tickmarks etc
 */
void
axistitle(
	char	*title,
	char	ax)
{
	char	**s, err_buf[EBUF_SIZE];

	/*
	 * save the goddam title somewhere....
	 */
	switch (ax) {
	case 'x':
	case 'X':
		s = &plotdev.axes[XIND].title;
		break;
	case 'y':
	case 'Y':
		s = &plotdev.axes[YIND].title;
		break;
	case 'z':
	case 'Z':
		s = &plotdev.axes[ZIND].title;
		break;
	default:
		sprintf(err_buf, "axistitle: unknown axis '%c'", ax);
		vopl_error(err_buf);
	}

	*s = savestr(*s, title);
}

/*
 * drawaxis
 *
 *	Draws an x, y or z axis, with or without annotation, tickmarks etc
 */
void
drawaxis(
	char	axis)
{
	int	ind;
	char	err_buf[EBUF_SIZE];

	switch (axis) {
	case 'x':
	case 'X':
		ind = XIND;
		break;
	case 'y':
	case 'Y':
		ind = YIND;
		break;
	case 'z':
	case 'Z':
		ind = ZIND;
		break;
	default:
		sprintf(err_buf, "drawaxis: unknown axis '%c'", axis);
		vopl_error(err_buf);
	}

	if (!plotdev.axes[ind].scaleset) { 
		plotdev.axes[ind].min = -1.0;
		plotdev.axes[ind].max = 1.0;
	}

	if (plotdev.axes[ind].scaling == LOGARITHMIC)
		log_axis(ind);
	else
		lin_axis(ind);
}

/*
 * drawaxes2
 *
 *	Draws the x and y axes, with or without annotation, tickmarks etc
 */
void
drawaxes2()
{
	int	axis;

	for (axis = 0; axis < AXES; axis++)
		if (!plotdev.axes[axis].scaleset) { 
			plotdev.axes[axis].min = -1.0;
			plotdev.axes[axis].max = 1.0;
		}

	if (plotdev.axes[XIND].scaling == LOGARITHMIC) 
		log_axis(XIND);
	else
		lin_axis(XIND);

	if (plotdev.axes[YIND].scaling == LOGARITHMIC) 
		log_axis(YIND);
	else 
		lin_axis(YIND);
}

/*
 * drawaxes
 *
 *	Draws an x, y, and z axes, with or without annotation, tickmarks etc
 */
void
drawaxes()
{
	int	axis;

	for (axis = 0; axis < AXES; axis++) {
		if (!plotdev.axes[axis].scaleset) { 
			plotdev.axes[axis].min = -1.0;
			plotdev.axes[axis].max = 1.0;
		}

		if (plotdev.axes[axis].scaling == LOGARITHMIC) 
			log_axis(axis);
		else
			lin_axis(axis);
	}
}

/*
 * lin_axis
 *
 *	draw a linear axis
 */
void
lin_axis(
	int		axis)
{
	float 		x, y, sx, sy;
	float		ssx, ssy, tinc, alabel;
	int 		i, j, count;
        char		form[50], err_buf[EBUF_SIZE];
	axisdata	ax;

	
	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	clipping(0);

	switch (axis) {
	case XIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMIN);
		draw2(XMAX, YMIN);

		textang(0.0);
		centertext(1);

		ax = plotdev.axes[XIND];

		x = ax.max - ax.min;
		count = x / ax.div + 0.5;

		xcentertext();
		topjustify();

		tinc = (XMAX - XMIN) / x * ax.div;
		for (i = 0; i <= count; i++) {
			sx = i * tinc + XMIN;

			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssx = sx + tinc * j / ax.minorticks;

					move2(ssx, YMIN);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(ssx, YMIN - 0.75 * LINELEN);
					else
						draw2(ssx, YMIN - 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}
		

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMIN);
				draw2(sx, YMIN - LINELEN);
			}
		
			if (ax.annotate) {
				alabel = ax.min + ax.div * i;
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(sx, YMIN - LINELEN - 1.1 * TEXTHEIGHT / 2);
				*/
				move2(sx, YMIN - 1.2 * LINELEN);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			textang(0.0);
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMIN - 6.0 * TEXTWIDTH);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			move2(x, y);
			drawstr(ax.title);
		}
		break;
	case YIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMIN, YMIN);
		draw2(XMIN, YMAX);

		textjustify(0);
		ycentertext();
		rightjustify();

		ax = plotdev.axes[YIND];

		y = ax.max - ax.min;
		tinc = (YMAX - YMIN) / y * ax.div;
		count = y / ax.div + 0.5;

		for (i = 0; i <= count; i++) {
			sy = i * tinc + YMIN;
			if (i < count && ax.minorticks)
				for (j = 1; j <= ax.minorticks; j++) {
					ssy = sy + tinc * j / ax.minorticks;

					move2(XMIN, ssy);
					if (!(ax.minorticks & 1) && j == ax.minorticks/2)
						draw2(XMIN - 0.75 * LINELEN, ssy);
					else
						draw2(XMIN - 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMIN, sy);
				draw2(XMIN - LINELEN, sy);
			}

			if (ax.annotate) {
				alabel = ax.min + ax.div * i;
				if (ax.format)
					sprintf(form, ax.format, alabel);
				else
					formatlabel(alabel, form);

				/*
				move2(XMIN - strlength(form) - 2 * LINELEN, sy - TEXTHEIGHT / 2);
				*/
				move2(XMIN - 1.2 * LINELEN, sy);
				drawstr(form);
			}
		}

		if (ax.title != (char *)NULL) {
			x = XMIN - 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
			textang(0.0);
		}
		break;
	case ZIND:
		vopl_error("Z-Axis not yet implemented");
		break;
	default:
		sprintf(err_buf, "axis: unknown axis: %d", axis);
		vopl_error(err_buf);
	}

	popviewport();
	popmatrix();
	popattributes();
	clipping(1);
}


/*
 * log_axis
 *
 *	Does a logarithmic axis with exponential style annotation
 */
void
log_axis(
	int	axis)
{

	float 		x, y, sx, sy;
	float		ssx, ssy, tinc, mtinc, alabel, ldiv;
	int 		i, j;
        char		form[21], err_buf[EBUF_SIZE];
	axisdata	ax;
	
	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	clipping(0);

	switch (axis) {
	case XIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		move2(XMIN, YMIN);
		draw2(XMAX, YMIN);

		textang(0.0);
		centertext(0);

		ax = plotdev.axes[XIND];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		tinc = (XMAX - XMIN) / (ax.nticks);
		for (i = 0; i <= ax.nticks; i++) {

			sx = i * tinc + XMIN;
			/* Minor ticks */
			if (i < ax.nticks && ax.minorticks) 
				for (j = 1; j < 10; j++) {
					ssx = sx + tinc * log10((double)j);

					move2(ssx, YMIN);
					if (j == 5)
						draw2(ssx, YMIN - 0.75 * LINELEN);
					else
						draw2(ssx, YMIN - 0.5 * LINELEN);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(ssx, YMAX);
				}

			if (plotdev.grid)
				if (!(i % plotdev.grid)) {
					move2(sx, YMAX);
					draw2(sx, YMIN);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(sx, YMIN);
				draw2(sx, YMIN - LINELEN);
			}
			
			if (ax.annotate) {
				formatlabel(alabel, form);

				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(sx + 0.5 * TEXTWIDTH, YMIN - LINELEN - 0.8 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), 0.0);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.3 * TEXTWIDTH, -0.9 * TEXTHEIGHT);
				drawstr("10");
			}
			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			centertext(1);
			x = 0.5 * (XMAX - XMIN) + XMIN;
			y = (YMIN - 6.0 * TEXTWIDTH);
			move2(x, y);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	case YIND:
		textsize(TEXTWIDTH, TEXTHEIGHT);
		centertext(0);
		textang(0.0);

		move2(XMIN, YMIN);
		draw2(XMIN, YMAX);

		ax = plotdev.axes[YIND];

		/*
		 * Get the minimum exponent value.
		 */
		alabel = (float)log10((double)ax.min);

		centertext(0);

		tinc = (YMAX - YMIN) / (ax.nticks);

		for (i = 0; i <= ax.nticks; i++) {
			sy = i * tinc + YMIN;

			if (i < ax.nticks && ax.minorticks)
				for (j = 1; j < 10; j++) {
					ssy = sy + tinc * log10((double)j);

					move2(XMIN, ssy);
					if (j == 5)
						draw2(XMIN - 0.75 * LINELEN, ssy);
					else
						draw2(XMIN - 0.5 * LINELEN, ssy);
					if (ax.minorticks && plotdev.grid && !(j % plotdev.grid))
						draw2(XMAX, ssy);
				}

			if (plotdev.grid) 
				if (!(i % plotdev.grid)) {
					move2(XMIN, sy);
					draw2(XMAX, sy);
				}

			if (ax.ntspacing && !(i % ax.ntspacing)) {
				move2(XMIN, sy);
				draw2(XMIN - LINELEN, sy);
			}

			if (ax.annotate) {
				formatlabel(alabel, form);
				textsize(0.7 * TEXTWIDTH, 0.7 * TEXTHEIGHT);
				move2(XMIN - strlength(form) -1.5 * LINELEN, sy + 0.5 * TEXTHEIGHT);
				drawstr(form);
				rmove2(-strlength(form), -0.75 * TEXTHEIGHT);
				textsize(TEXTWIDTH, TEXTHEIGHT);
				rmove2(-1.1 * TEXTWIDTH, 0.0);
				drawstr("10");
			}

			alabel += ax.div;
		}

		if (ax.title != (char *)NULL) {
			x = XMIN - 7.0 * TEXTWIDTH;
			y = 0.5 * (YMAX - YMIN) + YMIN;
			move2(x, y);
			textang(90.0);
			centertext(1);
			textsize(1.3 * TEXTWIDTH, 1.3 * TEXTHEIGHT);
			drawstr(ax.title);
		}
		break;
	case ZIND:
		vopl_error("Z-Axis not yet implemented");
		break;
	default:
		sprintf(err_buf, "axis: unknown axis: %d", ax);
		vopl_error(err_buf);
	}

	popviewport();
	popmatrix();
	popattributes();
	clipping(1);
}
vopl/src/hist.c010064400017730000310000000046120700225600000133520ustar00dghels00001250000004#include <vogle.h>
#include "vopl.h"

extern	double log10();
extern	double sqrt();

static	int	*hskip = NULL;
static	int	dohistnum = 0;

/*
 * hist2
 *
 *	display the 2-d histogram described by d;
 *      d is an array of <ng> groups with <ns> species in each group
 *      names is an array with the name for each group
 */
void hist2(
	float	*d,
	int	ng,
	int	ns,
	char	*names[])
{
	int	i, j, k;
	char	err_buf[EBUF_SIZE];
	float	sx, sy, left, right, bottom, top;
	float	width, swidth, x0, tinc;

	/*
	 * Set the view up so that clipping happens...
	 */

	pushmatrix();
	pushattributes();
	pushviewport();

	getviewport(&left, &right, &bottom, &top);

	viewport(left + (1.0 + XMIN) / 2.0 * (right - left),
		right - (1.0 - XMAX) / 2.0 * (right - left),
		bottom + (1.0 + YMIN) / 2.0 * (top - bottom),
		top - (1.0 - YMAX) / 2.0 * (top - bottom));

	annotate("", 'x');
	tickmarks(0, 'x');
	minorticks(0,'x');
	range(0., ng+1., 'x');

	if (!plotdev.axes[YIND].scaleset) {
		plotdev.axes[YIND].min=0.0;
		adjustscale(d, ns*ng, 'y');
	}
	
	ortho2(WhatX(plotdev.axes[XIND].min),
	       WhatX(plotdev.axes[XIND].max),
	       WhatY(plotdev.axes[YIND].min),
	       WhatY(plotdev.axes[YIND].max));

       /*
        * now plot the bars
        */
	width=(WhatX(plotdev.axes[XIND].max)-WhatX(plotdev.axes[XIND].min))/ng;
	swidth= width*5./7./ns;


	k = 0;
	for (i=0; i<ng; i++) {
	   if (hskip && hskip[i])
		continue;
	   x0=(k+1./7.)*width;
	   for (j=0; j<ns; j++) {
	      color(j%6+1);
	      rect(x0+j*swidth, 0., x0+(j+1)*swidth, d[i*ns+j]);
	   }
	   if (dohistnum) {
		   char buf[100];
		   centertext(1);
		   move2(x0 + (j + 0.5)*swidth, d[i * ns + j] + TEXTHEIGHT);
		   sprintf(buf, "%g", d[i * ns + j]);
			printf("%s\n", buf);
		   drawstr(buf);
	   }
	   k++;
	}

	popviewport();
	popattributes();
	popmatrix();

	/*
	 * Set up the text labels for each group of bars
	 */

	pushattributes();
	pushmatrix();
	pushviewport();

	ortho2(-1.0, 1.0, -1.0, 1.0);

	leftjustify();
	color(0);
	textang(-45.0);
	clipping(0);
	textsize(1.1*TEXTWIDTH, 1.1*TEXTHEIGHT);
	linestyle("");

	tinc = (XMAX - XMIN) / ng;
	k = 0;
	for (i = 0; i < ng; i++) {
	   if (hskip && hskip[i])
		continue;
	   sx = (k+0.3) * tinc + XMIN;
	   sy= YMIN-1.1*TEXTHEIGHT;
  	   move2(sx, sy);
	   drawstr(names[i]);
	   k++;
	}

	popviewport();
	popmatrix();
	popattributes();

}

void
histskip(
	int	*h)
{
	hskip = h;
}

void
histnum(
	int	h)
{
	dohistnum = h;
}
vopl/src/plot.c.orig010070000017730000310000000062210700224513400143150ustar00dghels00001250000004#include "vopl.h"

extern		double log10();
extern		double sqrt();

/*
 * plot2
 *
 *	display the 2-d graph described by x and y;
 */
void
plot2(
	float	x[],
	float	y[],
	int	n)
{
	int	i;
	char	err_buf[EBUF_SIZE];
	float	tx, ty, left, right, bottom, top;
	float	dashlen, a, b, c, d;

	/*
	 * Set the view up so that clipping happens...
	 */

	pushmatrix();
	pushviewport();
	pushattributes();

	getviewport(&left, &right, &bottom, &top);

	viewport(left + (1.0 + XMIN) / 2.0 * (right - left),
		right - (1.0 - XMAX) / 2.0 * (right - left),
		bottom + (1.0 + YMIN) / 2.0 * (top - bottom),
		top - (1.0 - YMAX) / 2.0 * (top - bottom));

	if (!plotdev.axes[XIND].scaleset)
		adjustscale(x, n, 'x');

	if (!plotdev.axes[YIND].scaleset)
		adjustscale(y, n, 'y');

	ortho2(WhatX(plotdev.axes[XIND].min), 
	       WhatX(plotdev.axes[XIND].max),
	       WhatY(plotdev.axes[YIND].min),
	       WhatY(plotdev.axes[YIND].max));

	/*
	 * Set dash len so that we get about 200 dashes in one plot
	 */
	a = WhatX(plotdev.axes[XIND].max) - WhatX(plotdev.axes[XIND].min);
	b = WhatY(plotdev.axes[YIND].max) - WhatY(plotdev.axes[YIND].min);

	dashlen = sqrt(a*a + b*b) / 100.0;
	dashlen = 0.015;
	setdash(dashlen);

	/*
	 * Do whatever type of fit is required....
	 */
	switch (plotdev.fit) {
	case NO_LINES:
		/*
		 * Don't do a sniveling thing......
		 */
		break;

	case STRAIGHT_LINE:
		/*
		 * Just draw it.....
		 */

		move2(WhatX(x[0]), WhatY(y[0]));
		for (i = 1; i < n; i++)
			draw2(WhatX(x[i]), WhatY(y[i]));

		break;
	case LEAST_SQUARE:
		/*
 		 * Do an orthogonal polynomial fit.....
		 */

		/*
		 * If degree is zero then simply plot a line y = average y
		 */
		if (plotdev.degree == 0)
			avefit(x, y, n);
		/*
		 * If degree is 1 then it's a simple linear least square fit...
		 */
		else if (plotdev.degree == 1)
			llsfit(x, y, n);
		else
			orthofit(x, y, plotdev.degree, n);
		break;
	case CUBIC_SPLINE:
		/*
		 * Do cubic spline fits......
		 */
		/*
		 * If no endslopes have been used then use VOGLE curve
		 * routine with cardinal splines.
		 */
		if (plotdev.splinetype == FREE) {
			curvebasis(cardinal);
			curveprecision(20);
			cubicsp(x, y, n);
		} else
			spline(x, y, n);
		break;
	case POWER_EQN:
		/*
		 * do power equation fit
		 */
		pefit(x, y, n);
		break;
	case SGR_FIT:
		/*
		 * do a saturated growth rate fit
		 */
		sgrfit(x, y, n);
		break;
	default:
		sprintf(err_buf, "plot2: unknown fit type %d", plotdev.fit);
		vopl_error(err_buf);
	}

	/*
	 * Set up the marker size
	 */

	if (plotdev.markerspacing && plotdev.marker != (char *)NULL) {
		if (plotdev.markerscale != 0.0) {
			pushattributes();
			centertext(1);
			/*clipping(0);*/
			tx = plotdev.markerscale * TEXTWIDTH * WhatX((plotdev.axes[XIND].max - plotdev.axes[XIND].min));
			ty = plotdev.markerscale * TEXTHEIGHT * WhatY((plotdev.axes[YIND].max - plotdev.axes[YIND].min));

			textsize(tx, ty);

			linestyle("");
			for (i = 0; i < n; i += plotdev.markerspacing) {
				move2(WhatX(x[i]), WhatY(y[i]) + 0.15 * ty);
				drawstr(plotdev.marker);
			}
			popattributes();
		} else
			for (i = 0; i < n; i += plotdev.markerspacing)
				point2(WhatX(x[i]), WhatY(y[i]));

	}

	popattributes();
	popviewport();
	popmatrix();
}
vopl/v2pc010070000017730000310000000004710451256651000122520ustar00dghels00001250000004mv Makefile makefile
mv README readme
mv src/Makefile src/makefile
mv src/README src/readme
mv src/sunfort/Makefile src/sunfort/makefile
mv src/adjustscale.c src/adjustsc.c
mv gpp/Makefile gpp/makefile
mv gpp/README gpp/readme
mv examples/Makefile examples/makefile
mv examples/Makefile.f77 examples/makefile.f77
vopl/Makefile.hp010070000017730000310000000033050547725647400135420ustar00dghels00001250000004#
# Makefile for vopl
#
# Usage: make os
#
# You might have to set:
#
#	OS
#	RANLIB
#	MCFLAGS
#	MCFLAGS
#	LIBS
#	F77
#	MFFLAGS
#
############################################################
#
CC = cc

# You can set -DBSD or -DSYS5 here
#
#OS = -DBSD

# If you set -DSYS5 then set RANLIB = "ar ts" or "echo"
RANLIB = echo

#
# Global CFLAGS can be set here. These are the ones we use on a sun.
#
# NOTE: change the -L bit or put libvogle.a 
# where the linker can find them....
#WHERELIBS = -L/decr/dist/vogle/src
#

# Specify the default VOGLE device for gpp here.
#
DEFDEV = -DX11

MCFLAGS = -g $(WHERELIBS)

# If we have fortran we have to say so.
#
F77 = fort77
MFFLAGS = -O +ppu +E3

#
# The name of the library to install and where to put it.
#
LIB = libvopl.a
DEST = /usr/lib

#
# Any other libraries that are needed go here
#

SUNLIBS = -lsuntool -lsunwindow -lpixrect -lX11
X11LIBS = -L/usr/lib/X11R4 -lX11
UNIXLIBS = 
APOLLOLIBS =

LIBS = -lvogle $(X11LIBS)


all:
	cd src; make -f Makefile \
			MCFLAGS="$(MCFLAGS)"

	if test -n "$(F77)" ; \
	then 	cd examples; \
		make -f Makefile.f77 \
			MFFLAGS="$(MFFLAGS)" \
			F77="$(F77)" \
			LIBS="$(LIBS)"; \
	fi; exit 0

	cd examples; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			LIBS="$(LIBS)"

	cd gpp; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			DEFDEV="$(DEFDEV)" \
			LIBS="$(LIBS)"

clean:
	cd src; make clean
	cd examples; make clean
	cd examples; make -f Makefile.f77 clean
	cd gpp; make clean

clobber:
	cd src; make clobber
	cd examples; make clobber
	cd examples; make -f Makefile.f77 clobber
	cd gpp; make clobber

install:
	cp src/$(LIB) $(DEST)
	chmod 644 $(DEST)/$(LIB)
	$(RANLIB) $(DEST)/$(LIB)
	cp src/vopl.h /usr/include
	chmod 644 /usr/include/vopl.h
vopl/Makefile.rs6000010070000017730000310000000037460605745272400140650ustar00dghels00001250000004#
# Makefile for vopl
#
# Usage: make os
#
# You might have to set:
#
#	OS
#	RANLIB
#	MCFLAGS
#	MCFLAGS
#	LIBS
#	F77
#	MFFLAGS
#
############################################################
#
# You can set -DBSD or -DSYS5 here
#
#OS = -DBSD
#OS = -DSYS5

# If you set -DSYS5 then set RANLIB = "ar ts" or "echo"
RANLIB = ranlib

#
# Global CFLAGS can be set here. These are the ones we use on a sun.
#
# NOTE: change the -L bit or put libvogle.a 
# where the linker can find them....
WHERELIBS = -L/home/murumba/guest/labman/vogle/src -I/home/murumba/guest/labman/vogle/src
#

# Specify the default VOGLE device for gpp here.
#
DEFDEV = -DX11

#MCFLAGS = -g $(OS) 
MCFLAGS = $(OS) -O $(WHERELIBS)
#MCFLAGS = $(OS) -O4 -fsingle -f68881 /usr/lib/libm.il
#
# Or on an apollo... (-Wp make it use the 'other cpp')
#MCFLAGS = $(OS) -O -Wp -M3000

#
# If we have fortran we have to say so.
#
F77 = xlf -qextname
# Global FFLAGS can be set here. These are the ones we use on a sun.
#
MFFLAGS = $(OS) -g $(WHERELIBS)
#MFFLAGS = $(OS) -O 

#
# The name of the library to install and where to put it.
#
LIB = libvopl.a
DEST = /usr/lib

#
# Any other libraries that are needed go here
#

SUNLIBS = -lsuntool -lsunwindow -lpixrect -lX11
X11LIBS = -lX11
UNIXLIBS = 
APOLLOLIBS =

LIBS = -lvogle $(X11LIBS)


all:
	cd src; make -f Makefile \
			RANLIB="$(RANLIB)" \
			MCFLAGS="$(MCFLAGS)"

	if test -n "$(F77)" ; \
	then 	cd examples; \
		make -f Makefile.f77 \
			MFFLAGS="$(MFFLAGS)" \
			F77="$(F77)" \
			LIBS="$(LIBS)"; \
	fi; exit 0

	cd examples; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			LIBS="$(LIBS)"

	cd gpp; make -f Makefile \
			MCFLAGS="$(MCFLAGS)" \
			DEFDEV="$(DEFDEV)" \
			LIBS="$(LIBS)"

clean:
	cd src; make clean
	cd examples; make clean
	cd examples; make -f Makefile.f77 clean
	cd gpp; make clean

clobber:
	cd src; make clobber
	cd examples; make clobber
	cd examples; make -f Makefile.f77 clobber
	cd gpp; make clobber

install:
	cp src/$(LIB) $(DEST)
	chmod 644 $(DEST)/$(LIB)
	$(RANLIB) $(DEST)/$(LIB)