The SENAC Mini-Manual
University of Waikato
Mathematical Software Project
Version 6.0
February 1994
Copyright c 1994 University of Waikato - all rights reserved
The information in this document is subject to change
without notice and should not be considered as a commitment
by the University of Waikato. The University assumes no
responsibility for errors that may appear.
The software discussed in this document is furnished
under a licence or agreement and may be used or copied only
in accordance with the terms of such a licence or agreement.
No part of this publication may be reproduced or
transmitted in any form or by any means, electronic or
mechanical, including photocopying, recording or any
information storage or retrieval system, without permission
in writing from the University of Waikato.
SENAC, Sencore, Sengraph, Senpack, Numlink and Graflink are
trademarks of the University of Waikato
DEC, ULTRIX, VAX, VAX LISP and VMS are trademarks of Digital
Equipment Corporation
NAG is a registered trademark of The Numerical Algorithms
Group Ltd
Sun-2, Sun-3, Sun-4 and Sparcstation are trademarks of Sun
Microsystems Inc
UNIX is a trademark of AT & T
4.2BSD and 4.3BDS are trademarks of the Regents of the
University of California
Allegro CL is a registered trademark of Franz Incorporated
_____________________________________________
Addresses
For further information in the UK/Europe contact:
University of London Computer Centre (ULCC)
20 Guilford Street
London WC1N 1DZ
FAX (071)242-1845
Tel (071)405-8400
e-mail: senac@ulcc.ac.uk
All other regions:
Associate Professor Kevin A. Broughan
University of Waikato,
Hamilton, New Zealand
Telephone: country and area code 6471 then 562889 or 566358
Fax: 6471 384155
e-mail: senac@waikato.ac.nz
_____________________________________________
Introduction
The Senac manual materials consist of the following
modules:
Sencore Manual - symbolic numeric interpreter and fortran translation
Senpack Manual - basic numerical algorithms, optimization and FEM
Sengraph Manual - a graphics library with PostScript output
Senac Mini-Manual - for Sencore, Senpack and Sengraph
Numlink Manual - interface to the NAG Library
Graflink Manual - interface to the NAG graphical system
The reader should note that this Mini-Manual covers
only the three modules Sencore, Senpack and Sengraph. For
each function it lists the function name, the function
arguments and a brief description of the purpose for which
the function might be used. It is organised in such a way
that sets of functions with a related role are grouped
together and the relevant section of a Senac manual noted.
Modules not included in the Mini-Manual
Numlink: The Numlink Manual defines over 600 functions in
the areas complex arithmetic, zeros of polynomials, roots of
one or more non-linear equations, summation of series,
quadrature, ordinary differential equations, partial
differential equations, numerical differentiation,
interpolation, integral equations, curve and surface
fitting, optimization, matrix operations including inversion
and eigen problems, determinants, simultaneous linear
equations, orthogonalization, simple statistics, correlation
and regression analysis, analysis of variance, random number
generators, univariate estimation, nonparametric statistics,
contingency table analysis, time series analysis, operations
research, sorting, special function approximation and
machine constants.
Graflink: The Graflink Manual defines 50 functions in the
areas piecewize linear plots, smooth function plots through
data points, user supplied functions of one or two variables
plots, cubic spline and Chebyshev polynomial plots, contour
plots on regular and non-regular grids, isometric and
perspective surface views, bar and pi charts and histograms,
keys to markers and fill patterns.
Sencore Functions
Introduction (Sencore Manual Chapter 1)
"->": prompt
"?": terminator displaying output
";": terminator not displaying output
"#": terminator cancelling command
":": assignment operator
bye;: exit command
exit;: exit command
quit;: exit command
help(): overall on-line help
senhelp(): on-line help for Sencore
nlhelp(): on-line help for Numlink
glhelp(): on-line help for Graflink
".": package delimiter for Numlink and Graflink
"<": less than predicate
"=": equality predicate
"=<": less than or equal predicate
">": greater than predicate
"><": not equal predicate
">=": greater than or equal predicate
Data Types (Sencore Manual Chapter 2)
Expressions: x+f([a,b],3/4)
Floating Point Numbers: 4.5, 3.6d-23
Functions: sin(x), g(f(u,v(t),5))
Integers: 345434555555555555555555555532
Lists: [[x],[x,y],[]]
Rational Numbers:444444444444444/3333333333333333333
Strings: "this is a string: a/(0"
Variables: x, yyyyyyyyyyyyyyyyyyyyyy
Predicates (Sencore Manual Chapter 2)
Each takes a single argument and returns true or false:
empty_listp, evenp, floatp, functionp, integerp, listp,
matrixp, non_neg_integerp, non_negativep, non_positivep,
numberp, oddp, polyp, positive_integerp, positivep,
primep, ratnop, symbolp, variablep, zero_matrixp, zerop.
Function Definition (Sencore Manual Chapter 3)
":=": function definition operator f(x,y):= x+y/x;
defev(fun, x, expr): defines fun(x) as expr after evaluating each argument
defun(fun, x, expr): defines fun(x) as expr without evaluation
Binding: x:[u,v]? assigns to x the value of [u,v] and returns that value
unbind(var1, var2, ... ): removes any bindings
undef(f1, f2, ... ): removes function definitions
eval(x): evaluates x and then evaluates the result
Control (Sencore Manual Chapter 4)
for from by to do : loop with numerical index
for in do : looping through a list
if then else : if then else construction
print(arg1, arg2, ...): prints each argument on a line with special string
control
program(loc_vars, state1, .... ) : sequential evaluation with local
variables, go to and return
sprog(state1, .... ): simple sequential evaluation
Constants (Sencore Manual Chapter 5)
%e: the exponential number
%pi: pi
%pinf: positive real infinity
%ninf: negative real infinity
Global Variables (Sencore Manual Chapter 5)
true: behaves as boolean 1
false: behaves as boolean 0
gcprint: garbage collection printing
ldprint: information about file loading
line_length: the length of the output line
line_space: the spaces between output lines
margin_string: indentation option
print_style: expressions may be cut accross line boundaries or logically
split
time: a list of the cpu and garbage collection times for the previous command
times_format: option to print a times b as ab or a*b
Strings (Sencore Manual Chapter 6)
ascii_to_character(n): the character string equivalent of an ascii number
concat(var, n): and indexed variable is formed, x,3 -> x3
concat(var1, n, var2): an indexed variable x,3,y -> x3y
error(str): the messge str is printed and an error reset forced
nth_character(str, m): the m'th character in string str
null_stringp(x): returns true if x is ""
string_join(str1, str2, ...): the strings are concatenated
string_to_ascii(str): a list of the ascii equivalents of characters in str
string_to_variable(str): the string str is converted to a variable for Senac
stringp(x): returns true if x is a string
substring(str, index, len): the substring beginning at index and having
length len
File Handling Utilities (Sencore Manual Chapter 7)
bat(file1, file2, ...): each file of Senac commands will be loaded and
executed
bat_error_mode: if set to continue batching will continue after an error
silent_bat(file1, file2, ...): the files will be loaded but the commands
not printed
lld(file1, file2, ...): each file of lisp source statements will be loaded
lod(file1, file2, ...): each file of lisp object code will be loaded
record(file): a Senac session will be recorded in the string file
end_record(): the session will be terminated and file closed.
sav(file, f1, f2, ...): the lisp form of the funcions fi will be saved
Operating System Interaction (Sencore Manual Chapter 8)
change_directory(path): the host directory will be changed to the string path
collect_garbage(): a garbage collection will be forced
date_list(): a list representing the current date
date_string(): a string representing the current date
delete_file(file): the string file will be deleted if appropriate
elapsed_time(): the clock time which has passed since some reference date
opsys(command): the string command is passed to the operating system for
execution
process_id(): the process identification number
version(): the versions of lisp and Senac which are running
Elementary Functions (Sencore Manual Chapter 9)
acos, acosh, asin, asinh, atan, atanh, cos, cosh, exp, ln, sin, sinh, tan,
tanh
binomial(n, r): the binomial coefficient
expexpand(expr): the exponential of a sum goes to the product of the
exponentials
factorial(n): the factorial of n
float(x): the rational numbers or integers in x are converted to floating
point
float_format(n, s): format floating point numbers
cl_format(str): format floating point numbers using Common Lisp formatting
gcd(n, m): the greatest common divisior of two integers
gcdext(m, n): the extended greatest common divisor
lnexpand(expr): recursively expand logarithms of products
small_primes: a list of primes less than 1000
medium_primes: a list of primes less than a 32 bit wordsize
mersenne_exponents: a list of the exponents for mersenne primes
prime_prob(n): a probabilistic prime test
prime_prove(n): a deterministic prime test
factor_prob(n): a probabilistic factoring function
factor_prove(n): a deterministic factoring function
trigexpand(expr): recursively expand trig functions of sums
Lists (Sencore Manual Chapter 10)
apply(f, lis): apply the function f to the arguments lis
const(a, n): returns a constant list of length n and element a
delete(x, lis): x is removed from the top level of the list lis
first(lis): the first element of the list is returned
front(a, lis): a list of all elements up to and including a in lis
get(lis, i): the i'th element of the list lis
get(lis, i, j): the j'th elment of the i'th sublist of lis
get(A, i, j): the ij'th element of the matrix A
get(matlis, i, j, k): j'th element of the k'th row of the i'th matrix
indexed_listn(var, m, n): a list of indexed variables [varn,..., varm]
insert_after(lis, z): a list with z inserted at the end of lis
insert_before(x, lis): a list with x inserted at the start of x
join(lis1, lis2, ...): the lisi are appended
last(lis): the last element of lis
length(lis): the length of lis
list(arg1, arg2, ... ): a list of the argi
listn(m, n): a list of integers from m to n
map(fun, lis1, lis2, ... ): the function fun is applied successively to
the elements of the lisi, there being as many lisi as arguments for fun
nthrest(m, lis): the first m elements of lis are removed
proj(lis, n): the n'th element of lis
put(x, i, a): a list obtained from x with its i'th element replaced by a
put(x, i, j, a): a list of lists obtained from x with the j'th element of
the i'th sublist replaced by a
put(x, i, j, k, a):a list of matrices obtained from x with the j'th element
of the k'th row of the i'th matrix replaced by a
remove_tail(lis, n): the last n elements of the list lis are removed
rest(lis): a list of all but the first elements of lis
reverse(lis): a list consisting of the elements of lis in reverse order
Matrices (Sencore Manual Chapter 11)
matrix(l1, l2,...): a matrix with rows li
adjoint(A): the adjoint of the matrix A
block_matrix(A, irange, jrange) : the block submatrix delimited by irange
and jrange
column(j, A): the j'th column of the matrix A
dense_to_sparse(A): the list representation of a sparse matrix
det_full(A): determinant of a matrix using Cramers rule
det_rat(A): determinant of a matrix with rational number entries
det_sparse(A): determinant of a sparse matrix
ident(n): the identity matrix
insert_elt(a, i, j, A): a matrix obtained from A by inserting a in the
ij'th position
inverse_full(A): the inverse of the matrix A using Cramer's rule
inverse_sparse(A): the inverse of a sparse matrix
linear_solve(lis, vars): the solution to a system of linear equations
linear_solve(lis, vars, rhs): solutions to a systems of linear equations
mat_dims(A): a list of the row and column dimensions of a matrix
matrix_inverse(A): the inverse of a matrix A
matrix_solve(A, B): solution to the equations AX=B
remove_col(j, A): a matrix obtained from A by removing the j'th column
remove_row(i, A): a matrix obtained from A by removing the i'th row
row(i, A): the i'th row of the matrix A
sparse_to_dense(lis): a matrix representation of a list representing a
sparse matrix
sub_matrix(A, irange, jrange): a submatrix determined by the indicators in
the lists irange for rows and jrange for columns
swap_rows(A,i,j): a matrix obtained from A by swopping the i'th and j'th rows
transpose(A): the transpose of A
zero(m, n): the zero matrix of zize m by n
matrix_upper_tri(A): upper triangular submatrix of A
matrix_lower_tri(A): lower triangular submatrix of A
upper_tri_to_matrix(a): a matrix from the list of lists of decreasing
length a
lower_tri_to_matrix(a): a matrix from the list of lists of increasing
length a
matrix_to_bands(A, ku, kl): a matrix of the leading diagonals of A
bands_to_matrix(A, m, ku): a matrix with leading diagonals being the rows
of A
matrix_to_lists(A): a list of the row lists of A
lists_to_matrix(e): e is a list of lists of equal length
matrix_join_horizontal(left, right): left and right have the same number of
rows
matrix_join_vertical(top, bottom): top and bottom have the same number of
columns
leading_block(A, l, m): the leading submatrix of A with l rows and m columns
tailing_block(A, l, m): the bottom block of A with l rows and m colums
Spartrices (Sencore Manual Chapter 11)
spartrix([i,[j,aij ...]]): function to enter a sparse ma-
trix spartrixp(x): returns true if x is a spartrix
block_spartrix(S, irange, jrange): the subspartrix of S
delimited by irange and jrange
get_spartrix_maxcol_index(S): the largest column index of
a nonzero element get_spartrix_maxrow_index(S): the larg-
est column index of a nonzero element
matrix_to_spartrix(A): conversion of a matrix to a spar-
trix spartrix_ident(n): the identity spartrix
spartrix_to_matrix(S): conversion of a spartrix to a ma-
trix spartrix_window[il, ih, jl, jh]: the extent of the
printed spartrix sub_spartrix(S, irange1, jrange, ... ):
the subspartrix of S determined by the
row and column indices irange and jrange
Simplification (Sencore Manual Chapter 12)
combine_numers [true]: numerators over equal demoninators are combined
combine_powers [true]: products of equal powers are combined
distrib(x): products are distributed
expand(expr): products and powers are expanded at one level
multi_expand(x): powers are expanded using the multinomial expansion
quotients [true]: negative numeric powers are converted to denominators
ratify(exp): cannonical rational simplification of exp
set_rule_variable(var, fun): define the matching type of a pattern variable
get_rule_variables(): return the variables that have been set
delete_rule_variable(var): unset the variable as a matching variable
delete_rule_variables(): unset all of the varibles which have been set
set_rule(lhs, rhs): define a pattern matching rewrite rule
delete_rule(lhs): delete a pattern matching rewrite rule
delete_rules(): delete all of the rules which have been defined
get_rules(): return the current list of rules
apply_rules(expr): apply the current rules to an expression
real_part(expr): the real part of an expression
imaginary_part(expr): the imaginary part of an expression
conjugate(expr): the complex conjugate of an expression
modulus(expr): the complex mudulus of an expression
complex_inverse(expr): the inverse of a complex expression
Fortran Translation (Sencore Manual Chapter 13)
fortify(f): the Senac function f is translated into Fortran
fortify(f, str): the translated function is written into the file str
declare(x, type): the variable x in a program is declared to be of type type
fortify_float_all: all integers and rational numbers are converted
fortify_identifier_check: long identifiers are reported
fortify_label_prefix: initial label number
fortify_precision: format size for fortran programs
fortran77: if then else syntax indicator
establish_commons(v1, v2, ..., vn): establish common blocks
set_commons(a1, r1, ...) store the value ri in the block ai
get_commons(): return the values currently stored in the blocks v1, v2, ..
fortran_compile(f): compile the Senac function f into Fortran as bin_f
defun_callback(f, args, body): define a function in Senac which may be
called back to from Fortran code
Differentiation and integration (Sencore Manual Chapter 14)
diff(expr, var): the derivative of expr with respect to the variable var
diff(expr, v1, n1, v2, n2, ... ): the derivative of expr ni times with
respect to vi
deriv(f(x1, x2, ... , xn), xi, expr): the derivative of the undefined
function f with respect to xi is expr
taylor(expr, v, pt, n): the Tayor expansion of expr with respec to the list
of variables v about the point pt to order n
taylor_grid: the number of evaluations to be used for calculating
taylor_remainder
taylor_remainder(...): a list of the highest and lowest values for the
remainder of the Taylor expansion using the Cauchy or Lagrange form.
integrate(expr, var): integrate expr using pattern matching or the Risch
algorithm
Monomial Polynomials (Sencore Manual Chapter 15)
poly(arg): transform arg if possible into the monomial polynomial type
polyp(arg): return true if arg is a monomial type polynomial
poly_to_gen(poly):transform a polynomial to a general Senac expression
coefs(poly): return a list of the coeficients
varibles(poly): return a list of the variables
deg_vec(poly): a list of lists of the degrees of the monomials of poly
deg_main_var(poly): the highest degree of the leading varible in poly
polyeval(poly, [val1, val2, ... , valn]): a polynomnial with the last n
variables evaluated
polyx_powers(poly, x): a list of the powers of x in poly
polymaxdeg(poly, x): the maximum degree of x in poly
polysign(poly): 1 if the leading coefficient is positive, -1 otherwise
polydiv(poly1, poly2): a list of the quotient and remainder following
division
polyzdiv(poly1, poly2): all coefficients are from the ring of integers
polygcd(poly1, poly2, poly3, ...): the GCD using Zippel's probabilistic
algorithm
polygetheadvars(): a list of the most significant variables in the variable
ordering
polygettailvars(): a list of the least significant variables
polysetheadvars(varlist): varlist is a list to become the ordering of the
most significant variables
polysettailvars(varlist): varlist is a list to become the ordering of the
least significant variables
reorderpoly(poly): reorders the monomial polynomial according to the set
orders
square_freep(poly): returns true if poly is square free
Recursive Polynomials (Sencore Manual Chapter 15)
r_poly(expr): returns if possible a recursive polynomial
r_poly1(var, [[expt1, coef1],....]): a polynomial with main variable var
r_ordervlbes([v1, v2, ...]): impose v1 > v2 > ... as the variable ordering
r_reordervbles(poly, [v1, ...]): impose a local reordering of variables for
poly
r_coefs(poly): a list of the coefficients of poly in ascending order of
degree
r_variables(poly): a list of the variables of poly
r_degree(poly): the degree of poly with respect to the main varible
r_polyeval(poly, [vble1, val1, ...]): poly is evaluated with vblei set to
vali
r_poly_to_gen(poly): an equivalent general Senac expression
r_div_poly(poly1, poly2): a list of the quotient and remainder
Polynomial Factorisation (Sencore Manual Chapter 15)
below zpoly is a recursive polynomial with integer coefficients
eisenstein(zpoly): returns true is Eisenstein's test succeeds
square_free_factors(zpoly): a list of the square free factors of poly
berlekamp(zpoly, p): a list of the factors of univariate zpoly modulo p a
prime
berlekamp_eez(zpoly ): a list of the factors of square free univariate zpoly
wang_rothschild(zpoly): a list of the factors of square free univariate zpoly
factor_uni(zpoly): a list of the factors of square free univariate zpoly
factor_multi(zpoly): a list of lists being the content, factors and
multiplicities fo the multivariate polynomial zpoly
qpoly_to_zpoly(poly): a list of an equivalent zpoly and integer denominator
r_square_freep(zpoly): returns true if zpoly is univariate and square free
square_free_uni(zpoly): a list of the content, square free factors and
multiplicities of the univariate zpoly
square_free_multi(zpoly): a list of the content, square free factors and
multiplicities of zpoly
recursive_to_monomial(poly): poly has the recursive representation
monomial_to_recursive(poly): poly has the monomial representation
r_polygcd(poly1, poly2): the polynomial gcd of poly1 and poly2
r_polygcdext(poly1, poly2): the extended gcd
Grobner Bases Applications (Sencore Manual Chapter 15)
grobner_basis(polys): the Grobner basis generated by a list of polynomials
with rational coefficients
reduce(poly, polys): complete reduction of a polynomial with respect to a
list of polynomials
quotient_basis(basis): a list of generators for the quotient ring generatied
by a Grobner basis
grobner_inverse(poly, basis): the inverse of a polynomial in a quotient ring
alg_quotient(p, q, m): the quotient of two polynomials with coefficients in
a simple rational extension field
alg_gcd(p,q,m): the gcd of two polynomials with coefficients in a simple
rational extension field
alg_ext_gcd(p,q,m): the extended gcd of two polynomials with coefficients
in a simple rational extension field
poly_solve(poly1, poly2, ...): the complete solution to a system of
polynomial equations
Array Functions (Sencore Manual Chapter 16)
array(dim, type, contents): return an array of given dimensions and type
array_to_list(array): convert an array to a simple list
array_dimensions(array): the dimensions of an array
array_dimension(array,slot): a dimension of an array
arrayp(x): test a Senac type to see whether it is an array
real_arrayp(x): test a Senac type to see whether it is a real array
integer_arrayp(x): test a Senac type to see whether it is an integer array
real_single_arrayp(x): test a Senac type to see whether it is a real single
precision array
read_array(file, dim, type): return an array with contents read from a file
write_array(array, file, cols, format, range): write an array to a named file
displace_array(source, offset, dims): create a new array sharing storage
with another
get_array_type(array): return the type of an array
matrix_to_array(A): convert a matrix to a two dimensional array
array_to_matrix(array): convert a two dimensional array to a matrix
array_map(fun, array1, array2,...): return an array which is the result of
applying fun elementwise to each of the argument arrays
Miscellaneous Functions (Sencore Manual Chapter 16)
random_number(a, b): a random number of the same type and between a and b
random_list(a, b, n): a list of random numbers with values between a and b
random_matrix(a, b, m, n): a matrix of random numbers with values between a
and b
random_element(lis): a random element of a list
subst(a, b, c): substitute a for b in c
compile_functions(f1, f2,...): compile the user functions f'i using the
Lisp compiler
-10-
Senpack Functions
Introduction (Senpack Manual Chapter 1)
flmoon(phase, type): phases of the moon, calculate by date
julday(month, day, year): Julian day number, calculate by date
caldat(julian): calendar date, calculate from Julian day number
Solution of Linear Algebraic Equations (Senpack Manual Chapter 2)
gaussj(A, B): matrix inversion/linear equation solution using Gauss-Jordan
ludcmp(A): linear equation solution, LU decomposition
lubksb(A, index, b): linear equation solution, backsubstitution
tridag(a, b, c, r): linear equation solution, tridiagonal equations
mprove(A, B, index, b, x): linear equation solution, iterative improvement
vander(x, q): linear equation solution, Vandermonde matrices
toeplz(r, y): linear equation solution, Toeplitz matrices
svdcmp(A): singular value decomposition of a matrix
svbksb(U, W, V, b): singular value backsubstitution
sparse(b, asub, bsub, x): linear equation solution, sparse matrix
Interpolation and Extrapolation (Senpack Manual Chapter 3)
polint(lisx, lisy, x): interpolation, polynomial
ratint(lisx, lisy, x): interpolation, rational function
spline(lisx, lisy, dx1, dxn): interpolation, construct a cubic spline
splint(lisx, lisy, y2a, x): evaluate a cubic spline
locate(lisx, x): search an ordered table, bisection
hunt(lisx, x, guess): search an ordered table, correlated calls
polcoe(xlis, ylis): polynomial coefficients from a table of values
polcof(xlis, ylis): polynomial coefficients from a table of values
polin2(xlis, ylis, A, x, y): interpolation, two dimensional polynomial
bcucof(y, y1, y2, y12, d1, d2): interpolation, two dimensional construct bicubic
bcuint(y, y1, y2, y12, x1l, x2l, x1, x2): interpolation, two dimensional evalute bicubic
splie2(xlis, ylis, Y): interpolation, two dimensional, construct two dimensional spline
splin2(x1a, x2a, ya, y2a, x1, x2): interpolation, two dimensional, evaluate two dimensional spline
Integration of Functions (Senpack Manual Chapter 4)
trapzd(fun, int, it): integrate a function using the trapezoidal rule
qtrap(fun, int): use the trapezoidal rule to desired accuracy
qsimp(fun, int): use Simpson's rule to desired accuracy
qromb(fun, int): use Romberg adaptive quadrature to desired accuracy
midpnt(fun, int, order): the extended midpoint rule
qromo(fun, int): use open Romberg to desired accuracy
midinf(fun, int): function on a semi infinite interval
midsql(fun, int): function with a square root singularity
midsqu(fun, int): inverse square root singularity
midexp(fun, int): increased exponentially
qgaus(fun, int): Gaussian quadratures
gauleg(int, order): compute Gauss-Legrendre weights and abscissas
quadf(fun, int): integrate a function of n variables returning a function of all but the last variable
quad2d(fun, int, [fa, fb]): two dimensional integrals
-11-
quad3d(fun, int, [fa, fb], [ga, gb]): three dimensional integrals
quad4d(fun, int, [fa, fb], [ga, gb], [ha, hb]): four dimensional integrals
Evaluation of Functions (Senpack Manual Chapter 5)
eulsum(sum, term, order): sum a series Euler van Wijngaarden algorithm
ddpoly(coefs, x, order): fast evaluation of specified derivatives
poldiv(poly1, poly2): polynomials divide one by another
chebft(int, n, func): fit a Chebyshev polynomial to a function
chevev(int, c, x): Chebyshev polynomial evaluation
chint(int, c): integrate a function already Chebyshev fitted
chder(int, c): integrate a function already Chebyshev fitted
chebpc(c): polynomial coefficients from a Chebyshev fit
pcshft(int, coefs): polynomial coefficients of a shifted polynomial
Special Functions (Senpack Manual Chapter 6)
gammln(x): logarithm of the gamma function
factrl(n): factorial function
bico(n, k): binomial coefficient function
factln(n): logarithm of the factorial function
beta(z, w): beta function
gammp(a, x): incomplete gamma function
gammq(a, x): incomplete complementary gamma function
gser(a, x): series evaluation of the incomplete gamma function
gcf(a, x): continued fraction evaluation of the incomplete gamma function
erf(x): error function
erfc(x): complementary error function
erfcc(x): complementary error function, consise routine
betai(a, b, x): incomplete beta function
betacf(a, b, x): incomplete beta function, continued fraction evaluation
bessj0(n, x): bessel function J0
bessy0(x): bessel function Y0
bessj1(x): bessel function J1
bessy1(x): bessel function Y1
bessj(n, x): bessel function J of integer order
bessy(n, x): bessel function Y of integer order
bessi0(x): modified bessel function I0
bessk0(x): modified bessel function K0
bessi1(x): modified bessel function I1
bessk1(x): modified bessel function K1
bessi(n, x): modified bessel function I of integer order
bessk(n, x): modified bessel function K of integer order
plgndr(l, m, x): associated Legendre polynomial
el2(x, qqc, aa, bb): elliptic integrals of the first and second kind
cel(qqc, pp, aa,bb): complete elliptic integrals
sncndn(uu, emmc): Jacobian elliptic function
Random Numbers (Senpack Manual Chapter 7)
ran0(idum): random deviates, improve an existing generator
ran1(idum): random deviates, uniform
ran2(idum): random deviates, uniform
ran3(idum): random deviates, uniform subtractive method
-12-
expdev(idum): random deviates, exponential
gasdev(idum): random deviates, normally distributed Box-Muller method
gamdev(ia, idum): random deviates, gamma-law distribution
poidev(xm, idum): random deviates, Poisson distributed
bnldev(pp, n): random deviates, binomial distributed
irbit1(): generate a random bit sequence
irbit2(): generate a random bit sequence
ran4(idum): random deviates, uniform using Data Encryption
des(input, key, newkey, isw): encryption
ks(key, n): encryption key standard
cyfun(ir, k): cyfer function for the Data Encryption Standard
Sorting (Senpack Manual Chapter 8)
piksrt(lis): sort an list by straight insertion
piksr2(lisa, lisb): sort two lists by straight insertion
shell(lis): sort an list by Shell's method
sort1(lis): sort an list by the heapsort method
sort2(lisa, lisb): sort two lists the heapsort method
indexx(lis): sort and construct an index for an list
sort3(lisa, lisb, lisc): sort, use and index to sort 3 or more lists
rank(index): sort, construct a rank table for an list
qcksrt(lis): sort an list by the quicksort method
eclass(n, lisa, lisb): determine equivalence classes
eclazz(n, eqivfun): determine equivalence classes
Root Finding (Senpack Manual Chapter 9)
scrsho(fun): graph a function roughly
zbrac(fun, int): search for brackets on a root of a function
zbrak(fun, int, n, brackets): search for brackets on a root of a function
rtbis(fun, int, tol): find a root by bisection
rtflsp(fun, int, tol): find a root by false position
rtsec(fun, int, tol): find a root by the secant method
zbrent(fun, int, tol): find a root by Brent's method
rtnewt(fun, fund, int, tol): find a root by Newton-Raphson
rtsafe(fun, fund, int, tol): find a root by Newton-Raphson and bisection
laguer(real, imag, [xr, xi]): root of a polynomial by Laguerre's method
zroots(real, imag): roots of a polynomial by Laguerre's method with deflation
qroot(coefs, b, c, eps): root of a real or complex polynomial by Bairstow's method
mnewt(x, fun, jacobian): nonlinear system of equations by Newton-Raphson
Minimization and Maximization (Senpack Manual Chapter 10)
mnbrak(ax, bx, fun): bracket a minimum of a function
golden(ax, bx, cx, fun): find a minimum of a function by golden section
brent(ax, bx, cx, fun): find a minumum of a function by Brent's method
dbrent(ax, bx, cx, fun, fund): find a minumum using derivative information
amoeba(simplex, lis, fun): minimum of a function, multidimensional downhill simplex
powell(lis, X, fun): minimum of a function, multidimensional Powel's method
frprmn(p, func, dfunc): minimum of a function, multidimensional, conjugage gradient
dfpmin(p, func, dfunc): minimum of a function, multidimensions, variable metric
simplex(obj, ub, lb, eq): linear programming simplex method
anneal(x, y, iorder): travelling salesman by simulated annealing
-13-
Eigenproblems (Senpack Manual Chapter 11)
jacobi(A): eigenvalues and vectors of a symmetric matrix
eigsrt(d, V): sorts eigenvectors into order by eigenvalue
tred2(A): Householder reduction of a real symmetric matrix
tqli(d, e, z): eigenvalues and vectors of a symmetric tridiagonal matrix
balanc(A): balance a non-symmetric matrix
elmhes(A): reduce a general matrix to Hessenberg form
hqr(A): eigenvalues of a Hessenberg matrix
Fast Fourier Transform (Senpack Manual Chapter 12)
four1(data): fourier transform (FFT) in one dimension
twofft(data1, data2): fourier transform of two real functions
realft(data): fourier transform of a real functions
sinft(y): sine transform using the FFT
cosft(y): cosine transform using the FFT
convlv(data, respns): convolution or deconvolution of data using the FFT
correl(data1, data2): correlation or autocorrelation of data using the FFT
spctrm(data, m, k): power spectrum estimation using the FFT
memcof(data, m): power spectrum estimation, evaluate maximum entropy coefs
evlmem(fdt, pm, cof): power spectrum estimation using the maximum entropy coefs
fixrts(d): roots of a polynomial, reflects inside the unit circle
predic(data, d, nfut): linear prediction using the MEM coefficients
fourn(data, nn): multidimensional FFT
Statistical Description of Data (Senpack Manual Chapter 13)
moment(data): calculate the moments of a data set
mdian1(data): calcuate the median of a data set by sorting
mdian2(data): calcuate the median of a data set iteratively
ttest(data1, data2): Student's t-test for the difference of means
avevar(data): calcuate the mean and variance of a data set
tutest(data1, data2): Student's t-test with unequal variances
fptest(data1, data2): Student's t-test with paired data
ftest(data1, data2): F-test for difference of variances
chsone(bins, ebins, knstrn): chi-square test for difference between data and model
chstwo(bins1, bins2, knstrn): chi-square test for difference between two data sets
ksone(data, func): Kolmorgorov-Smirnov test of data against model
kstwo(data1, data2): Kolmorgorov-Smirnov test of two data sets
probks(alam): Kolmorgorov-Smirnov probability function
cntab1(nn): contingency table analysis using chi-square
cntab2(nn): contingency table analysis using entropy measure
pearsn(x, y): Pearson's correlation between two data sets
spear(data1, data2): Spearman's rank correlation between two data sets
crank(w): replace array elements by their ranks
kendl1(data1, data2): Kendal's tau correlation between two data sets
kendl2(table): contingency table analysis using Kendall's tau
smooft(y pts): smooth data using FFT
Modelling of Data (Senpack Manual Chapter 14)
fit(x, y, sig, mwt): fit data to a straight line using least squares
lfit(x, y, sig, mfit, lista, funcs): linear least squares fit, general using normal equations
-14-
covsrt(covar, ma, lista): covariance matrix, sort, used by lfit
svdfit(x, y, sig, a, funcs): linear least squares fit, general, singular value decomposition
svdvar(v, ma, w): variances from singular value decomposition
fpoly(): fit a polynomial, using lfit or svdfit
fleg(): fit a Legendre polynomial, using lfit or svdfit
mrqmin(x, y, sig, a, lista, mfit, funcs, funcsd, alamda): nonlinear least squares fit Marquardt's method
mrqcof(): nonlinear least squares fit, used by mrqmin
fgauss(): fit a sum of Gaussians, using mrqmin
medfit(x, y): fit data to a straight line robustly, least absolute deviation
Integration of Ordinary Differential Equations (Senpack Manual Chapter 15)
rk4(y, dydx, x, h, derivs): integrate one step of ode's by 4th order Runge-Kutta
rkdumb(vstart, x1, x2, nstep, derivs): integrate ode's by 4th order Runge-Kutta
rkqc(y, dydx, x, htry, eps, yscal, derivs): integrate one step with accuracy monitoring
odeint(ystart, x1, x2, eps, h1, hmin, derivs): integrate ode's with accuracy monitoring
mmid(y, dydx, xs, htot, nstep, derivs): integrate ode's with the modified midpoint method
bsstep(y, dydx, x, htry, eps, yscal, derivs): integrate one step - Bulirsch-Stoer method
Two Point Boundary Value Problems (Senpack Manual Chapter 16)
shoot(v, delv, x1, x2, eps, h1, hmin, derivs, load, score): solve the 2 point boundary value problem by shooting
shootf(v1, v2, delv1, delv2, x1, x2, xf, eps, h1, hmin,
derivs, load1, load2, score): solve the 2 point boundary value problem by shooting to a fitting point
solvde(scalv, indexv, nb, y, difeq): solve the 2 point boundary value problem by relaxation
Partial Differential Equations (Senpack Manual Chapter 17)
sor(a, b, c, d, e, f, u, rjac): elliptic pde solved by the simultaneous overrelaxation method
adi(a, b, c, d, e, f, g, u, k, alpha, beta): elliptic pde solved by the alternating direction implicit method
Finite Element Method (Senpack Manual Chapter 18)
fe_begin(dim, type, name): start a new solution session
fe_enter_eqn(regions, alpha, beta, gamma, mu, load): enter the partial differential equation for a region
fe_print_eqn(): display the equation for every region
fe_enter_node(nn): enter a node
fe_get_node(nn): return a node
fe_enter_nodes(n, a, b): enter a set of nodes
fe_print_nodes(m, n): display a set of nodes
fe_enter_element(type, vertices, other_nodes, region): enter an element
fe_get_element(n): return an element
fe_print_elements(m, n): display a set of elements
enter_mesh(): convert elements entered manually to the current mesh
fe_enter_esbc(node, value): enter essential boundary conditions
fe_enter_esbcs([first, last], value): enter a set of essential boundary conditions
fe_enter_nbcc(node, value): enter concentrated natural boundary conditions
fe_enter_nbccs([first, last], value): enter a set of concentrated natural boundary conditions
fe_enter_nbcd(nodes, value): enter distributed natural boundary conditions
make_grid(type, parameters): make a grid from a library object
-15-
gridp(x): test a grid type
map_grid(f, grid): transform a grid to another grid
grid_union(grid1, grid2, ..): form a grid which is the union of grids
grid_difference(grid1, grid2): remove elements from a grid
print_grid_nodes(): print the nodes of a grid to the screen
print_grid_elements(grid): print the elements of a grid to the screen
plot_grid(file, grid): write the PostScript instructions to plot a grid
grid_to_mesh(grid): convert a grid to the current mesh
fe_load_bdry_nodes(file): parse a file containing polygonal
boundary nodes and conditions
fe_enter_bdry_nodes([n,x,y,i,v],..): input polygonal boundary nodes and conditions
fe_enter_quad_poly_bdry(bottom, right, top, left): enter a polygonal boundary and conditions
for a quadrilateral mesh
fe_enter_quad_param_bdry(bottom, right, top, left): enter a parametric boundary
for a quadrilateral mesh
fe_enter_param_region(n, components, hole1, hole2, ..): enter a boundary and conditions
defined by parametric functions
fe_enter_poly_region(n, boundary, hole1, hole2, ..): enter a polygonal region
fe_plot_bdry(file): write instructions to plot the domain boundary
make_quad_mesh(type): construct a quadrilateral mesh
make_triangular_mesh(type, elements, fixed): mesh a polygonal region
refine_mesh(): quadruple the number of elements
relax_mesh(): apply Laplacian smoothing
map_mesh(fun): transform an existing mesh
reduce_mesh_bandwidth(): relabel nodes to reduce the bandwidth
plot_mesh(file): write instructions to plot the mesh
get_mesh_bdry_nodes(): return the boundary node numbers
mesh_status(): determine mesh quality and statistics
fe_initial_shape(fun): enter initial conditions
fe_enter_time_steps([nsteps, delta, theta],...): enter the time step data
fe_run(): start the solution phase
fe_evaluate_solution(x|[x,y]): evaluate the solution at a point
fe_print_solution(): tabulate the solution
fe_plot_solution(file): write instructions to plot a one or two space solution
fe_get_solution_value(nn): get a solution value from the node number
fe_end(): clean up the internal data structures
Optimization (Senpack Manual Chapter 19)
lp_begin(): begin a new LP session
lp_enter_constraint(form, op, rhs): enter a single LP constraint
lp_enter_constraint2(lower, op, form, op, upper): enter a double LP constraint
lp_enter_bounds(lower, vars, upper): enter a simple LP bound or bounds
lp_enter_objective(form, type): enter the linear form to be optimized
lp_run(): start the LP solver
cutting_stock(stock, widths, lengths): solve the trim loss problem
cutting_stock2(stocks, widths, lengths): solve the trim loss problem with multiple stocks
ip_begin(): begin a new IP session
ip_enter_constraint(form, op, rhs): enter a single IP constraint
-16-
ip_enter_bounds(lower, vars, upper): enter a simple IP bound or bounds
ip_enter_objective(form, type): enter the form to be optimized
ip_run(): start the IP solver
zo_begin(): begin a new zero-one integer programming session
zo_enter_constraint(form, op, rhs): enter a single constraint
zo_enter_objective(form, type): enter the objective
zo_run(): start the solver
sa_begin(): start a simulated annealing session
sa_enter_constraint(form, op, rhs): enter a constraint
sa_enter_bounds(lower, vars, upper): enter a bound or bounds
sa_enter_objective(form, type): enter the objective
sa_run(): start the solver
knapsack(capacity, weights, values): single constraint knapsack problem function
warehouse(costs, volumes, bounds): simulated annealing assignment problem solution
global_optimum(fun, int): optimize a function of one variable
global_optimum2(fun, rect, constraints): optimize a function of n-variables
go_begin(): start the global optimizer
go_enter_constraint(form, op, rhs): enter a constraint
go_enter_range(var, dis, int1, int2, ...): enter the permissible values for a variable
go_enter_objective(form, type): enter an algebraic objective
go_run(): start the optimizer
portfolio(corr, means, a, b): select an optimal portfolio
-17-
Sengraph Functions
PostScript Interface (Sengraph Manual Chapter 2)
begin_plot(file): begin a new PostScript session
end_plot(): close the connection to the output file
newpath(): initialize the current path
stroke(): paint a line following the current path
closepath(): close the current path
showpage(): transmit the current page to the current output device
fill(): paint the area enclosed by the current path with the current colour
lineto(px, py): append a straight line segment to the current path
moveto(px, py): start a new subpath of the current path
rlineto(px, py): append a straight line segment to the current path
rmoveto(px, py): start a new subpath of the current path
arc(px, py, r, ang1, ang2): append a counterclockwise arc of a circle to the current path
arcn(px, py, r, ang1, ang2): append a clockwise arc of a circle to the current path
arcto(x1, y1, x2, y2, r): append an arc of a circle to the current path
print_plot_state(): print the current plot state
set_linewidth(width): set the width of the current line
set_dash(style, offset): set the dashed line style
set_gray(level): set the grayness level for plotting
set_linecap(shape): establish the current shape for the ends of lines
set_linejoin(shape): set the mode for line joining
set_miterlimit(angle): angle below which joins are bevelled
set_rgbcolor(red, green, blue): set the current color in RGB style
set_hsbcolor(hue, saturation, brightness): set the current color in the HSB style
set_square_point(side): set the side length of a square
plot_square_point(xp, yp): place a square at a point specified in PostScript coordinates
set_x_point(s): set the dimension of an ``x" marker
plot_x_point(xp, yp): place an x at a point specified in PostScript coordinates
set_round_point(r): set the size of a circle
plot_round_point(xp, yp): place a round at a point specified in PostScript coordinates
set_cross_point(s): set the side length of a cross
plot_cross_point(xp, yp): place a cross at a point specified in PostScript coordinates
Plotting in 2-space (Sengraph Manual Chapter 3)
set_viewport_position(xmin, ymin, xmax, ymax): establish a rectangular area of the PostScript page
set_viewport(indicator, value): set the viewport characteristics
reset_viewport(): restore default viewport characteristics
format_viewport(): instantiate the viewport style
print_viewport(): print the current viewport characteristics
set_window_position(xmin, ymin, xmax, ymax): establish user coordinates for the viewport
set_window(indicator, value): set the window characteristics
reset_window(): restore the default window characteristics
format_window(): instantiate the window style
print_window(): print the current window characteristics
font(type, size, oblique): set font characteristics
plot_string(string, font, x, y): print a string at a given point
-18-
user_to_out(x, y): convert user coordinates to PostScript coordinates
plot_point(x, y): draw a marker at a given point
plot_points(xa, ya): draw a marker at each point in a set of points
plot_line(x1, y1, x2, y2): draw a line between two points in user coordinates
plot_segment(segment): draw a line between the tail and head of a segment
plot_segments(seg_lis): draw lines between the head and tail of each segment
plot_interval([ot1, pt2]): draw a line between the points in a list of two points
plot_curve(f, g, a, b, n): plot a parametrized 2-space curve
plot_smooth_curve(f, g, a, b, ds): an algorithm for uniform curve approximation
moving_average(back, forward, style, width): set moving average characteristics
plot_data(ylis, a, b, moving_av): plot a simple graph given arrays of coordinates in 2_space
plot_polyline(xa, ya): draw a piecewize linear curve through a set of points
plot_polygon(xa, ya): draw a piecewize linear closed curve through a set of points
plot_least_squares_line(xa, ya): draw a least squares linear approximation to a set of points
plot_bezier_curve(xa, ya): draw a Bezier curve through a set of points
plot_b_spline(xa, ya): draw a b-spline curve through a set of points
plot_polar_curve(f): plot a curve given in polar coordinates
plot_level_curve(fun, dx, dy, h): plot a level curve for a 2 variable differentiable function
plot_vector_field(xdot, ydot, delta): plot a family of vectors in 2-space
plot_phase_portrait(xdot, ydot, delta, ds, n): streamlines of an autonomous system
Computational Geometry in 2-space (Sengraph Manual Chapter 4)
point(x, y): return a point given the x and y coordinates
pointp(expr): test a potential 2-space point
point_x(point): find the x-coordinate of a 2-space point
point_y(point): find the y-coordinate of a 2-space point
point_equal(pta, ptb): test to see if two points are equal
points_above_line(line, points): return a list of points above a line
points_below_line(line, points): return a list of points below a line
point_on_leftp(point, segment): test to see if a point is on the left of a segment
point_on_rightp(point, segment): test to see if a point is on the right of a segment
points_on_line(point, segment): return a list of the points on a line
point_on_linep(line, set): test to see if a point is on a line
increasing_x(pta, ptb): test for increasing x coordinates
decreasing_x(pta, ptb): test fpr decreasing x coordinates
increasing_y(pta, ptb): test for increasing y coordinates
decreasing_y(pta, ptb): test for decreasing y coordinates
points_to_line(pta, ptb): map two points to a line
segment_to_slope_intercept(segment): the slope and intercept of a line
east_points(set): points with the smallest x coordinate
west_points(set): points with the largest x coordinate
north_points(set): points with the largest y coordinate
south_points(set): points with the smallest y coordinate
list_to_chain(list): a list is mapped to a list of successive pairs
form_convex_hull(list): a list of points is mapped to their convex hull
plot_convex_hull(list): plot the convex hull of a list of points
plot_interval_chain(chain): plot an interval chain
remove_loops(list): loops are removed from a list of segments
segment(tail, head): construct a segment in 2-space
segmentp(x): test a potential 2-space segment
-19-
segment_head(segment): find the head of a segment
segment_tail(segment): find the tail of a segment
segment_loop_p(segment): test to see whether a segment has equal head and tail
segment_equal(sega, segb): test two segments for equality
interval_equal(sega, segb): test two segments to see if they are equal as intervals
reverse_segment(segment): interchange the head and tail of a segment
segment_length_squared(segment): the length of a segment squared
slope(segment): return the slope of a segment or nil if the segment is vertical
parallel_segmentp(sega, segb): test to see if two segments are parallel
project_x(segment): projection of a segment onto an x-axis interval
project_y(segment): projection of a segment onto a y-axis interval
interval_interior_disjointp(inta, intb): interior disjoint test
interval_interior_intersectp(inta, intb): interior intersection test
point_in_segmentp(point, segment): a point on the line determined by a segment is tested
segment_interior_disjointp(sega, segb): a pair of segments is tested for interior disjointness
segment_disjointp(sega, segb): disjoint segment test
pair_to_segment([pta, ptb]): a two element list is transformed to a segment
segment_equal_length(sega, segb): two segments are tested for length equality
segment_chain_to_points(list): the end points in a list of segments
segment_to_points(segment): a segment is mapped to a list of head and tail
member_same_bdry(pta, ptb, pt_list): test two points for boundary segment membership
point_on_polygonp(pt, poly): test a point for membership of a polygon boundary
segment_on_polygonp(seg, poly): test a segment for polygon boundary membership
point_in_polygonp(pt, poly): test a point for polygon membership
point_outside_polygonp(pt, poly): test a point for non polygon membership
segment_in_polygonp(seg, poly): test a segment for polygon membership
segment_midpoint(segment): the midpoint of a segment
Triangulation in 2-space (Sengraph Manual Chapter 5)
triangle(pta, ptb, ptc): make a 2-space triangle
trianglep(x): test a potential 2-space triangle
triangle_a(triangle): extract a vertex of a 2-space triangle
triangle_b(triangle): extract a vertex of a 2-space triangle
triangle_c(triangle): extract a vertex of a 2-space triangle
point_in_trianglep(pt, tri): test to see if a point is in the interior of a triangle
segment_to_triangle(sega, segb, segc): test three segments for triangularity
segments_to_triangles(list): find triangles in a list of segments
triangle_inclusion(tria, trib): triangle subset test
remove_super_triangles(list): remove any trianges which contain other triangles
segment_triangulation_disjointp(seg, triangles): disjoint segment from triangulation test
triangulate_point_set(list): triangulate the convex hull of a point set
triangulate_convex_region(pts, bdry, hole1,...): triangulate a convex region with points and convex holes
triangulate_region(pts, bdry, hole1, hole2,...): triangulate a general region with holes
Contour Plotting (Sengraph Manual Chapter 6)
rectangle(xl, yl, xh, yh): make a 2-space rectangle
rectanglep(x): test a potential 2-space rectangle
rectangle_xl(rectangle): find the smallest x-coordinate of a rectangle
rectangle_xh(rectangle): find the largest x-coordinate of a rectangle
rectangle_yl(rectangle): find the smallest y-coordinate of a rectangle
rectangle_yh(rectangle): find the largest y-coordinate of a rectangle
-20-
between(a, b, h): test to see if a number is between two given numbers
inverse_interp(a, b, va, vb, h): perform inverse linear interpolation
find_seg_in_rect(f, rect, h): given a function and a rectangle find an interpolating line
form_contour(f, dx, dy, h): form a single contour across a rectangular subdivision
plot_contour_seg(intersections): plot a line across a rectangle
plot_contour(f, dx, dy, h): plot a single contour over a rectangle
plot_contours(f, dx, dy, hlis): plot contours given as a list of heights
find_seg_in_triangle(f, tri, h): interpolate a function on a triangle
form_contour_in_triangulation(f, tri, h): find a contour given a triangulation
form_contours_in_triangulation(f, tri, hlis): find contours given a triangulation
Perspective and Parallel Views in 3-space (Sengraph Manual Chapter 7)
point3(x, y, z): create a point in 3-space
point3p(expr): test a potential point in 3-space
point3_x(point): extract the x-coordinate of a point in 3-space
point3_y(point): extract the y-coordinate of a point in 3-space
point3_z(point): extract the z-coordinate of a point in 3-space
segment3(tail, head): create a segment in 3-space
segment3p(x): test a potential 3-space segment
segment3_head(segment): extract the head of a 3-space segment
segment3_tail(segment): extract the tail of a 3-space segment
set_view(type, value): set a characteristic of a perspective or parallel view
reset_view(): restore all of the view parameters to their default values
set_view_transform(): make a viewing transformation
print_view(): print the parameter values of a view structure
plot_line3(pointa, pointb): plot a line in 3-space on a 2-space viewing plane
Surface Plots in 3-space (Sengraph Manual Chapter 8)
plot_function_surface(f, x1, y1, x2, y2, m, n): graph of a function of two variables on a rectangle
plot_regular_surface(f, x1, y1, x2, y2, m, n): graph of a function of two variables on a rectangle
plot_data_surface(data, x1, y1, x2, y2): graph of a set of values over a regular data set
plot_scattered_surface(points, values): an arbitary set of points and function values
plot_parametric_surface(f, g, h, u1, v1, u2, v2, m, n): a wire frame surface in 3-space
plot_polys_with_hsr(poly_list): plot a set of plane polygons in 3-space
SENAC Home page