Path: utzoo!utgpu!watmath!uunet!fernwood!apple!brutus.cs.uiuc.edu!psuvax1!gatech!ncar!asuvax!noao!arizona!naucse!jdc
From: jdc@naucse.UUCP (John Campbell)
Newsgroups: unix-pc.sources
Subject: gnuplot.shar.06
Message-ID: <1685@naucse.UUCP>
Date: 4 Sep 89 16:42:32 GMT
Organization: Northern Arizona University, Flagstaff, AZ
Lines: 1716


#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 6 (of 7)."
# Contents:  ./command.c ./docs/gnuplot.hlp
# Wrapped by jdc@naucse on Mon Sep  4 09:22:36 1989
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f './command.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'./command.c'\"
else
echo shar: Extracting \"'./command.c'\" \(23912 characters\)
sed "s/^X//" >'./command.c' <<'END_OF_FILE'
X/*
X *
X *    G N U P L O T  --  command.c
X *
X *  Copyright (C) 1986, 1987  Thomas Williams, Colin Kelley
X *
X *  You may use this code as you wish if credit is given and this message
X *  is retained.
X *
X *  Please e-mail any useful additions to vu-vlsi!plot so they may be
X *  included in later releases.
X *
X *  This file should be edited with 4-column tabs!  (:set ts=4 sw=4 in vi)
X */
X
X#include <stdio.h>
X#include <math.h>
X
X#ifdef MSDOS
X#include <process.h>
X#endif
X
X#include "plot.h"
X
X#ifndef STDOUT
X#define STDOUT 1
X#endif
X
X/*
X * global variables to hold status of 'set' options
X *
X */
XBOOLEAN			polar		= FALSE; 
XBOOLEAN			autoscale	= TRUE;
Xchar			dummy_var[MAX_ID_LEN+1] = "x";
Xenum PLOT_STYLE data_style	= POINTS,
X				func_style	= LINES;
XBOOLEAN			log_x		= FALSE,
X				log_y		= FALSE;
XFILE*			outfile;
Xchar			outstr[MAX_ID_LEN+1] = "STDOUT";
Xint				samples		= SAMPLES;
Xint				term		= 0;				/* unknown term is 0 */
Xdouble			xmin		= -10.0,
X				xmax		= 10.0,
X				ymin		= -10.0,
X				ymax		= 10.0;
Xdouble			loff		= 0.0,
X				roff		= 0.0,
X				toff		= 0.0,
X				boff		= 0.0;
Xdouble			zero = ZERO;			/* zero threshold, not 0! */
X
X
XBOOLEAN screen_ok;
XBOOLEAN term_init;
XBOOLEAN undefined;
X
X/*
X * instead of <strings.h>
X */
X
Xchar *gets(),*getenv();
Xchar *strcpy(),*strncpy(),*strcat();
X
Xchar *malloc();
X
Xdouble magnitude(),angle(),real(),imag();
Xstruct value *const_express(), *pop(), *complex();
Xstruct at_type *temp_at(), *perm_at();
Xstruct udft_entry *add_udf();
Xstruct udvt_entry *add_udv();
X
Xextern struct termentry term_tbl[];
X
Xstruct lexical_unit token[MAX_TOKENS];
Xchar input_line[MAX_LINE_LEN+1] = "set term ";
Xchar c_dummy_var[MAX_ID_LEN+1]; 		/* current dummy var */
Xint num_tokens, c_token;
X
Xstruct curve_points *first_plot = NULL;
Xstruct udft_entry plot_func, *dummy_func;
X
Xstatic char replot_line[MAX_LINE_LEN+1];
Xstatic int plot_token;					/* start of 'plot' command */
Xstatic char help[MAX_LINE_LEN] = HELP;
X
Xcom_line()
X{
X	read_line();
X
X	screen_ok = TRUE; /* so we can flag any new output */
X
X	do_line();
X}
X
X
Xdo_line()	  /* also used in load_file */
X{
X	if (is_comment(input_line[0]))
X		return;
X	if (is_system(input_line[0])) {
X		do_system();
X		fputs("!\n",stderr);
X		return;
X	}
X	num_tokens = scanner(input_line);
X	c_token = 0;
X	while(c_token < num_tokens) {
X		command();
X		if (c_token < num_tokens)	/* something after command */
X			if (equals(c_token,";"))
X				c_token++;
X			else
X					int_error("';' expected",c_token);
X	}
X}
X
X
X
Xcommand()
X{
Xstatic char sv_file[MAX_LINE_LEN+1];
X			/* string holding name of save or load file */
X
X	c_dummy_var[0] = '\0';		/* no dummy variable */
X
X	if (is_definition(c_token))
X		define();
X	else if (equals(c_token,"help") || equals(c_token,"?")) {
X		register int len;
X		register char *help_ptr;
X
X		c_token++;
X		if ((help_ptr = getenv("GNUHELP")))	/* initial command */
X			(void) strncpy(help,help_ptr,sizeof(help) - 1);
X		else
X			(void) strncpy(help,HELP,sizeof(help) - 1);
X
X		while (!(END_OF_COMMAND)) {
X			len = strlen(help);
X			help[len] = ' ';   /* put blank between help segments */
X			copy_str(help+len+1,c_token++);
X		}
X		do_help();
X		screen_ok = FALSE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"pa$use")) {
X		struct value a;
X		int stime, text=0, len;
X		char buf[MAX_LINE_LEN+1], *ptr;
X
X		c_token++;
X		stime = (int )real(const_express(&a));
X		if (!(END_OF_COMMAND)) {
X			if (!isstring(c_token))
X				int_error("expecting string",c_token);
X			else {
X			/*	Unfortunately, quote_str has a ID limit. */
X				len = token[c_token].length - 2;
X				ptr = &input_line[token[c_token].start_index+1];
X				fprintf (stderr, "%.*s", len,ptr);
X				text = 1;
X			}
X		}
X		if (stime < 0) fgets (buf,MAX_LINE_LEN,stdin);  /* Hold until CR hit. */
X		if (stime > 0) sleep(stime);
X		if (text != 0 && stime >= 0) fprintf (stderr,"\n");
X		c_token++;
X		screen_ok = FALSE;
X	}
X	else if (almost_equals(c_token,"pr$int")) {
X		struct value a;
X
X		c_token++;
X		(void) const_express(&a);
X		(void) putc('\t',stderr);
X		disp_value(stderr,&a);
X		(void) putc('\n',stderr);
X		screen_ok = FALSE;
X	}
X	else if (almost_equals(c_token,"p$lot")) {
X		plot_token = c_token++;
X		plotrequest();
X	}
X	else if (almost_equals(c_token,"rep$lot")) {
X		if (replot_line[0] == '\0') 
X			int_error("no previous plot",c_token);
X		(void) strcpy(input_line,replot_line);
X		screen_ok = FALSE;
X		num_tokens = scanner(input_line);
X		c_token = 1;					/* skip the 'plot' part */
X		plotrequest();
X	}
X	else if (almost_equals(c_token,"se$t"))
X		set_stuff();
X	else if (almost_equals(c_token,"sh$ow"))
X		show_stuff();
X	else if (almost_equals(c_token,"cl$ear")) {
X		if (!term_init) {
X			(*term_tbl[term].init)();
X			term_init = TRUE;
X		}
X		(*term_tbl[term].graphics)();
X		(*term_tbl[term].text)();
X		(void) fflush(outfile);
X		screen_ok = FALSE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"she$ll")) {
X		do_shell();
X		screen_ok = FALSE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"sa$ve")) {
X		if (almost_equals(++c_token,"f$unctions")) {
X			if (!isstring(++c_token))
X				int_error("expecting filename",c_token);
X			else {
X				quote_str(sv_file,c_token);
X				save_functions(fopen(sv_file,"w"));
X			}
X		}
X		else if (almost_equals(c_token,"v$ariables")) {
X			if (!isstring(++c_token))
X				int_error("expecting filename",c_token);
X			else {
X				quote_str(sv_file,c_token);
X				save_variables(fopen(sv_file,"w"));
X			}
X		}
X		else if (isstring(c_token)) {
X			quote_str(sv_file,c_token);
X			save_all(fopen(sv_file,"w"));
X		}
X		else {
X			int_error(
X		"filename or keyword 'functions' or 'variables' expected",c_token);
X		}
X		c_token++;
X	}
X	else if (almost_equals(c_token,"l$oad")) {
X		if (!isstring(++c_token))
X			int_error("expecting filename",c_token);
X		else {
X			quote_str(sv_file,c_token);
X			load_file(fopen(sv_file,"r"));	
X		/* input_line[] and token[] now destroyed! */
X			c_token = num_tokens = 0;
X		}
X	}
X	else if (almost_equals(c_token,"ex$it") ||
X			almost_equals(c_token,"q$uit")) {
X		done(IO_SUCCESS);
X	}
X	else if (!equals(c_token,";")) {		/* null statement */
X		int_error("invalid command",c_token);
X	}
X}
X
X
Xenum PLOT_STYLE
Xget_style()
X{
Xregister enum PLOT_STYLE ps;
X
X	c_token++;
X	if (almost_equals(c_token,"l$ines"))
X		ps = LINES;
X	else if (almost_equals(c_token,"i$mpulses"))
X		ps = IMPULSES;
X	else if (almost_equals(c_token,"p$oints"))
X		ps = POINTS;
X	else
X		int_error("expecting 'lines', 'points', or 'impulses'",c_token);
X	c_token++;
X	return(ps);
X}
X
X
Xset_stuff()
X{
Xstatic char testfile[MAX_LINE_LEN+1];
X
X	if (almost_equals(++c_token,"a$utoscale")) {
X		autoscale = TRUE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"noa$utoscale")) {
X		autoscale = FALSE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"po$lar")) {
X		polar = TRUE;
X		xmin = 0.0;
X		xmax = 2*Pi;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"nopo$lar")) {
X		polar = FALSE;
X		xmin = -10.0;
X		xmax = 10.0;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"d$ata")) {
X		c_token++;
X		if (!almost_equals(c_token,"s$tyle"))
X			int_error("expecting keyword 'style'",c_token);
X		data_style = get_style();
X	}
X	else if (almost_equals(c_token,"d$ummy")) {
X		c_token++;
X		copy_str(dummy_var,c_token++);
X	}
X	else if (almost_equals(c_token,"f$unction")) {
X		c_token++;
X		if (!almost_equals(c_token,"s$tyle"))
X			int_error("expecting keyword 'style'",c_token);
X		func_style = get_style();
X	}
X	else if (almost_equals(c_token,"l$ogscale")) {
X		c_token++;
X		if (equals(c_token,"x")) {
X			log_y = FALSE;
X			log_x = TRUE;
X			c_token++;
X		}
X		else if (equals(c_token,"y")) {
X			log_x = FALSE;
X			log_y = TRUE;
X			c_token++;
X		}
X		else if (equals(c_token,"xy") || equals(c_token,"yx")) {
X			log_x = log_y = TRUE;
X			c_token++;
X		}
X		else
X			int_error("expecting 'x', 'y', or 'xy'",c_token);
X	}
X	else if (almost_equals(c_token,"nol$ogscale")) {
X		log_x = log_y = FALSE;
X		c_token++;
X	}
X	else if (almost_equals(c_token,"of$fsets")) {
X		c_token++;
X		if (END_OF_COMMAND) {
X			loff = roff = toff = boff = 0.0;  /* Reset offsets */
X		}
X		else {
X			load_offsets (&loff,&roff,&toff,&boff);
X		}
X	}
X	else if (almost_equals(c_token,"o$utput")) {
X		register FILE *f;
X
X		c_token++;
X		if (END_OF_COMMAND) {	/* no file specified */
X 			UP_redirect (4);
X#ifdef VMS
X			if (outfile != stdout) /* Never close stdout */
X#endif
X			(void) fclose(outfile);
X#ifdef VMS
X			outfile = stdout; /* Avoid the dup... */
X#else
X			outfile = fdopen(dup(STDOUT), "w");
X#endif
X			term_init = FALSE;
X			(void) strcpy(outstr,"STDOUT");
X		} else if (!isstring(c_token))
X			int_error("expecting filename",c_token);
X		else {
X			quote_str(testfile,c_token);
X			if (!(f = fopen(testfile,"w"))) {
X			  os_error("cannot open file; output not changed",c_token);
X			}
X#ifdef VMS
X			if (outfile != stdout) /* Never close stdout */
X#endif
X			(void) fclose(outfile);
X			outfile = f;
X			term_init = FALSE;
X			outstr[0] = '\'';
X			(void) strcat(strcpy(outstr+1,testfile),"'");
X 			UP_redirect (1);
X		}
X		c_token++;
X	}
X	else if (almost_equals(c_token,"sa$mples")) {
X		register int tsamp;
X		struct value a;
X
X		c_token++;
X		tsamp = (int)magnitude(const_express(&a));
X		if (tsamp < 1)
X			int_error("sampling rate must be > 0; sampling unchanged",
X				c_token);
X		else {
X			register struct curve_points *f_p = first_plot;
X
X			first_plot = NULL;
X			cp_free(f_p);
X			samples = tsamp;
X		}
X	}
X	else if (almost_equals(c_token,"t$erminal")) {
X		c_token++;
X		if (END_OF_COMMAND) {
X			list_terms();
X			screen_ok = FALSE;
X		}
X		else
X			term = set_term(c_token);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"x$range")) {
X		c_token++;
X		if (!equals(c_token,"["))
X			int_error("expecting '['",c_token);
X		c_token++;
X		load_range(&xmin,&xmax);
X		if (!equals(c_token,"]"))
X			int_error("expecting ']'",c_token);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"y$range")) {
X		c_token++;
X		if (!equals(c_token,"["))
X			int_error("expecting '['",c_token);
X		c_token++;
X		load_range(&ymin,&ymax);
X		autoscale = FALSE;
X		if (!equals(c_token,"]"))
X			int_error("expecting ']'",c_token);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"z$ero")) {
X		struct value a;
X		c_token++;
X		zero = magnitude(const_express(&a));
X	}
X	else
X		int_error(
X	"valid set options:  '[no]autoscale', 'data', 'dummy', 'function',\n\
X'[no]logscale', 'offsets', 'output', '[no]polar', 'samples',\n\
X'terminal', 'xrange', 'yrange', 'zero'",
X	c_token);
X}
X
X
Xshow_stuff()
X{
X	if (almost_equals(++c_token,"ac$tion_table") ||
X			 equals(c_token,"at") ) {
X		c_token++;
X		show_at();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"au$toscale")) {
X		(void) putc('\n',stderr);
X		show_autoscale();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"d$ata")) {
X		c_token++;
X		if (!almost_equals(c_token,"s$tyle"))
X			int_error("expecting keyword 'style'",c_token);
X		(void) putc('\n',stderr);
X		show_style("data",data_style);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"d$ummy")) {
X		fprintf(stderr,"\n\tdummy variable is %s\n",dummy_var);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"f$unctions")) {
X		c_token++;
X		if (almost_equals(c_token,"s$tyle"))  {
X			(void) putc('\n',stderr);
X			show_style("functions",func_style);
X			c_token++;
X		}
X		else
X			show_functions();
X	}
X	else if (almost_equals(c_token,"l$ogscale")) {
X		(void) putc('\n',stderr);
X		show_logscale();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"of$fsets")) {
X		(void) putc('\n',stderr);
X		show_offsets();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"o$utput")) {
X		(void) putc('\n',stderr);
X		show_output();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"po$lar")) {
X		(void) putc('\n',stderr);
X		show_polar();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"sa$mples")) {
X		(void) putc('\n',stderr);
X		show_samples();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"t$erminal")) {
X		(void) putc('\n',stderr);
X		show_term();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"v$ariables")) {
X		show_variables();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"ve$rsion")) {
X		show_version();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"x$range")) {
X		(void) putc('\n',stderr);
X		show_range('x',xmin,xmax);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"y$range")) {
X		(void) putc('\n',stderr);
X		show_range('y',ymin,ymax);
X		c_token++;
X	}
X	else if (almost_equals(c_token,"z$ero")) {
X		(void) putc('\n',stderr);
X		show_zero();
X		c_token++;
X	}
X	else if (almost_equals(c_token,"a$ll")) {
X		c_token++;
X		show_version();
X		show_polar();
X		fprintf(stderr,"\tdummy variable is %s\n",dummy_var);
X		show_style("data",data_style);
X		show_style("functions",func_style);
X		show_output();
X		show_term();
X		show_samples();
X		show_logscale();
X		show_autoscale();
X		show_zero();
X		show_range('x',xmin,xmax);
X		show_range('y',ymin,ymax);
X		show_offsets();
X		show_variables();
X		show_functions();
X		c_token++;
X	}
X	else
X		int_error(
X	"valid show options:  'action_table', 'all', 'autoscale', 'data',\n\
X'dummy', 'function', 'logscale', 'offsets', 'output', 'polar',\n\
X'samples', 'terminal', 'variables', 'version', 'xrange', 'yrange', 'zero'",
Xc_token);
X	screen_ok = FALSE;
X	(void) putc('\n',stderr);
X}
X
X
Xload_offsets (a, b, c, d)
Xdouble *a,*b, *c, *d;
X{
Xstruct value t;
X
X	*a = real (const_express(&t));  /* loff value */
X	c_token++;
X	if (equals(c_token,","))
X		c_token++;
X	if (END_OF_COMMAND) 
X	    return;
X
X	*b = real (const_express(&t));  /* roff value */
X	c_token++;
X	if (equals(c_token,","))
X		c_token++;
X	if (END_OF_COMMAND) 
X	    return;
X
X	*c = real (const_express(&t));  /* toff value */
X	c_token++;
X	if (equals(c_token,","))
X		c_token++;
X	if (END_OF_COMMAND) 
X	    return;
X
X	*d = real (const_express(&t));  /* boff value */
X	c_token++;
X}
X
X
Xload_range(a,b)
Xdouble *a,*b;
X{
Xstruct value t;
X
X	if (equals(c_token,"]"))
X		return;
X	if (END_OF_COMMAND) {
X	    int_error("starting range value or ':' expected",c_token);
X	} else if (!equals(c_token,"to") && !equals(c_token,":"))  {
X		*a = real(const_express(&t));
X	}	
X	if (!equals(c_token,"to") && !equals(c_token,":"))
X		int_error("':' expected",c_token);
X	c_token++;
X	if (!equals(c_token,"]"))
X		*b = real(const_express(&t));
X}
X
X
Xplotrequest()
X{
X	
X	if (!term)					/* unknown */
X		int_error("use 'set term' to set terminal type first",c_token);
X
X	if (equals(c_token,"[")) {
X		c_token++;
X		if (isletter(c_token)) {
X			copy_str(c_dummy_var,c_token++);
X			if (equals(c_token,"="))
X				c_token++;
X			else
X				int_error("'=' expected",c_token);
X		}
X		load_range(&xmin,&xmax);
X		if (!equals(c_token,"]"))
X			int_error("']' expected",c_token);
X		c_token++;
X	}
X
X	if (equals(c_token,"[")) { /* set optional y ranges */
X		c_token++;
X		load_range(&ymin,&ymax);
X		autoscale = FALSE;
X		if (!equals(c_token,"]"))
X			int_error("']' expected",c_token);
X		c_token++;
X	}
X
X	eval_plots();
X}
X
X
Xdefine()
X{
Xregister int start_token;  /* the 1st token in the function definition */
Xregister struct udvt_entry *udv;
Xregister struct udft_entry *udf;
X
X	if (equals(c_token+1,"(")) {
X		/* function ! */
X		start_token = c_token;
X		copy_str(c_dummy_var, c_token + 2);
X		c_token += 5; /* skip (, dummy, ) and = */
X		if (END_OF_COMMAND)
X			int_error("function definition expected",c_token);
X		udf = dummy_func = add_udf(start_token);
X		if (udf->at)				/* already a dynamic a.t. there */
X			free((char *)udf->at);	/* so free it first */
X		if (!(udf->at = perm_at()))
X			int_error("not enough memory for function",start_token);
X		m_capture(&(udf->definition),start_token,c_token-1);
X	}
X	else {
X		/* variable ! */
X		start_token = c_token;
X		c_token +=2;
X		udv = add_udv(start_token);
X		(void) const_express(&(udv->udv_value));
X		udv->udv_undef = FALSE;
X	}
X}
X
X
Xget_data(this_plot)
Xstruct curve_points *this_plot;
X{
Xstatic char data_file[MAX_LINE_LEN+1], line[MAX_LINE_LEN+1];
Xregister int i, overflow, l_num;
Xregister FILE *fp;
Xfloat x, y;
X
X	quote_str(data_file, c_token);
X	this_plot->plot_type = DATA;
X	if (!(fp = fopen(data_file, "r")))
X		os_error("can't open data file", c_token);
X
X	l_num = 0;
X
X	overflow = i = 0;
X
X	while (fgets(line, MAX_LINE_LEN, fp)) {
X		l_num++;
X		if (is_comment(line[0]) || ! line[1])	/* line[0] will be '\n' */
X			continue;		/* ignore comments  and blank lines */
X
X		if (i == samples+1) {
X			overflow = i;	/* keep track for error message later */
X			i--;			/* so we don't fall off end of points[i] */
X		}
X		switch (sscanf(line, "%f %f", &x, &y)) {
X			case 1:			/* only one number on the line */
X				y = x;		/* so use it as the y value, */
X				x = i;		/* and use the index as the x */
X			/* no break; !!! */
X			case 2:
X				this_plot->points[i].undefined = TRUE;
X				if (x >= xmin && x <= xmax && (autoscale ||
X					(y >= ymin && y <= ymax))) {
X					if (log_x) {
X						if (x <= 0.0)
X							break;
X						this_plot->points[i].x = log10(x);
X					} else
X						this_plot->points[i].x = x;
X					if (log_y) {
X						if (y <= 0.0)
X							break;
X						this_plot->points[i].y = log10(y);
X					} else
X						this_plot->points[i].y = y;
X					if (autoscale) {
X						if (y < ymin) ymin = y;
X						if (y > ymax) ymax = y;
X					}
X
X					this_plot->points[i].undefined = FALSE;
X				}
X				if (overflow)
X					overflow++;
X				else
X					i++;
X				break;
X
X			default:
X				(void) sprintf(line, "bad data on line %d", l_num);
X				int_error(line,c_token);
X		}
X	}
X	if (overflow) {
X		(void) sprintf(line,
X	"%d data points found--samples must be set at least this high",overflow);
X				/* actually, samples can be one less! */
X		int_error(line,c_token);
X	}
X	this_plot->p_count = i;
X	(void) fclose(fp);
X}
X
X
Xeval_plots()
X{
Xregister int i;
Xregister struct curve_points *this_plot, **tp_ptr;
Xregister int start_token, mysamples;
Xregister double x_min, x_max, y_min, y_max, x;
Xregister double xdiff, temp;
Xregister int plot_num;
Xstatic struct value a;
X
X	/* don't sample higher than output device can handle! */
X	mysamples = (samples <= term_tbl[term].xmax) ?samples :term_tbl[term].xmax;
X
X	if (log_x) {
X		if (xmin < 0.0 || xmax < 0.0)
X			int_error("x range must be above 0 for log scale!",NO_CARET);
X		x_min = log10(xmin);
X		x_max = log10(xmax);
X	} else {
X		x_min = xmin;
X		x_max = xmax;
X	}
X
X	if (autoscale) {
X		ymin = HUGE;
X		ymax = -HUGE;
X	} else if (log_y && (ymin <= 0.0 || ymax <= 0.0))
X			int_error("y range must be above 0 for log scale!",
X				NO_CARET);
X
X	xdiff = (x_max - x_min) / mysamples;
X
X	tp_ptr = &(first_plot);
X	plot_num = 0;
X
X	while (TRUE) {
X		if (END_OF_COMMAND)
X			int_error("function to plot expected",c_token);
X
X		start_token = c_token;
X
X		if (is_definition(c_token)) {
X			define();
X		} else {
X			plot_num++;
X			if (*tp_ptr)
X				this_plot = *tp_ptr;
X			else {		/* no memory malloc()'d there yet */
X				this_plot = (struct curve_points *)
X					malloc((unsigned int) (sizeof(struct curve_points) -
X					(MAX_POINTS - (samples+1))*sizeof(struct coordinate)));
X				if (!this_plot)
X					int_error("out of memory",c_token);
X				this_plot->next_cp = NULL;
X				this_plot->title = NULL;
X				*tp_ptr = this_plot;
X			}
X
X			if (isstring(c_token)) {			/* data file to plot */
X				this_plot->plot_type = DATA;
X				this_plot->plot_style = data_style;
X				get_data(this_plot);
X				c_token++;
X			}
X			else {							/* function to plot */
X				this_plot->plot_type = FUNC;
X				this_plot->plot_style = func_style;
X
X				(void) strcpy(c_dummy_var,dummy_var);
X				dummy_func = &plot_func;
X
X				plot_func.at = temp_at();
X
X				for (i = 0; i <= mysamples; i++) {
X					if (i == samples+1)
X						int_error("number of points exceeded samples",
X							NO_CARET);
X					x = x_min + i*xdiff;
X					if (log_x)
X						x = pow(10.0,x);
X					(void) complex(&plot_func.dummy_value, x, 0.0);
X					
X					evaluate_at(plot_func.at,&a);
X
X					if (this_plot->points[i].undefined =
X						undefined || (fabs(imag(&a)) > zero))
X							continue;
X				/*	
X					The old code used plot_type to generate x, but with
X					polar and offset concepts we need to record the x
X					value.
X				*/
X					this_plot->points[i].x = x;
X
X					temp = real(&a);
X
X					if (log_y && temp <= 0.0) {
X							this_plot->points[i].undefined = TRUE;
X							continue;
X					}
X					if (autoscale) {
X						if (temp < ymin) ymin = temp;
X						if (temp > ymax) ymax = temp;
X					} else if (temp < ymin || temp > ymax) {
X						this_plot->points[i].undefined = TRUE;
X						continue;
X					}
X
X					this_plot->points[i].y = log_y ? log10(temp) : temp;
X				}
X				this_plot->p_count = i; /* mysamples + 1 */
X			}
X			m_capture(&(this_plot->title),start_token,c_token-1);
X			if (almost_equals(c_token,"w$ith"))
X				this_plot->plot_style = get_style();
X			tp_ptr = &(this_plot->next_cp);
X		}
X
X		if (equals(c_token,","))
X			c_token++;
X		else
X			break;
X	}
X
X	if (autoscale && (ymin == ymax))
X		ymax += 1.0;	/* kludge to avoid divide-by-zero in do_plot */
X
X	if (log_y) {
X		y_min = log10(ymin);
X		y_max = log10(ymax);
X	} else {
X		y_min = ymin;
X		y_max = ymax;
X	}
X	capture(replot_line,plot_token,c_token);	
X	do_plot(first_plot,plot_num,x_min,x_max,y_min,y_max);
X}
X
X
X
Xdone(status)
Xint status;
X{
X	if (term)
X		(*term_tbl[term].reset)();
X	exit(status);
X}
X
X
X#ifdef vms
X
X#include <descrip.h>
X#include <rmsdef.h>
X#include <errno.h>
X
Xextern lib$get_input(), lib$put_output();
X
Xint vms_len;
X
Xunsigned int status[2] = {1, 0};
X
X$DESCRIPTOR(prompt_desc,PROMPT);
X$DESCRIPTOR(line_desc,input_line);
X
X$DESCRIPTOR(help_desc,help);
X$DESCRIPTOR(helpfile_desc,"GNUPLOT$HELP");
X
X
Xread_line()
X{
X	switch(status[1] = lib$get_input(&line_desc, &prompt_desc, &vms_len)){
X		case RMS$_EOF:
X			done(IO_SUCCESS);	/* ^Z isn't really an error */
X			break;
X		case RMS$_TNS:			/* didn't press return in time */
X			vms_len--;		/* skip the last character */
X			break;			/* and parse anyway */
X		case RMS$_BES:			/* Bad Escape Sequence */
X		case RMS$_PES:			/* Partial Escape Sequence */
X			sys$putmsg(status);
X			vms_len = 0;		/* ignore the line */
X			break;
X		case SS$_NORMAL:
X			break;			/* everything's fine */
X		default:
X			done(status[1]);	/* give the error message */
X	}
X	input_line[vms_len] = '\0';
X}
X
X
Xdo_help()
X{
X	help_desc.dsc$w_length = strlen(help);
X	if ((vaxc$errno = lbr$output_help(lib$put_output,0,&help_desc,
X		&helpfile_desc,0,lib$get_input)) != SS$_NORMAL)
X			os_error("can't open GNUPLOT$HELP");
X}
X
X
Xdo_shell()
X{
X	if ((vaxc$errno = lib$spawn()) != SS$_NORMAL) {
X		os_error("spawn error",NO_CARET);
X	}
X}
X
X
Xdo_system()
X{
X	input_line[0] = ' ';	/* an embarrassment, but... */
X
X	if ((vaxc$errno = lib$spawn(&line_desc)) != SS$_NORMAL)
X		os_error("spawn error",NO_CARET);
X
X	(void) putc('\n',stderr);
X}
X
X#else /* vms */
X
Xdo_help()
X{
X	if (system(help))
X		os_error("can't spawn help",c_token);
X}
X
X
Xdo_system()
X{
X	if (system(input_line + 1))
X		os_error("system() failed",NO_CARET);
X}
X
X#ifdef MSDOS
X
Xread_line()
X{
Xregister int i;
X
X	input_line[0] = MAX_LINE_LEN - 1;
X	cputs(PROMPT);
X	cgets(input_line);			/* console input so CED will work */
X	(void) putc('\n',stderr);
X	if (input_line[2] == 26) {
X		(void) putc('\n',stderr);		/* end-of-file */
X		done(IO_SUCCESS);
X	}
X
X	i = 0;
X	while (input_line[i] = input_line[i+2])
X		i++;		/* yuck!  move everything down two characters */
X}
X
X
Xdo_shell()
X{
Xregister char *comspec;
X	if (!(comspec = getenv("COMSPEC")))
X		comspec = "\command.com";
X	if (spawnl(P_WAIT,comspec,NULL) == -1)
X		os_error("unable to spawn shell",NO_CARET);
X}
X
X#else /* MSDOS */
X		/* plain old Unix */
X
Xread_line()
X{
X	fputs(PROMPT,stderr);
X	if (!fgets(input_line, MAX_LINE_LEN, stdin)) {
X		(void) putc('\n',stderr);		/* end-of-file */
X		done(IO_SUCCESS);
X	}
X	else {
X		input_line[strlen(input_line)-1] = '\0';  /* Remove trailing \n */
X	}
X}
X
X#ifdef VFORK
X
Xdo_shell()
X{
Xregister char *shell;
Xregister int p;
Xstatic int execstat;
X	if (!(shell = getenv("SHELL")))
X		shell = SHELL;
X	if ((p = vfork()) == 0) {
X		execstat = execl(shell,shell,NULL);
X		_exit(1);
X	} else if (p == -1)
X		os_error("vfork failed",c_token);
X	else
X		while (wait(NULL) != p)
X			;
X	if (execstat == -1)
X		os_error("shell exec failed",c_token);
X	(void) putc('\n',stderr);
X}
X#else /* VFORK */
X
X#define EXEC "exec "
Xdo_shell()
X{
Xstatic char exec[100] = EXEC;
Xregister char *shell;
X	if (!(shell = getenv("SHELL")))
X		shell = SHELL;
X
X	if (system(strncpy(&exec[sizeof(EXEC)-1],shell,
X		sizeof(exec)-sizeof(EXEC)-1)))
X		os_error("system() failed",NO_CARET);
X
X	(void) putc('\n',stderr);
X}
X#endif /* VFORK */
X#endif /* MSDOS */
X#endif /* vms */
END_OF_FILE
if test 23912 -ne `wc -c <'./command.c'`; then
    echo shar: \"'./command.c'\" unpacked with wrong size!
fi
# end of './command.c'
fi
if test -f './docs/gnuplot.hlp' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'./docs/gnuplot.hlp'\"
else
echo shar: Extracting \"'./docs/gnuplot.hlp'\" \(19621 characters\)
sed "s/^X//" >'./docs/gnuplot.hlp' <<'END_OF_FILE'
X
X GNUPLOT is a command-driven interactive function plotting program.  It
X is case sensitive (commands and function names written in lowercase
X are not the same as those written in CAPS).  All command names may be
X abbreviated, as long as the abbreviation is not ambiguous.  Any number
X of commands may appear on a line, separated by semicolons (;).
X
X Type the EOF character (^D for UNIX, ^Z for DOS) to exit the help system
X from any level and return to GNUPLOT.  <RETURN> goes back to the previous
X level and to GNUPLOT from top level help.
X1 clear
X This command erases the current screen or output device as specified
X by 'set output'.  This usually generates a formfeed on hardcopy
X devices.  Use 'set terminal' to set the device type.
X1 exit
X 'exit', 'quit' and your computer's END-OF-FILE character will exit
X GNUPLOT.  All these commands will clear the output device (as the
X 'clear' command does) before exiting.
X1 expressions
X2 functions
X3 abs
X This function returns the absolute value of its argument.  The
X returned value is of the same type as the argument.
X
X For complex arguments, abs(x) is defined as the length of x in the
X complex plane [i.e.  sqrt(real(x)**2 + imag(x)**2) ].
X3 acos
X This function returns the arc cosine (inverse cosine) of its
X argument.  'acos' returns its argument in radians.
X3 arg
X This function returns the phase of a complex number, in radians.
X3 asin
X This function returns the arc sin (inverse sin) of its argument.
X 'asin' returns its argument in radians.
X3 atan
X This function returns the arc tangent (inverse tangent) of its
X argument.  'atan' returns its argument in radians.
X3 besj0
X This function returns the j0th Bessel function of its argument.
X 'besj0' expects its argument to be in radians.
X3 besj1
X This function returns the j1st Bessel function of its argument.
X 'besj1' expects its argument to be in radians.
X3 besy0
X This function returns the y0th Bessel function of its argument.
X 'besy0' expects its argument to be in radians.
X3 besy1
X This function returns the y1st Bessel function of its argument.
X 'besy1' expects its argument to be in radians.
X3 ceil
X This function returns the largest integer not less than its
X argument.  For complex numbers, 'ceil' returns the largest integer
X not less than the real part of its argument.
X3 cos
X This function returns the cosine of its argument.  'cos' expects its
X argument to be in radians.
X3 cosh
X This function returns the hyperbolic cosine of its argument.
X 'cosh' expects its argument to be in radians.
X3 exp
X This function returns the exponential function of its argument
X (e raised to the power of its argument).
X3 floor
X This function returns the smallest integer not greater than its
X argument.  For complex numbers, 'floor' returns the smallest
X integer not greater than the real part of its argument.
X3 imag
X This function returns the imaginary part of its argument as a real number.
X3 int
X This function returns the integer part of its argument, truncated
X toward zero.
X3 log
X This function returns the natural logarithm (base e) of its
X argument.
X3 log10
X This function returns the logarithm (base 10) of its argument.
X3 real
X This function returns the real part of its argument.
X3 sgn
X This function returns 1 if its argument is positive, -1 if its
X argument is negative, and 0 if its argument is 0.  If the argument
X is a complex value, the imaginary component is ignored.
X3 sin
X This function returns the sine of its argument.  'sin' expects its
X argument to be in radians.
X3 sinh
X This function returns the hyperbolic sine of its argument.  'sinh'
X expects its argument to be in radians.
X3 sqrt
X This function returns the square root of its argument.
X3 tan
X This function returns the tangent of its argument.  'tan' expects
X its argument to be in radians.
X3 tanh
X This function returns the hyperbolic tangent of its argument.
X 'tanh' expects its argument to be in radians.
X2 operators
X3 binary
X The following is a list of all the binary operators and their
X usages:
X
X  Symbol 	Example 	 Explanation
X   **     	 a**b    	  exponentiation
X   *      	 a*b     	  multiplication
X   /      	 a/b     	  division
X   %      	 a%b     	* modulo
X   +      	 a+b     	  addition
X   -      	 a-b     	  subtraction
X   ==     	 a==b    	  equality
X   !=     	 a!=b    	  inequality
X   &      	 a&b     	* bitwise and
X   ^      	 a^b     	* bitwise exclusive or
X   |      	 a|b     	* bitwise inclusive or
X   &&     	 a&&b    	* logical and
X   ||     	 a||b    	* logical or
X   ?:     	 a?b:c   	* ternary operation
X
X (*) Starred explanations indicate that the operator requires
X integer arguments.
X
X Logical AND (&&) and OR (||) short-circuit the way they do in C.
X That is, the second && operand is not evaluated if the first is
X false; the second || operand is not evaluated if the first is true.
X
X The ternary operator evaluates its first argument (a).  If it is
X true (non-zero) the second argument (b) is evaluated and returned,
X otherwise the third argument (c) is evaluated and returned.
X3 unary
X The following is a list of all the unary operators and their
X usages:
X
X  Symbol 	Example 	 Explanation
X   -      	 -a      	  unary minus
X   ~      	 ~a      	* one's complement
X   !      	 !a      	* logical negation
X   !      	 a!      	* factorial
X
X (*) Starred explanations indicate that the operator requires an
X integer argument.
X
X The factorial operator returns a real number to allow a greater range.
X1 help
X The 'help' command displays on-line help.  To specify information on a
X particular topic use the syntax:
X
X     help <topic>
X
X Help is actually a separate program.  If help doesn't work for you, ask
X your administrator how to set up the GNUHELP environment variable (and
X possibly the HELPDIR environment variable).
X
X You may exit the help utility and return to GNUPLOT by either pressing
X <Return>(s) at the 'HELP >' prompt or pressing your computer's END-OF-FILE
X character at any help prompt.
X1 load
X This command executes each line of the specified input file as if it
X had been typed in interactively.  Files created by the 'save' command
X can later be 'load'ed.  Any text file containing valid commands can be
X created and then executed by the 'load' command.  Files being 'load'ed
X may themselves contain 'load' commands.  Lines beginning with # (or !
X if using VMS) will be treated as comments and ignored.
X
X The 'load' command must be the last command on the line.
X
X Syntax:
X         load <input-file>
X
X The name of the input file must be enclosed in quotes.
X
X Examples:
X
X         load 'work.gnu'
X         load "func.dat"
X1 pause
X Pause is useful in conjunction with `load` files.  The command 'pause'
X displays any text associated with the command and then waits the
X specified amount of time.  This allows one to build a 'load' file
X and control the amount of time a finished graph is displayed.  The
X first argument is an expression that can be -1, 0, 1, 2, ...  -1
X will wait until a carriage return is hit.  0 won't pause at all, and
X 1, 2, etc. will wait the specified number of seconds.
X
X Note: Since pause is not part of the plot it may interact with
X different device drivers differently (depending upon how text and
X graphics are mixed).
X
X Examples:
X         pause -1    ! Wait until a carriage return is hit
X         pause 3     ! Wait three seconds
X         pause -1  "Hit return to continue"
X         pause 10  "Isn't this pretty?  It's a cubic-spline."
X
X Syntax:
X         pause <expression> ["string"]
X1 plot
X2 data_file
X Discrete data contained in a file can displayed by specifying the
X name of the data file (enclosed in quotes) on the 'plot' command
X line.
X
X Data files should contain one data point per line.  A data point may
X be specified either as an X and Y value separated by blank space, or
X as just the Y value, in which case the program will use the number
X of the coordinate as the X value.  Coordinate numbers starts at 0
X and are incremented for each data point read.  Blank lines and lines
X beginning with # will be treated as comments and ignored.
X
X
X This example compares the data in the file population.dat to a
X theoretical curve:
X
X         pop(x) = 103*exp((1965-x)/10)
X         plot [1960:1990] 'population.dat', pop(x)
X
X The file population.dat might contain:
X
X  # Gnu population in Antarctica since 1965
X  1965   103
X  1970   55
X  1975   34
X  1980   24
X  1985   10
X2 ranges
X This option specifies the region of the plot which will be displayed.
X
X Ranges may be provided on the 'plot' command line as synonyms for
X the 'set xrange' and 'set yrange' commands.
X
X Syntax:
X         [{dummy-var =} {xmin : xmax}] { [{ymin : ymax}] }
X
X Where dummy-var is the independent variable (the default is 'x',
X but this may be changed with the 'set dummy' command) and the min
X and max terms can be expressions or constants.
X
X Both the min and max terms are optional.  The ':' is also optional
X if neither a min nor a max term is specified.  This allows '[]' to
X be used as a null range specification.
X
X Specifying a Y range turns autoscaling OFF.
X
X
X Examples:
X
X This uses current ranges:
X         plot cos(x)
X
X This sets the xrange only:
X         plot [-10:30] sin(pi*x)/(pi*x)
X
X This is the same, but uses t as the dummy-variable:
X         plot [t = -10 :30]  sin(pi*t)/(pi*t)
X
X This sets both the x and yranges:
X         plot [-pi:pi] [-3:3]  tan(x), 1/x
X
X This sets only the yrange:
X         plot [] [-2:sin(5)*-8] sin(x)**besj0(x)
X
X This sets xmax and ymin only:
X         plot [:200] [-pi:]  exp(sin(x))
X2 style
X Plots may be displayed in one of three styles: 'lines', 'points', or
X 'impulses'.  The 'lines' style connects adjacent points with lines.
X The 'points' style displays a small symbol at each point.  The
X 'impulses' style displays a vertical line from the X axis to each
X point.
X
X Default styles are chosen with the 'set function style' and
X 'set data style' commands.
X
X Syntax:
X         with <style>
X
X Where <style> is one of 'lines', 'points', or 'impulses'.  These
X keywords may be abbreviated.
X
X
X Examples:
X
X This plots sin(x) with impulses:
X         plot sin(x) with impulses
X
X This plots sin(x) with points, cos(x) default:
X         plot [-9:30]  sin(x) w points, cos(x)
X
X This plots tan(x) with the default function style, "data.1" with lines:
X         plot [] [-2:5] tan(x), "data.1" with l
X
X This plots "leastsq.dat" with impulses:
X         plot 'leastsq.dat' w i
X1 print
X This command prints the value of <expression> to the screen.
X
X Syntax:
X         print <expression>
X
X See 'expressions'.
X1 quit
X 'quit' is a synonym for 'exit'.  See 'exit'.
X1 replot
X 'replot' repeats the last 'plot' command.  This can be useful for
X viewing a plot with different 'set' options, or when generating the
X same plot for several devices.
X1 save
X This command saves either user-defined functions, variables, or both
X to the specified file.
X
X Syntax:
X         save  {option} <filename>
X
X Where <option> is either 'functions' or 'variables'.  If no option is
X used GNUPLOT saves both functions and variables.
X
X 'save'd files are written in text format and may be read by the 'load'
X command.
X
X The filename must be enclosed in quotes.
X
X Examples:
X
X         save "work.gnu"
X         save functions 'func.dat'
X         save var 'var.dat'
X1 set-show
X Set or show various internal gnuplot settings.
X2 all
X The command 'show all' will display all the set-show options
X currently in effect.
X
X Syntax:
X         show all
X2 autoscale
X If autoscaling is set, the Y axis is automatically scaled to fit the
X range of the function or data being plotted.  If autoscaling is not
X set, the current Y range is used.  See 'set yrange'.
X
X Syntax:
X         set autoscale
X         set noautoscale
X         show autoscale
X2 dummy
X By default, GNUPLOT assumes that the independent variable is 'x' on
X the 'plot' command line.  'x' is called the dummy variable because
X it is just a notation to indicate the independent variable.  The
X 'set dummy' command changes this default dummy variable name.  For
X example, you may find it more convenient to call the dummy variable
X 't' when plotting time functions:
X
X         set dummy t
X         plot sin(t), cos(t)
X
X Syntax:
X         set dummy <dummy-var>
X         show dummy
X2 functions
X The 'show functions' command lists all user-defined functions and
X their definitions.
X
X Syntax:
X         show functions
X2 logscale
X Log scaling may be set on the X and/or Y axis.
X
X Syntax:
X         set logscale <axes>
X         set nologscale
X         show logscale
X
X Where <axes> is either 'x', 'y', or 'xy'.
X2 polar
X The 'set polar' command changes the meaning of the plot from
X rectangular coordinates to polar coordinates.  In polar
X coordinates, the dummy variable (x) is an angle.  The domain
X of this angle is changed from whatever it was to [0:2*pi].
X
X The command 'set nopolar' changes the meaning of the plot back
X to the default rectangular coordinate system.  The domain of
X x is changed from whatever it was to [-10:10].
X
X While in polar coordinates the meaning of an expression in x
X is really r = f(x), where x is an angle of rotation.  The plot,
X however, is plotted on a rectangular grid.  Thus the displayed
X ranges of x and y are rectanglar values, while the command
X 'set xrange' refers to polar values.
X
X Syntax:
X         set polar
X 	 set nopolar
X 	 show polar
X2 offsets
X The amount of the graph that the plot takes up may be controlled
X to some extent with the 'set offsets' command.  This command takes
X four arguments--left offset, right offset, top offset and bottom
X offset.  By default, each offset is 0.  Left and right offsets are
X given in units of the x axis, while top and bottom offsets are
X given in units of the y axis.  The plot of sin(x), displayed with
X offsets of 0, 0, 2, 2 will take up  1/3 of the displayed y axis.
X Offsets are particularly useful with polar coordinates as a means
X of compensating for aspect ratio distortion.
X
X Syntax:
X         set offsets <expr>, <expr>, <expr>, <expr>
X         show offsets
X2 output
X By default, plots are displayed to the standard output.  The
X 'set output' command redirects the displays to the specified file or
X device.
X
X Syntax:
X         set output {filename}
X         show output
X
X The filename must be enclosed in quotes.  If the filename is
X omitted, output will be sent to the standard output.
X2 samples
X The sampling rate of functions may be changed by the 'set samples'
X command.  By default, sampling is set to 160 points.  A higher
X sampling rate will produce more accurate plots, but will take
X longer.  In generating plots, GNUPLOT will use either the sampling
X rate set or the resolution of the current output device, whichever
X is lower.
X
X Syntax:
X         set samples <expression>
X         show samples
X2 style
X Plots may be displayed in one of three styles: 'lines', 'points', or
X 'impulses'.  The 'lines' style connects adjacent points with lines.
X The 'points' style displays a small symbol at each point.  The
X 'impulses' style displays a vertical line from the X axis to each
X point.
X
X Default styles are chosen with the 'set function style' and 'set
X data style' commands.  See 'plot' for information about how to
X override the default plotting style for individual functions.
X
X Syntax:
X         set function style <style>
X         set data style <style>
X         show function style
X         show data style
X
X Where style is either 'lines', 'points', or 'impulses'.
X2 terminal
X GNUPLOT supports many different graphics devices.  Use the 'set
X terminal' command to select the type of device for which GNUPLOT
X will produce output.   While your installation may not include all
X of these, the following were available in the source code at the
X time this help file was written:
X
X Machines:  IBM-PC's (ega, cga, hercules), ATT6300, CORONA325,
X            UNIXPC (att7300 or 3b1);
X Terminals: AED512, AED767, HP2623A, HP7580B, REGIS, SELENAR,
X            TEK40xx, BBN Bitgraph;
X Printers:  LASERJET1, LASERJET2, LASERJET3, POSTSCRIPT, QMS,
X            VECTRIX384;
X Other:     UNIXPLOT.
X
X Syntax:
X         set terminal {terminal-type}
X         show terminal
X
X If <terminal-type> is omitted, GNUPLOT will list the available
X terminal types.  <terminal-type> may be abbreviated.
X
X Use 'set output' to redirect this output to a file or device.
X2 variables
X The 'show variables' command lists all user-defined variables and
X their values.
X
X Syntax:
X         show variables
X2 version
X Show the current version of gnuplot.  This is the same text
X that appears when gnuplot starts up.  (There is no SET VERSION
X command, of course.)
X
X Syntax:
X 	SHOW VERSION
X2 xrange
X The 'set xrange' command sets the horizontal range which will be
X displayed.
X
X This range may also be specified on the 'plot' command line.
X
X Syntax:
X         set xrange [{xmin : xmax}]
X
X Where <xmin> and <xmax> terms are expressions or constants.
X
X Both the <xmin> and <xmax> terms are optional.
X2 yrange
X The 'set yrange' command sets the vertical range which will be
X displayed.  This command turns autoscaling OFF.
X
X This range may also be specified on the 'plot' command line.
X
X Syntax:
X         set yrange [{ymin : ymax}]
X
X Where <ymin> and <ymax> terms are expressions or constants.
X
X Both the <ymin> and <ymax> terms are optional.
X2 zero
X GNUPLOT will not plot a point if its imaginary part is greater in
X magnitude than the 'zero' threshold.  The default 'zero' value is
X 1e-8.
X
X Syntax:
X         set zero <expression>
X         show zero
X1 shell
X The 'shell' command spawns an interactive shell.  To return to
X GNUPLOT, type 'logout' if using VMS, 'exit' or your END-OF-FILE
X character if using Unix, or 'exit' if using MS-DOS.
X
X A single shell command may be spawned by preceding it with the !
X character ($ if using VMS) at the beginning of a command line.
X Control will return immediately to GNUPLOT after this command is
X executed.  For example,
X
X      ! dir
X
X prints a directory listing and then returns to GNUPLOT.
X1 start_up
X When GNUPLOT is run, it looks for an initialization file to load.
X This file is called '.gnuplot' on Unix systems, and 'GNUPLOT.INI' on
X other systems.  If this file is not found in the current directory,
X the program will look for it in your home directory (under MS-DOS, the
X environment variable GNUPLOT should contain the name of this
X directory).
X
X If this file is found, GNUPLOT executes the commands in this file.
X This is most useful for setting your terminal type and defining any
X functions or variables which you use often.  The variable 'pi' is
X already defined for you.
X1 substitution
X Command-line substitution is specified by a system command enclosed in
X backquotes (`).  This command is spawned and the output it produces
X replaces the name of the command (and backquotes) on the command line.
X
X Newlines in the output produced by the spawned command are replaced with
X blanks.
X
X Command-line substitution can be used anywhere on the GNUPLOT command
X line.
X
X
X Example:
X
X This will run the program 'leastsq' and substitute `leastsq` on the
X command line with its output:
X
X  f(x) = `leastsq`
X
X or, in VMS
X
X  f(x) = `run leastsq`
X1 user_defined
X You may define your own functions and variables.  User-defined
X functions and variables may be used anywhere.
X
X User-defined function syntax:
X     <function-name> ( <dummy-var> ) =  <expression>
X
X Where <expression> is defined in terms of <dummy-var>.
X
X User-defined variable syntax:
X     <variable-name> = <constant-expression>
X
X Examples:
X     w = 2
X     q = floor(tan(pi/2 - 0.1))
X     f(x) = sin(w*x)
X     sinc(x) = sin(pi*x)/(pi*x)
X     delta(t) = (t == 0)
X     ramp(t) = (t > 0) ? t : 0
X
X The variable 'pi' is already defined for you.
X
X See 'show functions' and 'show variables'.
END_OF_FILE
if test 19621 -ne `wc -c <'./docs/gnuplot.hlp'`; then
    echo shar: \"'./docs/gnuplot.hlp'\" unpacked with wrong size!
fi
# end of './docs/gnuplot.hlp'
fi
echo shar: End of archive 6 \(of 7\).
cp /dev/null ark6isdone
MISSING=""
for I in 1 2 3 4 5 6 7 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 7 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
-- 
	John Campbell               ...!arizona!naucse!jdc
                                    CAMPBELL@NAUVAX.bitnet
	unix?  Sure send me a dozen, all different colors.