wxmaxima 13.04.2-2 / usr / share / wxMaxima / autocomplete.txt

FUNCTION: fast_linsolve
TEMPLATE: fast_linsolve([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])
FUNCTION: grobner_basis
TEMPLATE: grobner_basis([<expr_1>, ..., <expr_m>])
FUNCTION: set_up_dot_simplifications
TEMPLATE: set_up_dot_simplifications(<eqns>, <check_through_degree>)
TEMPLATE: set_up_dot_simplifications(<eqns>)
FUNCTION: declare_weights
TEMPLATE: declare_weights(<x_1>, <w_1>, ..., <x_n>, <w_n>)
FUNCTION: nc_degree
TEMPLATE: nc_degree(<p>)
FUNCTION: dotsimp
TEMPLATE: dotsimp(<f>)
FUNCTION: fast_central_elements
TEMPLATE: fast_central_elements([<x_1>, ..., <x_n>], <n>)
FUNCTION: check_overlaps
TEMPLATE: check_overlaps(<n>, <add_to_simps>)
FUNCTION: mono
TEMPLATE: mono([<x_1>, ..., <x_n>], <n>)
FUNCTION: monomial_dimensions
TEMPLATE: monomial_dimensions(<n>)
FUNCTION: extract_linear_equations
TEMPLATE: extract_linear_equations([<p_1>, ..., <p_n>], [<m_1>, ..., <m_n>])
FUNCTION: list_nc_monomials
TEMPLATE: list_nc_monomials([<p_1>, ..., <p_n>])
TEMPLATE: list_nc_monomials(<p>)
OPTION  : all_dotsimp_denoms
FUNCTION: array
TEMPLATE: array(<name>, <dim_1>, ..., <dim_n>)
TEMPLATE: array(<name>, <type>, <dim_1>, ..., <dim_n>)
TEMPLATE: array([<name_1>, ..., <name_m>], <dim_1>, ..., <dim_n>)
FUNCTION: arrayapply
TEMPLATE: arrayapply(<A>, [<i_1>, ..., <i_n>])
FUNCTION: arrayinfo
TEMPLATE: arrayinfo(<A>)
FUNCTION: arraymake
TEMPLATE: arraymake(<A>, [<i_1>, ..., <i_n>])
OPTION  : arrays
FUNCTION: bashindices
TEMPLATE: bashindices(<expr>)
FUNCTION: fillarray
TEMPLATE: fillarray(<A>, <B>)
FUNCTION: listarray
TEMPLATE: listarray(<A>)
FUNCTION: make_array
TEMPLATE: make_array(<type>, <dim_1>, ..., <dim_n>)
FUNCTION: rearray
TEMPLATE: rearray(<A>, <dim_1>, ..., <dim_n>)
FUNCTION: remarray
TEMPLATE: remarray(<A_1>, ..., <A_n>)
TEMPLATE: remarray(all)
FUNCTION: subvar
TEMPLATE: subvar(<x>, <i>)
OPTION  : use_fast_arrays
FUNCTION: init_atensor
TEMPLATE: init_atensor(<alg_type>, <opt_dims>)
TEMPLATE: init_atensor(<alg_type>)
FUNCTION: atensimp
TEMPLATE: atensimp(<expr>)
OPTION  : adim
OPTION  : aform
OPTION  : asymbol
FUNCTION: sf
TEMPLATE: sf(<u>, <v>)
FUNCTION: af
TEMPLATE: af(<u>, <v>)
FUNCTION: av
TEMPLATE: av(<u>, <v>)
FUNCTION: abasep
TEMPLATE: abasep(<v>)
FUNCTION: augmented_lagrangian_method
TEMPLATE: augmented_lagrangian_method(<FOM>, <xx>, <C>, <yy>)
TEMPLATE: augmented_lagrangian_method(<FOM>, <xx>, <C>, <yy>, optional_args)
TEMPLATE: augmented_lagrangian_method([<FOM>, <grad>], <xx>, <C>, <yy>)
TEMPLATE: augmented_lagrangian_method([<FOM>, <grad>], <xx>, <C>, <yy>, optional_args)
FUNCTION: bode_gain
TEMPLATE: bode_gain(<H>, <range>, ...<plot_opts>...)
FUNCTION: bode_phase
TEMPLATE: bode_phase(<H>, <range>, ...<plot_opts>...)
FUNCTION: run_testsuite
TEMPLATE: run_testsuite([<options>])
OPTION  : testsuite_files
FUNCTION: bug_report
TEMPLATE: bug_report()
FUNCTION: build_info
TEMPLATE: build_info()
FUNCTION: alias
TEMPLATE: alias(<new_name_1>, <old_name_1>, ..., <new_name_n>, <old_name_n>)
OPTION  : debugmode
FUNCTION: ev
TEMPLATE: ev(<expr>, <arg_1>, ..., <arg_n>)
OPTION  : eval
OPTION  : evflag
OPTION  : evfun
OPTION  : infeval
FUNCTION: kill
TEMPLATE: kill(<a_1>, ..., <a_n>)
TEMPLATE: kill(labels)
TEMPLATE: kill(inlabels, outlabels, linelabels)
TEMPLATE: kill(<n>)
TEMPLATE: kill([<m>, <n>])
TEMPLATE: kill(values, functions, arrays, ...)
TEMPLATE: kill(all)
TEMPLATE: kill(allbut (<a_1>, ..., <a_n>))
FUNCTION: labels
TEMPLATE: labels(<symbol>)
OPTION  : linenum
OPTION  : myoptions
OPTION  : nolabels
OPTION  : optionset
FUNCTION: playback
TEMPLATE: playback()
TEMPLATE: playback(<n>)
TEMPLATE: playback([<m>, <n>])
TEMPLATE: playback([<m>])
TEMPLATE: playback(input)
TEMPLATE: playback(slow)
TEMPLATE: playback(time)
TEMPLATE: playback(grind)
FUNCTION: printprops
TEMPLATE: printprops(<a>, <i>)
TEMPLATE: printprops([<a_1>, ..., <a_n>], <i>)
TEMPLATE: printprops(all, <i>)
OPTION  : prompt
FUNCTION: quit
TEMPLATE: quit()
FUNCTION: remfunction
TEMPLATE: remfunction(<f_1>, ..., <f_n>)
TEMPLATE: remfunction(all)
FUNCTION: reset
TEMPLATE: reset()
OPTION  : showtime
FUNCTION: to_lisp
TEMPLATE: to_lisp()
OPTION  : values
OPTION  : %e
OPTION  : %i
OPTION  : false
OPTION  : ind
OPTION  : inf
OPTION  : infinity
OPTION  : minf
OPTION  : %phi
OPTION  : %pi
OPTION  : true
OPTION  : und
OPTION  : zeroa
OPTION  : zerob
FUNCTION: activate
TEMPLATE: activate(<context_1>, ..., <context_n>)
OPTION  : activecontexts
FUNCTION: assume
TEMPLATE: assume(<pred_1>, ..., <pred_n>)
OPTION  : assumescalar
OPTION  : assume_pos
OPTION  : assume_pos_pred
OPTION  : context
OPTION  : contexts
FUNCTION: deactivate
TEMPLATE: deactivate(<context_1>, ..., <context_n>)
FUNCTION: facts
TEMPLATE: facts(<item>)
TEMPLATE: facts()
OPTION  : features
FUNCTION: forget
TEMPLATE: forget(<pred_1>, ..., <pred_n>)
TEMPLATE: forget(<L>)
FUNCTION: killcontext
TEMPLATE: killcontext(<context_1>, ..., <context_n>)
FUNCTION: newcontext
TEMPLATE: newcontext(<name>)
FUNCTION: supcontext
TEMPLATE: supcontext(<name>, <context>)
TEMPLATE: supcontext(<name>)
FUNCTION: contrib_ode
TEMPLATE: contrib_ode(<eqn>, <y>, <x>)
FUNCTION: odelin
TEMPLATE: odelin(<eqn>, <y>, <x>)
FUNCTION: ode_check
TEMPLATE: ode_check(<eqn>, <soln>)
OPTION  : method
OPTION  : %c
OPTION  : %k1
OPTION  : %k2
FUNCTION: gauss_a
TEMPLATE: gauss_a(<a>, <b>, <c>, <x>)
FUNCTION: gauss_b
TEMPLATE: gauss_b(<a>, <b>, <c>, <x>)
FUNCTION: dgauss_a
TEMPLATE: dgauss_a(<a>, <b>, <c>, <x>)
FUNCTION: dgauss_b
TEMPLATE: dgauss_b(<a>, <b>, <c>, <x>)
FUNCTION: kummer_m
TEMPLATE: kummer_m(<a>, <b>, <x>)
FUNCTION: kummer_u
TEMPLATE: kummer_u(<a>, <b>, <x>)
FUNCTION: dkummer_m
TEMPLATE: dkummer_m(<a>, <b>, <x>)
FUNCTION: dkummer_u
TEMPLATE: dkummer_u(<a>, <b>, <x>)
FUNCTION: csetup
TEMPLATE: csetup()
FUNCTION: cmetric
TEMPLATE: cmetric(<dis>)
TEMPLATE: cmetric()
FUNCTION: ct_coordsys
TEMPLATE: ct_coordsys(<coordinate_system>, <extra_arg>)
TEMPLATE: ct_coordsys(<coordinate_system>)
FUNCTION: init_ctensor
TEMPLATE: init_ctensor()
FUNCTION: christof
TEMPLATE: christof(<dis>)
FUNCTION: ricci
TEMPLATE: ricci(<dis>)
FUNCTION: uricci
TEMPLATE: uricci(<dis>)
FUNCTION: scurvature
TEMPLATE: scurvature()
FUNCTION: einstein
TEMPLATE: einstein(<dis>)
FUNCTION: leinstein
TEMPLATE: leinstein(<dis>)
FUNCTION: riemann
TEMPLATE: riemann(<dis>)
FUNCTION: lriemann
TEMPLATE: lriemann(<dis>)
FUNCTION: uriemann
TEMPLATE: uriemann(<dis>)
FUNCTION: rinvariant
TEMPLATE: rinvariant()
FUNCTION: weyl
TEMPLATE: weyl(<dis>)
FUNCTION: ctaylor
TEMPLATE: ctaylor()
FUNCTION: frame_bracket
TEMPLATE: frame_bracket(<fr>, <fri>, <diagframe>)
FUNCTION: nptetrad
TEMPLATE: nptetrad()
FUNCTION: psi
TEMPLATE: psi(<dis>)
FUNCTION: petrov
TEMPLATE: petrov()
FUNCTION: contortion
TEMPLATE: contortion(<tr>)
FUNCTION: nonmetricity
TEMPLATE: nonmetricity(<nm>)
FUNCTION: ctransform
TEMPLATE: ctransform(<M>)
FUNCTION: findde
TEMPLATE: findde(<A>, <n>)
FUNCTION: cograd
TEMPLATE: cograd()
FUNCTION: contragrad
TEMPLATE: contragrad()
FUNCTION: dscalar
TEMPLATE: dscalar()
FUNCTION: checkdiv
TEMPLATE: checkdiv()
FUNCTION: cgeodesic
TEMPLATE: cgeodesic(<dis>)
FUNCTION: bdvac
TEMPLATE: bdvac(<f>)
FUNCTION: invariant1
TEMPLATE: invariant1()
FUNCTION: invariant2
TEMPLATE: invariant2()
FUNCTION: bimetric
TEMPLATE: bimetric()
FUNCTION: diagmatrixp
TEMPLATE: diagmatrixp(<M>)
FUNCTION: symmetricp
TEMPLATE: symmetricp(<M>)
FUNCTION: ntermst
TEMPLATE: ntermst(<f>)
FUNCTION: cdisplay
TEMPLATE: cdisplay(<ten>)
FUNCTION: deleten
TEMPLATE: deleten(<L>, <n>)
OPTION  : dim
OPTION  : diagmetric
OPTION  : ctrgsimp
OPTION  : cframe_flag
OPTION  : ctorsion_flag
OPTION  : cnonmet_flag
OPTION  : ctayswitch
OPTION  : ctayvar
OPTION  : ctaypov
OPTION  : ctaypt
OPTION  : gdet
OPTION  : ratchristof
OPTION  : rateinstein
OPTION  : ratriemann
OPTION  : ratweyl
OPTION  : lfg
OPTION  : ufg
OPTION  : riem
OPTION  : lriem
OPTION  : uriem
OPTION  : ric
OPTION  : uric
OPTION  : lg
OPTION  : ug
OPTION  : weyl
OPTION  : fb
OPTION  : kinvariant
OPTION  : np
OPTION  : npi
OPTION  : tr
OPTION  : kt
OPTION  : nm
OPTION  : nmc
OPTION  : tensorkill
OPTION  : ct_coords
OPTION  : refcheck
OPTION  : setcheck
OPTION  : setcheckbreak
OPTION  : setval
FUNCTION: timer
TEMPLATE: timer(<f_1>, ..., <f_n>)
TEMPLATE: timer(all)
TEMPLATE: timer()
FUNCTION: untimer
TEMPLATE: untimer(<f_1>, ..., <f_n>)
TEMPLATE: untimer()
OPTION  : timer_devalue
FUNCTION: timer_info
TEMPLATE: timer_info(<f_1>, ..., <f_n>)
TEMPLATE: timer_info()
FUNCTION: trace
TEMPLATE: trace(<f_1>, ..., <f_n>)
TEMPLATE: trace(all)
TEMPLATE: trace()
FUNCTION: trace_options
TEMPLATE: trace_options(<f>, <option_1>, ..., <option_n>)
TEMPLATE: trace_options(<f>)
FUNCTION: untrace
TEMPLATE: untrace(<f_1>, ..., <f_n>)
TEMPLATE: untrace()
FUNCTION: %ibes
TEMPLATE: %ibes[<n>](<x>) 
FUNCTION: %j
TEMPLATE: %j[<n>](<x>) 
FUNCTION: %k
TEMPLATE: %k[<n>](<x>) 
FUNCTION: %y
TEMPLATE: %y[<n>](<x>) 
FUNCTION: airy
TEMPLATE: airy(<x>)
FUNCTION: bessel
TEMPLATE: bessel(<z>, <a>) 
FUNCTION: expint
TEMPLATE: expint(<z>)
FUNCTION: g0
TEMPLATE: g0(<x>) 
FUNCTION: g1
TEMPLATE: g1(<x>) 
FUNCTION: gn
TEMPLATE: gn(<x>, <n>) 
FUNCTION: gauss
TEMPLATE: gauss(<mean>, <sd>)
FUNCTION: i0
TEMPLATE: i0(<x>) 
FUNCTION: i1
TEMPLATE: i1(<x>) 
FUNCTION: in
TEMPLATE: in(<x>, <n>) 
FUNCTION: j0
TEMPLATE: j0(<x>) 
FUNCTION: j1
TEMPLATE: j1(<x>) 
FUNCTION: jn
TEMPLATE: jn(<x>, <n>) 
FUNCTION: continuous_freq
TEMPLATE: continuous_freq(<list>)
TEMPLATE: continuous_freq(<list>, <m>)
FUNCTION: discrete_freq
TEMPLATE: discrete_freq(<list>)
FUNCTION: subsample
TEMPLATE: subsample(<data_matrix>, <predicate_function>)
TEMPLATE: subsample(<data_matrix>, <predicate_function>, <col_num1>, <col_num2>, ...)
FUNCTION: mean
TEMPLATE: mean(<list>)
TEMPLATE: mean(<matrix>)
FUNCTION: var
TEMPLATE: var(<list>)
TEMPLATE: var(<matrix>)
FUNCTION: var1
TEMPLATE: var1(<list>)
TEMPLATE: var1(<matrix>)
FUNCTION: std
TEMPLATE: std(<list>)
TEMPLATE: std(<matrix>)
FUNCTION: std1
TEMPLATE: std1(<list>)
TEMPLATE: std1(<matrix>)
FUNCTION: noncentral_moment
TEMPLATE: noncentral_moment(<list>, <k>)
TEMPLATE: noncentral_moment(<matrix>, <k>)
FUNCTION: central_moment
TEMPLATE: central_moment(<list>, <k>)
TEMPLATE: central_moment(<matrix>, <k>)
FUNCTION: cv
TEMPLATE: cv(<list>)
TEMPLATE: cv(<matrix>)
FUNCTION: smin
TEMPLATE: smin(<list>)
TEMPLATE: smin(<matrix>)
FUNCTION: smax
TEMPLATE: smax(<list>)
TEMPLATE: smax(<matrix>)
FUNCTION: range
TEMPLATE: range(<list>)
TEMPLATE: range(<matrix>)
FUNCTION: quantile
TEMPLATE: quantile(<list>, <p>)
TEMPLATE: quantile(<matrix>, <p>)
FUNCTION: median
TEMPLATE: median(<list>)
TEMPLATE: median(<matrix>)
FUNCTION: qrange
TEMPLATE: qrange(<list>)
TEMPLATE: qrange(<matrix>)
FUNCTION: mean_deviation
TEMPLATE: mean_deviation(<list>)
TEMPLATE: mean_deviation(<matrix>)
FUNCTION: median_deviation
TEMPLATE: median_deviation(<list>)
TEMPLATE: median_deviation(<matrix>)
FUNCTION: harmonic_mean
TEMPLATE: harmonic_mean(<list>)
TEMPLATE: harmonic_mean(<matrix>)
FUNCTION: geometric_mean
TEMPLATE: geometric_mean(<list>)
TEMPLATE: geometric_mean(<matrix>)
FUNCTION: kurtosis
TEMPLATE: kurtosis(<list>)
TEMPLATE: kurtosis(<matrix>)
FUNCTION: skewness
TEMPLATE: skewness(<list>)
TEMPLATE: skewness(<matrix>)
FUNCTION: pearson_skewness
TEMPLATE: pearson_skewness(<list>)
TEMPLATE: pearson_skewness(<matrix>)
FUNCTION: quartile_skewness
TEMPLATE: quartile_skewness(<list>)
TEMPLATE: quartile_skewness(<matrix>)
FUNCTION: cov
TEMPLATE: cov(<matrix>)
FUNCTION: cov1
TEMPLATE: cov1(<matrix>)
FUNCTION: global_variances
TEMPLATE: global_variances(<matrix>)
TEMPLATE: global_variances(<matrix>, <logical_value>)
FUNCTION: cor
TEMPLATE: cor(<matrix>)
TEMPLATE: cor(<matrix>, <logical_value>)
FUNCTION: list_correlations
TEMPLATE: list_correlations(<matrix>)
TEMPLATE: list_correlations(<matrix>, <logical_value>)
FUNCTION: histogram
TEMPLATE: histogram(<list>)
TEMPLATE: histogram(<list>, <option_1>, <option_2>, ...)
TEMPLATE: histogram(<one_column_matrix>)
TEMPLATE: histogram(<one_column_matrix>, <option_1>, <option_2>, ...)
TEMPLATE: histogram(<one_row_matrix>)
TEMPLATE: histogram(<one_row_matrix>, <option_1>, <option_2>, ...)
FUNCTION: scatterplot
TEMPLATE: scatterplot(<list>)
TEMPLATE: scatterplot(<list>, <option_1>, <option_2>, ...)
TEMPLATE: scatterplot(<matrix>)
TEMPLATE: scatterplot(<matrix>, <option_1>, <option_2>, ...)
FUNCTION: barsplot
TEMPLATE: barsplot(<data1>, <data2>, ..., <option_1>, <option_2>, ...)
FUNCTION: piechart
TEMPLATE: piechart(<list>)
TEMPLATE: piechart(<list>, <option_1>, <option_2>, ...)
TEMPLATE: piechart(<one_column_matrix>)
TEMPLATE: piechart(<one_column_matrix>, <option_1>, <option_2>, ...)
TEMPLATE: piechart(<one_row_matrix>)
TEMPLATE: piechart(<one_row_matrix>, <option_1>, <option_2>, ...)
FUNCTION: boxplot
TEMPLATE: boxplot(<data>)
TEMPLATE: boxplot(<data>, <option_1>, <option_2>, ...)
FUNCTION: diag
TEMPLATE: diag(<lm>)
FUNCTION: JF
TEMPLATE: JF(<lambda>,<n>)
FUNCTION: jordan
TEMPLATE: jordan(<mat>)
FUNCTION: dispJordan
TEMPLATE: dispJordan(<l>)
FUNCTION: minimalPoly
TEMPLATE: minimalPoly(<l>)
FUNCTION: ModeMatrix
TEMPLATE: ModeMatrix(<A>,<l>)
FUNCTION: mat_function
TEMPLATE: mat_function(<f>,<mat>)
FUNCTION: bc2
TEMPLATE: bc2(<solution>, <xval1>, <yval1>, <xval2>, <yval2>)
FUNCTION: desolve
TEMPLATE: desolve(<eqn>, <x>)
TEMPLATE: desolve([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])
FUNCTION: ic1
TEMPLATE: ic1(<solution>, <xval>, <yval>)
FUNCTION: ic2
TEMPLATE: ic2(<solution>, <xval>, <yval>, <dval>)
FUNCTION: ode2
TEMPLATE: ode2(<eqn>, <dvar>, <ivar>)
FUNCTION: antid
TEMPLATE: antid(<expr>, <x>, <u(x)>) 
FUNCTION: antidiff
TEMPLATE: antidiff(<expr>, <x>, <u>(<x>))
OPTION  : atomgrad
FUNCTION: atvalue
TEMPLATE: atvalue(<expr>, [<x_1> = <a_1>, ..., <x_m> = <a_m>], <c>)
TEMPLATE: atvalue(<expr>, <x_1> = <a_1>, <c>)
FUNCTION: cartan
TEMPLATE: cartan-
FUNCTION: del
TEMPLATE: del(<x>)
FUNCTION: delta
TEMPLATE: delta(<t>)
OPTION  : dependencies
FUNCTION: depends
TEMPLATE: depends(<f_1>, <x_1>, ..., <f_n>, <x_n>)
OPTION  : derivabbrev
FUNCTION: derivdegree
TEMPLATE: derivdegree(<expr>, <y>, <x>)
FUNCTION: derivlist
TEMPLATE: derivlist(<var_1>, ..., <var_k>)
OPTION  : derivsubst
FUNCTION: diff
TEMPLATE: diff(<expr>, <x_1>, <n_1>, ..., <x_m>, <n_m>)
TEMPLATE: diff(<expr>, <x>, <n>)
TEMPLATE: diff(<expr>, <x>)
TEMPLATE: diff(<expr>)
OPTION  : diff
FUNCTION: dscalar
TEMPLATE: dscalar(<f>)
FUNCTION: express
TEMPLATE: express(<expr>)
FUNCTION: gradef
TEMPLATE: gradef(<f>(<x_1>, ..., <x_n>), <g_1>, ..., <g_m>)
TEMPLATE: gradef(<a>, <x>, <expr>)
OPTION  : gradefs
FUNCTION: laplace
TEMPLATE: laplace(<expr>, <t>, <s>)
FUNCTION: pdf_normal
TEMPLATE: pdf_normal(<x>,<m>,<s>)
FUNCTION: cdf_normal
TEMPLATE: cdf_normal(<x>,<m>,<s>)
FUNCTION: quantile_normal
TEMPLATE: quantile_normal(<q>,<m>,<s>)
FUNCTION: mean_normal
TEMPLATE: mean_normal(<m>,<s>)
FUNCTION: var_normal
TEMPLATE: var_normal(<m>,<s>)
FUNCTION: std_normal
TEMPLATE: std_normal(<m>,<s>)
FUNCTION: skewness_normal
TEMPLATE: skewness_normal(<m>,<s>)
FUNCTION: kurtosis_normal
TEMPLATE: kurtosis_normal(<m>,<s>)
FUNCTION: random_normal
TEMPLATE: random_normal(<m>,<s>)
TEMPLATE: random_normal(<m>,<s>,<n>)
FUNCTION: pdf_student_t
TEMPLATE: pdf_student_t(<x>,<n>)
FUNCTION: cdf_student_t
TEMPLATE: cdf_student_t(<x>,<n>)
FUNCTION: quantile_student_t
TEMPLATE: quantile_student_t(<q>,<n>)
FUNCTION: mean_student_t
TEMPLATE: mean_student_t(<n>)
FUNCTION: var_student_t
TEMPLATE: var_student_t(<n>)
FUNCTION: std_student_t
TEMPLATE: std_student_t(<n>)
FUNCTION: skewness_student_t
TEMPLATE: skewness_student_t(<n>)
FUNCTION: kurtosis_student_t
TEMPLATE: kurtosis_student_t(<n>)
FUNCTION: random_student_t
TEMPLATE: random_student_t(<n>)
TEMPLATE: random_student_t(<n>,<m>)
FUNCTION: pdf_noncentral_student_t
TEMPLATE: pdf_noncentral_student_t(<x>,<n>,<ncp>)
FUNCTION: cdf_noncentral_student_t
TEMPLATE: cdf_noncentral_student_t(<x>,<n>,<ncp>)
FUNCTION: quantile_noncentral_student_t
TEMPLATE: quantile_noncentral_student_t(<q>,<n>,<ncp>)
FUNCTION: mean_noncentral_student_t
TEMPLATE: mean_noncentral_student_t(<n>,<ncp>)
FUNCTION: var_noncentral_student_t
TEMPLATE: var_noncentral_student_t(<n>,<ncp>)
FUNCTION: std_noncentral_student_t
TEMPLATE: std_noncentral_student_t(<n>,<ncp>)
FUNCTION: skewness_noncentral_student_t
TEMPLATE: skewness_noncentral_student_t(<n>,<ncp>)
FUNCTION: kurtosis_noncentral_student_t
TEMPLATE: kurtosis_noncentral_student_t(<n>,<ncp>)
FUNCTION: random_noncentral_student_t
TEMPLATE: random_noncentral_student_t(<n>,<ncp>)
TEMPLATE: random_noncentral_student_t(<n>,<ncp>,<m>)
FUNCTION: pdf_chi2
TEMPLATE: pdf_chi2(<x>,<n>)
FUNCTION: cdf_chi2
TEMPLATE: cdf_chi2(<x>,<n>)
FUNCTION: quantile_chi2
TEMPLATE: quantile_chi2(<q>,<n>)
FUNCTION: mean_chi2
TEMPLATE: mean_chi2(<n>)
FUNCTION: var_chi2
TEMPLATE: var_chi2(<n>)
FUNCTION: std_chi2
TEMPLATE: std_chi2(<n>)
FUNCTION: skewness_chi2
TEMPLATE: skewness_chi2(<n>)
FUNCTION: kurtosis_chi2
TEMPLATE: kurtosis_chi2(<n>)
FUNCTION: random_chi2
TEMPLATE: random_chi2(<n>)
TEMPLATE: random_chi2(<n>,<m>)
FUNCTION: pdf_noncentral_chi2
TEMPLATE: pdf_noncentral_chi2(<x>,<n>,<ncp>)
FUNCTION: cdf_noncentral_chi2
TEMPLATE: cdf_noncentral_chi2(<x>,<n>,<ncp>)
FUNCTION: quantile_noncentral_chi2
TEMPLATE: quantile_noncentral_chi2(<q>,<n>,<ncp>)
FUNCTION: mean_noncentral_chi2
TEMPLATE: mean_noncentral_chi2(<n>,<ncp>)
FUNCTION: var_noncentral_chi2
TEMPLATE: var_noncentral_chi2(<n>,<ncp>)
FUNCTION: std_noncentral_chi2
TEMPLATE: std_noncentral_chi2(<n>,<ncp>)
FUNCTION: skewness_noncentral_chi2
TEMPLATE: skewness_noncentral_chi2(<n>,<ncp>)
FUNCTION: kurtosis_noncentral_chi2
TEMPLATE: kurtosis_noncentral_chi2(<n>,<ncp>)
FUNCTION: random_noncentral_chi2
TEMPLATE: random_noncentral_chi2(<n>,<ncp>)
TEMPLATE: random_noncentral_chi2(<n>,<ncp>,<m>)
FUNCTION: pdf_f
TEMPLATE: pdf_f(<x>,<m>,<n>)
FUNCTION: cdf_f
TEMPLATE: cdf_f(<x>,<m>,<n>)
FUNCTION: quantile_f
TEMPLATE: quantile_f(<q>,<m>,<n>)
FUNCTION: mean_f
TEMPLATE: mean_f(<m>,<n>)
FUNCTION: var_f
TEMPLATE: var_f(<m>,<n>)
FUNCTION: std_f
TEMPLATE: std_f(<m>,<n>)
FUNCTION: skewness_f
TEMPLATE: skewness_f(<m>,<n>)
FUNCTION: kurtosis_f
TEMPLATE: kurtosis_f(<m>,<n>)
FUNCTION: random_f
TEMPLATE: random_f(<m>,<n>)
TEMPLATE: random_f(<m>,<n>,<k>)
FUNCTION: pdf_exp
TEMPLATE: pdf_exp(<x>,<m>)
FUNCTION: cdf_exp
TEMPLATE: cdf_exp(<x>,<m>)
FUNCTION: quantile_exp
TEMPLATE: quantile_exp(<q>,<m>)
FUNCTION: mean_exp
TEMPLATE: mean_exp(<m>)
FUNCTION: var_exp
TEMPLATE: var_exp(<m>)
FUNCTION: std_exp
TEMPLATE: std_exp(<m>)
FUNCTION: skewness_exp
TEMPLATE: skewness_exp(<m>)
FUNCTION: kurtosis_exp
TEMPLATE: kurtosis_exp(<m>)
FUNCTION: random_exp
TEMPLATE: random_exp(<m>)
TEMPLATE: random_exp(<m>,<k>)
FUNCTION: pdf_lognormal
TEMPLATE: pdf_lognormal(<x>,<m>,<s>)
FUNCTION: cdf_lognormal
TEMPLATE: cdf_lognormal(<x>,<m>,<s>)
FUNCTION: quantile_lognormal
TEMPLATE: quantile_lognormal(<q>,<m>,<s>)
FUNCTION: mean_lognormal
TEMPLATE: mean_lognormal(<m>,<s>)
FUNCTION: var_lognormal
TEMPLATE: var_lognormal(<m>,<s>)
FUNCTION: std_lognormal
TEMPLATE: std_lognormal(<m>,<s>)
FUNCTION: skewness_lognormal
TEMPLATE: skewness_lognormal(<m>,<s>)
FUNCTION: kurtosis_lognormal
TEMPLATE: kurtosis_lognormal(<m>,<s>)
FUNCTION: random_lognormal
TEMPLATE: random_lognormal(<m>,<s>)
TEMPLATE: random_lognormal(<m>,<s>,<n>)
FUNCTION: pdf_gamma
TEMPLATE: pdf_gamma(<x>,<a>,<b>)
FUNCTION: cdf_gamma
TEMPLATE: cdf_gamma(<x>,<a>,<b>)
FUNCTION: quantile_gamma
TEMPLATE: quantile_gamma(<q>,<a>,<b>)
FUNCTION: mean_gamma
TEMPLATE: mean_gamma(<a>,<b>)
FUNCTION: var_gamma
TEMPLATE: var_gamma(<a>,<b>)
FUNCTION: std_gamma
TEMPLATE: std_gamma(<a>,<b>)
FUNCTION: skewness_gamma
TEMPLATE: skewness_gamma(<a>,<b>)
FUNCTION: kurtosis_gamma
TEMPLATE: kurtosis_gamma(<a>,<b>)
FUNCTION: random_gamma
TEMPLATE: random_gamma(<a>,<b>)
TEMPLATE: random_gamma(<a>,<b>,<n>)
FUNCTION: pdf_beta
TEMPLATE: pdf_beta(<x>,<a>,<b>)
FUNCTION: cdf_beta
TEMPLATE: cdf_beta(<x>,<a>,<b>)
FUNCTION: quantile_beta
TEMPLATE: quantile_beta(<q>,<a>,<b>)
FUNCTION: mean_beta
TEMPLATE: mean_beta(<a>,<b>)
FUNCTION: var_beta
TEMPLATE: var_beta(<a>,<b>)
FUNCTION: std_beta
TEMPLATE: std_beta(<a>,<b>)
FUNCTION: skewness_beta
TEMPLATE: skewness_beta(<a>,<b>)
FUNCTION: kurtosis_beta
TEMPLATE: kurtosis_beta(<a>,<b>)
FUNCTION: random_beta
TEMPLATE: random_beta(<a>,<b>)
TEMPLATE: random_beta(<a>,<b>,<n>)
FUNCTION: pdf_continuous_uniform
TEMPLATE: pdf_continuous_uniform(<x>,<a>,<b>)
FUNCTION: cdf_continuous_uniform
TEMPLATE: cdf_continuous_uniform(<x>,<a>,<b>)
FUNCTION: quantile_continuous_uniform
TEMPLATE: quantile_continuous_uniform(<q>,<a>,<b>)
FUNCTION: mean_continuous_uniform
TEMPLATE: mean_continuous_uniform(<a>,<b>)
FUNCTION: var_continuous_uniform
TEMPLATE: var_continuous_uniform(<a>,<b>)
FUNCTION: std_continuous_uniform
TEMPLATE: std_continuous_uniform(<a>,<b>)
FUNCTION: skewness_continuous_uniform
TEMPLATE: skewness_continuous_uniform(<a>,<b>)
FUNCTION: kurtosis_continuous_uniform
TEMPLATE: kurtosis_continuous_uniform(<a>,<b>)
FUNCTION: random_continuous_uniform
TEMPLATE: random_continuous_uniform(<a>,<b>)
TEMPLATE: random_continuous_uniform(<a>,<b>,<n>)
FUNCTION: pdf_logistic
TEMPLATE: pdf_logistic(<x>,<a>,<b>)
FUNCTION: cdf_logistic
TEMPLATE: cdf_logistic(<x>,<a>,<b>)
FUNCTION: quantile_logistic
TEMPLATE: quantile_logistic(<q>,<a>,<b>)
FUNCTION: mean_logistic
TEMPLATE: mean_logistic(<a>,<b>)
FUNCTION: var_logistic
TEMPLATE: var_logistic(<a>,<b>)
FUNCTION: std_logistic
TEMPLATE: std_logistic(<a>,<b>)
FUNCTION: skewness_logistic
TEMPLATE: skewness_logistic(<a>,<b>)
FUNCTION: kurtosis_logistic
TEMPLATE: kurtosis_logistic(<a>,<b>)
FUNCTION: random_logistic
TEMPLATE: random_logistic(<a>,<b>)
TEMPLATE: random_logistic(<a>,<b>,<n>)
FUNCTION: pdf_pareto
TEMPLATE: pdf_pareto(<x>,<a>,<b>)
FUNCTION: cdf_pareto
TEMPLATE: cdf_pareto(<x>,<a>,<b>)
FUNCTION: quantile_pareto
TEMPLATE: quantile_pareto(<q>,<a>,<b>)
FUNCTION: mean_pareto
TEMPLATE: mean_pareto(<a>,<b>)
FUNCTION: var_pareto
TEMPLATE: var_pareto(<a>,<b>)
FUNCTION: std_pareto
TEMPLATE: std_pareto(<a>,<b>)
FUNCTION: skewness_pareto
TEMPLATE: skewness_pareto(<a>,<b>)
FUNCTION: kurtosis_pareto
TEMPLATE: kurtosis_pareto(<a>,<b>)
FUNCTION: random_pareto
TEMPLATE: random_pareto(<a>,<b>)
TEMPLATE: random_pareto(<a>,<b>,<n>)
FUNCTION: pdf_weibull
TEMPLATE: pdf_weibull(<x>,<a>,<b>)
FUNCTION: cdf_weibull
TEMPLATE: cdf_weibull(<x>,<a>,<b>)
FUNCTION: quantile_weibull
TEMPLATE: quantile_weibull(<q>,<a>,<b>)
FUNCTION: mean_weibull
TEMPLATE: mean_weibull(<a>,<b>)
FUNCTION: var_weibull
TEMPLATE: var_weibull(<a>,<b>)
FUNCTION: std_weibull
TEMPLATE: std_weibull(<a>,<b>)
FUNCTION: skewness_weibull
TEMPLATE: skewness_weibull(<a>,<b>)
FUNCTION: kurtosis_weibull
TEMPLATE: kurtosis_weibull(<a>,<b>)
FUNCTION: random_weibull
TEMPLATE: random_weibull(<a>,<b>)
TEMPLATE: random_weibull(<a>,<b>,<n>)
FUNCTION: pdf_rayleigh
TEMPLATE: pdf_rayleigh(<x>,<b>)
FUNCTION: cdf_rayleigh
TEMPLATE: cdf_rayleigh(<x>,<b>)
FUNCTION: quantile_rayleigh
TEMPLATE: quantile_rayleigh(<q>,<b>)
FUNCTION: mean_rayleigh
TEMPLATE: mean_rayleigh(<b>)
FUNCTION: var_rayleigh
TEMPLATE: var_rayleigh(<b>)
FUNCTION: std_rayleigh
TEMPLATE: std_rayleigh(<b>)
FUNCTION: skewness_rayleigh
TEMPLATE: skewness_rayleigh(<b>)
FUNCTION: kurtosis_rayleigh
TEMPLATE: kurtosis_rayleigh(<b>)
FUNCTION: random_rayleigh
TEMPLATE: random_rayleigh(<b>)
TEMPLATE: random_rayleigh(<b>,<n>)
FUNCTION: pdf_laplace
TEMPLATE: pdf_laplace(<x>,<a>,<b>)
FUNCTION: cdf_laplace
TEMPLATE: cdf_laplace(<x>,<a>,<b>)
FUNCTION: quantile_laplace
TEMPLATE: quantile_laplace(<q>,<a>,<b>)
FUNCTION: mean_laplace
TEMPLATE: mean_laplace(<a>,<b>)
FUNCTION: var_laplace
TEMPLATE: var_laplace(<a>,<b>)
FUNCTION: std_laplace
TEMPLATE: std_laplace(<a>,<b>)
FUNCTION: skewness_laplace
TEMPLATE: skewness_laplace(<a>,<b>)
FUNCTION: kurtosis_laplace
TEMPLATE: kurtosis_laplace(<a>,<b>)
FUNCTION: random_laplace
TEMPLATE: random_laplace(<a>,<b>)
TEMPLATE: random_laplace(<a>,<b>,<n>)
FUNCTION: pdf_cauchy
TEMPLATE: pdf_cauchy(<x>,<a>,<b>)
FUNCTION: cdf_cauchy
TEMPLATE: cdf_cauchy(<x>,<a>,<b>)
FUNCTION: quantile_cauchy
TEMPLATE: quantile_cauchy(<q>,<a>,<b>)
FUNCTION: random_cauchy
TEMPLATE: random_cauchy(<a>,<b>)
TEMPLATE: random_cauchy(<a>,<b>,<n>)
FUNCTION: pdf_gumbel
TEMPLATE: pdf_gumbel(<x>,<a>,<b>)
FUNCTION: cdf_gumbel
TEMPLATE: cdf_gumbel(<x>,<a>,<b>)
FUNCTION: quantile_gumbel
TEMPLATE: quantile_gumbel(<q>,<a>,<b>)
FUNCTION: mean_gumbel
TEMPLATE: mean_gumbel(<a>,<b>)
FUNCTION: var_gumbel
TEMPLATE: var_gumbel(<a>,<b>)
FUNCTION: std_gumbel
TEMPLATE: std_gumbel(<a>,<b>)
FUNCTION: skewness_gumbel
TEMPLATE: skewness_gumbel(<a>,<b>)
FUNCTION: kurtosis_gumbel
TEMPLATE: kurtosis_gumbel(<a>,<b>)
FUNCTION: random_gumbel
TEMPLATE: random_gumbel(<a>,<b>)
TEMPLATE: random_gumbel(<a>,<b>,<n>)
FUNCTION: pdf_binomial
TEMPLATE: pdf_binomial(<x>,<n>,<p>)
FUNCTION: cdf_binomial
TEMPLATE: cdf_binomial(<x>,<n>,<p>)
FUNCTION: quantile_binomial
TEMPLATE: quantile_binomial(<q>,<n>,<p>)
FUNCTION: mean_binomial
TEMPLATE: mean_binomial(<n>,<p>)
FUNCTION: var_binomial
TEMPLATE: var_binomial(<n>,<p>)
FUNCTION: std_binomial
TEMPLATE: std_binomial(<n>,<p>)
FUNCTION: skewness_binomial
TEMPLATE: skewness_binomial(<n>,<p>)
FUNCTION: kurtosis_binomial
TEMPLATE: kurtosis_binomial(<n>,<p>)
FUNCTION: random_binomial
TEMPLATE: random_binomial(<n>,<p>)
TEMPLATE: random_binomial(<n>,<p>,<m>)
FUNCTION: pdf_poisson
TEMPLATE: pdf_poisson(<x>,<m>)
FUNCTION: cdf_poisson
TEMPLATE: cdf_poisson(<x>,<m>)
FUNCTION: quantile_poisson
TEMPLATE: quantile_poisson(<q>,<m>)
FUNCTION: mean_poisson
TEMPLATE: mean_poisson(<m>)
FUNCTION: var_poisson
TEMPLATE: var_poisson(<m>)
FUNCTION: std_poisson
TEMPLATE: std_poisson(<m>)
FUNCTION: skewness_poisson
TEMPLATE: skewness_poisson(<m>)
FUNCTION: kurtosis_poisson
TEMPLATE: kurtosis_poisson(<m>)
FUNCTION: random_poisson
TEMPLATE: random_poisson(<m>)
TEMPLATE: random_poisson(<m>,<n>)
FUNCTION: pdf_bernoulli
TEMPLATE: pdf_bernoulli(<x>,<p>)
FUNCTION: cdf_bernoulli
TEMPLATE: cdf_bernoulli(<x>,<p>)
FUNCTION: quantile_bernoulli
TEMPLATE: quantile_bernoulli(<q>,<p>)
FUNCTION: mean_bernoulli
TEMPLATE: mean_bernoulli(<p>)
FUNCTION: var_bernoulli
TEMPLATE: var_bernoulli(<p>)
FUNCTION: std_bernoulli
TEMPLATE: std_bernoulli(<p>)
FUNCTION: skewness_bernoulli
TEMPLATE: skewness_bernoulli(<p>)
FUNCTION: kurtosis_bernoulli
TEMPLATE: kurtosis_bernoulli(<p>)
FUNCTION: random_bernoulli
TEMPLATE: random_bernoulli(<p>)
TEMPLATE: random_bernoulli(<p>,<n>)
FUNCTION: pdf_geometric
TEMPLATE: pdf_geometric(<x>,<p>)
FUNCTION: cdf_geometric
TEMPLATE: cdf_geometric(<x>,<p>)
FUNCTION: quantile_geometric
TEMPLATE: quantile_geometric(<q>,<p>)
FUNCTION: mean_geometric
TEMPLATE: mean_geometric(<p>)
FUNCTION: var_geometric
TEMPLATE: var_geometric(<p>)
FUNCTION: std_geometric
TEMPLATE: std_geometric(<p>)
FUNCTION: skewness_geometric
TEMPLATE: skewness_geometric(<p>)
FUNCTION: kurtosis_geometric
TEMPLATE: kurtosis_geometric(<p>)
FUNCTION: random_geometric
TEMPLATE: random_geometric(<p>)
TEMPLATE: random_geometric(<p>,<n>)
FUNCTION: pdf_discrete_uniform
TEMPLATE: pdf_discrete_uniform(<x>,<n>)
FUNCTION: cdf_discrete_uniform
TEMPLATE: cdf_discrete_uniform(<x>,<n>)
FUNCTION: quantile_discrete_uniform
TEMPLATE: quantile_discrete_uniform(<q>,<n>)
FUNCTION: mean_discrete_uniform
TEMPLATE: mean_discrete_uniform(<n>)
FUNCTION: var_discrete_uniform
TEMPLATE: var_discrete_uniform(<n>)
FUNCTION: std_discrete_uniform
TEMPLATE: std_discrete_uniform(<n>)
FUNCTION: skewness_discrete_uniform
TEMPLATE: skewness_discrete_uniform(<n>)
FUNCTION: kurtosis_discrete_uniform
TEMPLATE: kurtosis_discrete_uniform(<n>)
FUNCTION: random_discrete_uniform
TEMPLATE: random_discrete_uniform(<n>)
TEMPLATE: random_discrete_uniform(<n>,<m>)
FUNCTION: pdf_hypergeometric
TEMPLATE: pdf_hypergeometric(<x>,<n1>,<n2>,<n>)
FUNCTION: cdf_hypergeometric
TEMPLATE: cdf_hypergeometric(<x>,<n1>,<n2>,<n>)
FUNCTION: quantile_hypergeometric
TEMPLATE: quantile_hypergeometric(<q>,<n1>,<n2>,<n>)
FUNCTION: mean_hypergeometric
TEMPLATE: mean_hypergeometric(<n1>,<n2>,<n>)
FUNCTION: var_hypergeometric
TEMPLATE: var_hypergeometric(<n1>,<n2>,<n>)
FUNCTION: std_hypergeometric
TEMPLATE: std_hypergeometric(<n1>,<n2>,<n>)
FUNCTION: skewness_hypergeometric
TEMPLATE: skewness_hypergeometric(<n1>,<n2>,<n>)
FUNCTION: kurtosis_hypergeometric
TEMPLATE: kurtosis_hypergeometric(<n1>,<n2>,<n>)
FUNCTION: random_hypergeometric
TEMPLATE: random_hypergeometric(<n1>,<n2>,<n>)
TEMPLATE: random_hypergeometric(<n1>,<n2>,<n>,<m>)
FUNCTION: pdf_negative_binomial
TEMPLATE: pdf_negative_binomial(<x>,<n>,<p>)
FUNCTION: cdf_negative_binomial
TEMPLATE: cdf_negative_binomial(<x>,<n>,<p>)
FUNCTION: quantile_negative_binomial
TEMPLATE: quantile_negative_binomial(<q>,<n>,<p>)
FUNCTION: mean_negative_binomial
TEMPLATE: mean_negative_binomial(<n>,<p>)
FUNCTION: var_negative_binomial
TEMPLATE: var_negative_binomial(<n>,<p>)
FUNCTION: std_negative_binomial
TEMPLATE: std_negative_binomial(<n>,<p>)
FUNCTION: skewness_negative_binomial
TEMPLATE: skewness_negative_binomial(<n>,<p>)
FUNCTION: kurtosis_negative_binomial
TEMPLATE: kurtosis_negative_binomial(<n>,<p>)
FUNCTION: random_negative_binomial
TEMPLATE: random_negative_binomial(<n>,<p>)
TEMPLATE: random_negative_binomial(<n>,<p>,<m>)
FUNCTION: draw
TEMPLATE: draw(<gr2d>, ..., <gr3d>, ..., <options>, ...)
FUNCTION: draw2d
TEMPLATE: draw2d(<option>, <graphic_object>, ...)
FUNCTION: draw3d
TEMPLATE: draw3d(<option>, <graphic_object>, ...)
FUNCTION: draw_file
TEMPLATE: draw_file(<graphic option>, ..., <graphic object>, ...)
FUNCTION: multiplot_mode
TEMPLATE: multiplot_mode(<term>)
FUNCTION: set_draw_defaults
TEMPLATE: set_draw_defaults(<graphic option>, ..., <graphic object>, ...)
OPTION  : adapt_depth
OPTION  : axis_3d
OPTION  : axis_bottom
OPTION  : axis_left
OPTION  : axis_right
OPTION  : axis_top
OPTION  : border
OPTION  : cbrange
OPTION  : cbtics
OPTION  : color
OPTION  : colorbox
OPTION  : columns
OPTION  : contour
OPTION  : contour_levels
OPTION  : data_file_name
OPTION  : delay
OPTION  : enhanced3d
OPTION  : eps_height
OPTION  : eps_width
OPTION  : file_bgcolor
OPTION  : file_name
OPTION  : fill_color
OPTION  : fill_density
OPTION  : filled_func
OPTION  : font
OPTION  : font_size
OPTION  : gnuplot_file_name
OPTION  : grid
OPTION  : head_angle
OPTION  : head_both
OPTION  : head_length
OPTION  : head_type
OPTION  : ip_grid
OPTION  : ip_grid_in
OPTION  : key
OPTION  : label_alignment
OPTION  : label_orientation
OPTION  : line_type
OPTION  : line_width
OPTION  : logcb
OPTION  : logx
OPTION  : logy
OPTION  : logz
OPTION  : nticks
OPTION  : palette
OPTION  : pdf_height
OPTION  : pdf_width
OPTION  : pic_height
OPTION  : pic_width
OPTION  : point_size
OPTION  : point_type
OPTION  : points_joined
OPTION  : proportional_axes
OPTION  : rot_horizontal
OPTION  : rot_vertical
OPTION  : surface_hide
OPTION  : terminal
OPTION  : title
OPTION  : transform
OPTION  : transparent
OPTION  : tube_extremes
OPTION  : unit_vectors
OPTION  : user_preamble
OPTION  : x_voxel
OPTION  : xaxis
OPTION  : xaxis_color
OPTION  : xaxis_secondary
OPTION  : xaxis_type
OPTION  : xaxis_width
OPTION  : xlabel
OPTION  : xrange
OPTION  : xrange_secondary
OPTION  : xtics
OPTION  : xtics_axis
OPTION  : xtics_rotate
OPTION  : xtics_rotate_secondary
OPTION  : xtics_secondary
OPTION  : xtics_secondary_axis
OPTION  : xu_grid
OPTION  : xy_file
OPTION  : xyplane
OPTION  : y_voxel
OPTION  : yaxis
OPTION  : yaxis_color
OPTION  : yaxis_secondary
OPTION  : yaxis_type
OPTION  : yaxis_width
OPTION  : ylabel
OPTION  : yrange
OPTION  : yrange_secondary
OPTION  : ytics
OPTION  : ytics_axis
OPTION  : ytics_rotate
OPTION  : ytics_rotate_secondary
OPTION  : ytics_secondary
OPTION  : ytics_secondary_axis
OPTION  : yv_grid
OPTION  : z_voxel
OPTION  : zaxis
OPTION  : zaxis_color
OPTION  : zaxis_type
OPTION  : zaxis_width
OPTION  : zlabel
OPTION  : zrange
OPTION  : ztics
OPTION  : ztics_axis
OPTION  : ztics_rotate
TEMPLATE: make_level_picture(<data>,<width>,<height>)
OPTION  : boundaries_array
FUNCTION: chaosgame
TEMPLATE: chaosgame(<[[><x1>, <y1><]>...<[><xm>, <ym><]]>, <[><x0>, <y0><]>, <b>, <n>, ..., options, ...);
FUNCTION: evolution
TEMPLATE: evolution(<F>, <y0>, <n>, ..., options, ...);
FUNCTION: evolution2d
TEMPLATE: evolution2d(<[><F>, <G><]>, <[><u>, <v><]>, <[><u0>, <y0><]>, <n>, ..., options, ...);
FUNCTION: ifs
TEMPLATE: ifs(<[><r1>, ..., <rm><]>, <[><A1>, ..., <Am><]>, <[[><x1>, <y1><]>, ..., <[><xm>, <ym><]]>, <[><x0>, <y0><]>, <n>, ..., options, ...);
FUNCTION: julia
TEMPLATE: julia(<x>, <y>, ...<options>...)
FUNCTION: mandelbrot
TEMPLATE: mandelbrot(<options>)
FUNCTION: orbits
TEMPLATE: orbits(<F>, <y0>, <n1>, <n2>, [<x>, <x0>, <xf>, <xstep>], ...options...);
FUNCTION: rk
TEMPLATE: rk(<ODE>, <var>, <initial>, <domain>)
TEMPLATE: rk([<ODE1>,...,<ODEm>], [<v1>,...,<vm>], [<init1>,...,<initm>], <domain>)
FUNCTION: staircase
TEMPLATE: staircase(<F>, <y0>, <n>, ...options...);
FUNCTION: jacobi_sn
TEMPLATE: jacobi_sn(<u>, <m>)
FUNCTION: jacobi_cn
TEMPLATE: jacobi_cn(<u>, <m>)
FUNCTION: jacobi_dn
TEMPLATE: jacobi_dn(<u>, <m>)
FUNCTION: jacobi_ns
TEMPLATE: jacobi_ns(<u>, <m>)
FUNCTION: jacobi_sc
TEMPLATE: jacobi_sc(<u>, <m>)
FUNCTION: jacobi_sd
TEMPLATE: jacobi_sd(<u>, <m>)
FUNCTION: jacobi_nc
TEMPLATE: jacobi_nc(<u>, <m>)
FUNCTION: jacobi_cs
TEMPLATE: jacobi_cs(<u>, <m>)
FUNCTION: jacobi_cd
TEMPLATE: jacobi_cd(<u>, <m>)
FUNCTION: jacobi_nd
TEMPLATE: jacobi_nd(<u>, <m>)
FUNCTION: jacobi_ds
TEMPLATE: jacobi_ds(<u>, <m>)
FUNCTION: jacobi_dc
TEMPLATE: jacobi_dc(<u>, <m>)
FUNCTION: inverse_jacobi_sn
TEMPLATE: inverse_jacobi_sn(<u>, <m>)
FUNCTION: inverse_jacobi_cn
TEMPLATE: inverse_jacobi_cn(<u>, <m>)
FUNCTION: inverse_jacobi_dn
TEMPLATE: inverse_jacobi_dn(<u>, <m>)
FUNCTION: inverse_jacobi_ns
TEMPLATE: inverse_jacobi_ns(<u>, <m>)
FUNCTION: inverse_jacobi_sc
TEMPLATE: inverse_jacobi_sc(<u>, <m>)
FUNCTION: inverse_jacobi_sd
TEMPLATE: inverse_jacobi_sd(<u>, <m>)
FUNCTION: inverse_jacobi_nc
TEMPLATE: inverse_jacobi_nc(<u>, <m>)
FUNCTION: inverse_jacobi_cs
TEMPLATE: inverse_jacobi_cs(<u>, <m>)
FUNCTION: inverse_jacobi_cd
TEMPLATE: inverse_jacobi_cd(<u>, <m>)
FUNCTION: inverse_jacobi_nd
TEMPLATE: inverse_jacobi_nd(<u>, <m>)
FUNCTION: inverse_jacobi_ds
TEMPLATE: inverse_jacobi_ds(<u>, <m>)
FUNCTION: inverse_jacobi_dc
TEMPLATE: inverse_jacobi_dc(<u>, <m>)
FUNCTION: elliptic_f
TEMPLATE: elliptic_f(<phi>, <m>)
FUNCTION: elliptic_e
TEMPLATE: elliptic_e(<phi>, <m>)
FUNCTION: elliptic_eu
TEMPLATE: elliptic_eu(<u>, <m>)
FUNCTION: elliptic_pi
TEMPLATE: elliptic_pi(<n>, <phi>, <m>)
FUNCTION: elliptic_kc
TEMPLATE: elliptic_kc(<m>)
FUNCTION: elliptic_ec
TEMPLATE: elliptic_ec(<m>)
OPTION  : %rnum_list
OPTION  : algexact
FUNCTION: algsys
TEMPLATE: algsys([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])
TEMPLATE: algsys([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
FUNCTION: allroots
TEMPLATE: allroots(<expr>)
TEMPLATE: allroots(<eqn>)
FUNCTION: bfallroots
TEMPLATE: bfallroots(<expr>)
TEMPLATE: bfallroots(<eqn>)
OPTION  : backsubst
OPTION  : breakup
FUNCTION: dimension
TEMPLATE: dimension(<eqn>)
TEMPLATE: dimension(<eqn_1>, ..., <eqn_n>)
OPTION  : dispflag
FUNCTION: funcsolve
TEMPLATE: funcsolve(<eqn>, <g>(<t>))
OPTION  : globalsolve
FUNCTION: ieqn
TEMPLATE: ieqn(<ie>, <unk>, <tech>, <n>, <guess>)
OPTION  : ieqnprint
FUNCTION: lhs
TEMPLATE: lhs(<expr>)
FUNCTION: linsolve
TEMPLATE: linsolve([<expr_1>, ..., <expr_m>], [<x_1>, ..., <x_n>])
OPTION  : linsolvewarn
OPTION  : linsolve_params
OPTION  : multiplicities
FUNCTION: nroots
TEMPLATE: nroots(<p>, <low>, <high>)
FUNCTION: nthroot
TEMPLATE: nthroot(<p>, <n>)
OPTION  : polyfactor
OPTION  : programmode
OPTION  : realonly
FUNCTION: realroots
TEMPLATE: realroots(<expr>, <bound>)
TEMPLATE: realroots(<eqn>, <bound>)
TEMPLATE: realroots(<expr>)
TEMPLATE: realroots(<eqn>)
FUNCTION: rhs
TEMPLATE: rhs(<expr>)
OPTION  : rootsconmode
FUNCTION: rootscontract
TEMPLATE: rootscontract(<expr>)
OPTION  : rootsepsilon
FUNCTION: solve
TEMPLATE: solve(<expr>, <x>)
TEMPLATE: solve(<expr>)
TEMPLATE: solve([<eqn_1>, ..., <eqn_n>], [<x_1>, ..., <x_n>])
OPTION  : solvedecomposes
OPTION  : solveexplicit
OPTION  : solvefactors
OPTION  : solvenullwarn
OPTION  : solveradcan
OPTION  : solvetrigwarn
FUNCTION: at
TEMPLATE: at(<expr>, [<eqn_1>, ..., <eqn_n>])
TEMPLATE: at(<expr>, <eqn>)
FUNCTION: box
TEMPLATE: box(<expr>)
TEMPLATE: box(<expr>, <a>)
OPTION  : boxchar
FUNCTION: carg
TEMPLATE: carg(<z>)
FUNCTION: constantp
TEMPLATE: constantp(<expr>)
FUNCTION: declare
TEMPLATE: declare(<a_1>, <p_1>, <a_2>, <p_2>, ...)
FUNCTION: disolate
TEMPLATE: disolate(<expr>, <x_1>, ..., <x_n>)
FUNCTION: dispform
TEMPLATE: dispform(<expr>)
TEMPLATE: dispform(<expr>, all)
FUNCTION: distrib
TEMPLATE: distrib(<expr>)
FUNCTION: dpart
TEMPLATE: dpart(<expr>, <n_1>, ..., <n_k>)
FUNCTION: exp
TEMPLATE: exp(<x>)
OPTION  : %emode
OPTION  : %enumer
OPTION  : exptisolate
OPTION  : exptsubst
FUNCTION: freeof
TEMPLATE: freeof(<x_1>, ..., <x_n>, <expr>)
FUNCTION: genfact
TEMPLATE: genfact(<x>, <y>, <z>)
FUNCTION: imagpart
TEMPLATE: imagpart(<expr>)
FUNCTION: infix
TEMPLATE: infix(<op>)
TEMPLATE: infix(<op>, <lbp>, <rbp>)
TEMPLATE: infix(<op>, <lbp>, <rbp>, <lpos>, <rpos>, <pos>)
OPTION  : inflag
FUNCTION: inpart
TEMPLATE: inpart(<expr>, <n_1>, ..., <n_k>)
FUNCTION: isolate
TEMPLATE: isolate(<expr>, <x>)
OPTION  : isolate_wrt_times
OPTION  : listconstvars
OPTION  : listdummyvars
FUNCTION: listofvars
TEMPLATE: listofvars(<expr>)
FUNCTION: lfreeof
TEMPLATE: lfreeof(<list>, <expr>)
FUNCTION: lopow
TEMPLATE: lopow(<expr>, <x>)
FUNCTION: lpart
TEMPLATE: lpart(<label>, <expr>, <n_1>, ..., <n_k>)
FUNCTION: multthru
TEMPLATE: multthru(<expr>)
TEMPLATE: multthru(<expr_1>, <expr_2>)
FUNCTION: nounify
TEMPLATE: nounify(<f>)
FUNCTION: nterms
TEMPLATE: nterms(<expr>)
FUNCTION: op
TEMPLATE: op(<expr>)
FUNCTION: operatorp
TEMPLATE: operatorp(<expr>, <op>)
TEMPLATE: operatorp(<expr>, [<op_1>, ..., <op_n>])
FUNCTION: optimize
TEMPLATE: optimize(<expr>)
OPTION  : optimprefix
FUNCTION: ordergreat
TEMPLATE: ordergreat(<v_1>, ..., <v_n>)
TEMPLATE: orderless(<v_1>, ..., <v_n>)
FUNCTION: ordergreatp
TEMPLATE: ordergreatp(<expr_1>, <expr_2>)
TEMPLATE: orderlessp(<expr_1>, <expr_2>)
FUNCTION: part
TEMPLATE: part(<expr>, <n_1>, ..., <n_k>)
FUNCTION: partition
TEMPLATE: partition(<expr>, <x>)
OPTION  : partswitch
FUNCTION: pickapart
TEMPLATE: pickapart(<expr>, <n>)
OPTION  : piece
FUNCTION: polarform
TEMPLATE: polarform(<expr>)
FUNCTION: powers
TEMPLATE: powers(<expr>, <x>)
FUNCTION: product
TEMPLATE: product(<expr>, <i>, <i_0>, <i_1>)
FUNCTION: realpart
TEMPLATE: realpart(<expr>)
FUNCTION: rectform
TEMPLATE: rectform(<expr>)
FUNCTION: rembox
TEMPLATE: rembox(<expr>, unlabelled)
TEMPLATE: rembox(<expr>, <label>)
TEMPLATE: rembox(<expr>)
FUNCTION: sum
TEMPLATE: sum(<expr>, <i>, <i_0>, <i_1>)
FUNCTION: lsum
TEMPLATE: lsum(<expr>, <x>, <L>)
FUNCTION: unorder
TEMPLATE: unorder()
FUNCTION: verbify
TEMPLATE: verbify(<f>)
FUNCTION: constvalue
TEMPLATE: constvalue(<x>)
TEMPLATE: declare_constvalue(<a>, <x>)
FUNCTION: units
TEMPLATE: units(<x>)
TEMPLATE: declare_units(<a>, <u>)
FUNCTION: qty
TEMPLATE: qty(<x>)
TEMPLATE: declare_qty(<a>, <x>)
FUNCTION: unitp
TEMPLATE: unitp(<x>)
FUNCTION: declare_unit_conversion
TEMPLATE: declare_unit_conversion(<u> = <v>, ...)
FUNCTION: declare_dimensions
TEMPLATE: declare_dimensions(<a_1>, <d_1>, ..., <a_n>, <d_n>)
TEMPLATE: remove_dimensions(<a_1>, ..., <a_n>)
FUNCTION: declare_fundamental_dimensions
TEMPLATE: declare_fundamental_dimensions(<d_1>, <d_2>, <d_3>, ...)
TEMPLATE: remove_fundamental_dimensions(<d_1>, <d_2>, <d_3>, ...)
FUNCTION: declare_fundamental_units
TEMPLATE: declare_fundamental_units(<u_1>, <d_1>, ..., <u_n>, <d_n>)
TEMPLATE: remove_fundamental_units(<u_1>, ..., <u_n>)
FUNCTION: dimensions
TEMPLATE: dimensions(<x>)
TEMPLATE: dimensions_as_list(<x>)
FUNCTION: fundamental_units
TEMPLATE: fundamental_units(<x>)
TEMPLATE: fundamental_units()
FUNCTION: dimensionless
TEMPLATE: dimensionless(<L>)
FUNCTION: natural_unit
TEMPLATE: natural_unit(<expr>, [<v_1>, ..., <v_n>])
FUNCTION: f90
TEMPLATE: f90(<expr_1>, ..., <expr_n>)
FUNCTION: bffac
TEMPLATE: bffac(<expr>, <n>)
OPTION  : algepsilon
FUNCTION: bfloat
TEMPLATE: bfloat(<expr>)
FUNCTION: bfloatp
TEMPLATE: bfloatp(<expr>)
FUNCTION: bfpsi
TEMPLATE: bfpsi(<n>, <z>, <fpprec>)
TEMPLATE: bfpsi0(<z>, <fpprec>)
OPTION  : bftorat
OPTION  : bftrunc
FUNCTION: cbffac
TEMPLATE: cbffac(<z>, <fpprec>)
FUNCTION: float
TEMPLATE: float(<expr>)
OPTION  : float2bf
FUNCTION: floatnump
TEMPLATE: floatnump(<expr>)
OPTION  : fpprec
OPTION  : fpprintprec
OPTION  : numer_pbranch
FUNCTION: buildq
TEMPLATE: buildq(<L>, <expr>)
FUNCTION: macroexpand
TEMPLATE: macroexpand(<expr>)
FUNCTION: macroexpand1
TEMPLATE: macroexpand1(<expr>)
OPTION  : macros
FUNCTION: splice
TEMPLATE: splice(<a>)
FUNCTION: apply
TEMPLATE: apply(<F>, [<x_1>, ..., <x_n>])
FUNCTION: block
TEMPLATE: block([<v_1>, ..., <v_m>], <expr_1>, ..., <expr_n>)
TEMPLATE: block(<expr_1>, ..., <expr_n>)
FUNCTION: break
TEMPLATE: break(<expr_1>, ..., <expr_n>)
FUNCTION: catch
TEMPLATE: catch(<expr_1>, ..., <expr_n>)
FUNCTION: compfile
TEMPLATE: compfile(<filename>, <f_1>, ..., <f_n>)
TEMPLATE: compfile(<filename>, functions)
TEMPLATE: compfile(<filename>, all)
FUNCTION: compile
TEMPLATE: compile(<f_1>, ..., <f_n>)
TEMPLATE: compile(functions)
TEMPLATE: compile(all)
FUNCTION: define
TEMPLATE: define(<f>(<x_1>, ..., <x_n>), <expr>)
TEMPLATE: define(<f>[<x_1>, ..., <x_n>], <expr>)
TEMPLATE: define(funmake (<f>, [<x_1>, ..., <x_n>]), <expr>)
TEMPLATE: define(arraymake (<f>, [<x_1>, ..., <x_n>]), <expr>)
TEMPLATE: define(ev (<expr_1>), <expr_2>)
FUNCTION: define_variable
TEMPLATE: define_variable(<name>, <default_value>, <mode>)
FUNCTION: dispfun
TEMPLATE: dispfun(<f_1>, ..., <f_n>)
TEMPLATE: dispfun(all)
OPTION  : functions
FUNCTION: fundef
TEMPLATE: fundef(<f>)
FUNCTION: funmake
TEMPLATE: funmake(<F>, [<arg_1>, ..., <arg_n>])
FUNCTION: lambda
TEMPLATE: lambda([<x_1>, ..., <x_m>], <expr_1>, ..., <expr_n>)
TEMPLATE: lambda([[<L>]], <expr_1>, ..., <expr_n>)
TEMPLATE: lambda([<x_1>, ..., <x_m>, [<L>]], <expr_1>, ..., <expr_n>)
FUNCTION: local
TEMPLATE: local(<v_1>, ..., <v_n>)
OPTION  : macroexpansion
OPTION  : mode_checkp
OPTION  : mode_check_errorp
OPTION  : mode_check_warnp
FUNCTION: mode_declare
TEMPLATE: mode_declare(<y_1>, <mode_1>, ..., <y_n>, <mode_n>)
FUNCTION: mode_identity
TEMPLATE: mode_identity(<arg_1>, <arg_2>)
OPTION  : transcompile
FUNCTION: translate
TEMPLATE: translate(<f_1>, ..., <f_n>)
TEMPLATE: translate(functions)
TEMPLATE: translate(all)
FUNCTION: translate_file
TEMPLATE: translate_file(<maxima_filename>)
TEMPLATE: translate_file(<maxima_filename>, <lisp_filename>)
OPTION  : transrun
OPTION  : tr_array_as_ref
OPTION  : tr_bound_function_applyp
OPTION  : tr_file_tty_messagesp
OPTION  : tr_float_can_branch_complex
OPTION  : tr_function_call_default
OPTION  : tr_numer
OPTION  : tr_optimize_max_loop
OPTION  : tr_semicompile
OPTION  : tr_state_vars
FUNCTION: tr_warnings_get
TEMPLATE: tr_warnings_get()
OPTION  : tr_warn_bad_function_calls
OPTION  : tr_warn_fexpr
OPTION  : tr_warn_meval
OPTION  : tr_warn_mode
OPTION  : tr_warn_undeclared
OPTION  : tr_warn_undefined_variable
OPTION  : tr_windy
FUNCTION: compile_file
TEMPLATE: compile_file(<filename>)
TEMPLATE: compile_file(<filename>, <compiled_filename>)
TEMPLATE: compile_file(<filename>, <compiled_filename>, <lisp_filename>)
FUNCTION: declare_translated
TEMPLATE: declare_translated(<f_1>, <f_2>, ...)
OPTION  : GGFINFINITY
OPTION  : GGFCFMAX
FUNCTION: ggf
TEMPLATE: ggf(<l>)
FUNCTION: create_graph
TEMPLATE: create_graph(<v_list>, <e_list>)
TEMPLATE: create_graph(<n>, <e_list>)
TEMPLATE: create_graph(<v_list>, <e_list>, <directed>)
FUNCTION: copy_graph
TEMPLATE: copy_graph(<g>)
FUNCTION: circulant_graph
TEMPLATE: circulant_graph(<n>, <d>)
FUNCTION: clebsch_graph
TEMPLATE: clebsch_graph()
FUNCTION: complement_graph
TEMPLATE: complement_graph(<g>)
FUNCTION: complete_bipartite_graph
TEMPLATE: complete_bipartite_graph(<n>, <m>)
FUNCTION: complete_graph
TEMPLATE: complete_graph(<n>)
FUNCTION: cycle_digraph
TEMPLATE: cycle_digraph(<n>)
FUNCTION: cycle_graph
TEMPLATE: cycle_graph(<n>)
FUNCTION: cuboctahedron_graph
TEMPLATE: cuboctahedron_graph(<n>)
FUNCTION: cube_graph
TEMPLATE: cube_graph(<n>)
FUNCTION: dodecahedron_graph
TEMPLATE: dodecahedron_graph()
FUNCTION: empty_graph
TEMPLATE: empty_graph(<n>)
FUNCTION: flower_snark
TEMPLATE: flower_snark(<n>)
FUNCTION: from_adjacency_matrix
TEMPLATE: from_adjacency_matrix(<A>)
FUNCTION: frucht_graph
TEMPLATE: frucht_graph()
FUNCTION: graph_product
TEMPLATE: graph_product(<g1>, <g1>)
FUNCTION: graph_union
TEMPLATE: graph_union(<g1>, <g1>)
FUNCTION: grid_graph
TEMPLATE: grid_graph(<n>, <m>)
FUNCTION: great_rhombicosidodecahedron_graph
TEMPLATE: great_rhombicosidodecahedron_graph()
FUNCTION: great_rhombicuboctahedron_graph
TEMPLATE: great_rhombicuboctahedron_graph()
FUNCTION: grotzch_graph
TEMPLATE: grotzch_graph()
FUNCTION: heawood_graph
TEMPLATE: heawood_graph()
FUNCTION: icosahedron_graph
TEMPLATE: icosahedron_graph()
FUNCTION: icosidodecahedron_graph
TEMPLATE: icosidodecahedron_graph()
FUNCTION: induced_subgraph
TEMPLATE: induced_subgraph(<V>, <g>)
FUNCTION: line_graph
TEMPLATE: line_graph(<g>)
FUNCTION: make_graph
TEMPLATE: make_graph(<vrt>, <f>)
TEMPLATE: make_graph(<vrt>, <f>, <oriented>)
FUNCTION: mycielski_graph
TEMPLATE: mycielski_graph(<g>)
FUNCTION: new_graph
TEMPLATE: new_graph()
FUNCTION: path_digraph
TEMPLATE: path_digraph(<n>)
FUNCTION: path_graph
TEMPLATE: path_graph(<n>)
FUNCTION: petersen_graph
TEMPLATE: petersen_graph()
TEMPLATE: petersen_graph(<n>, <d>)
FUNCTION: random_bipartite_graph
TEMPLATE: random_bipartite_graph(<a>, <b>, <p>)
FUNCTION: random_digraph
TEMPLATE: random_digraph(<n>, <p>)
FUNCTION: random_regular_graph
TEMPLATE: random_regular_graph(<n>)
TEMPLATE: random_regular_graph(<n>, <d>)
FUNCTION: random_graph
TEMPLATE: random_graph(<n>, <p>)
FUNCTION: random_graph1
TEMPLATE: random_graph1(<n>, <m>)
FUNCTION: random_network
TEMPLATE: random_network(<n>, <p>, <w>)
FUNCTION: random_tournament
TEMPLATE: random_tournament(<n>)
FUNCTION: random_tree
TEMPLATE: random_tree(<n>)
FUNCTION: small_rhombicosidodecahedron_graph
TEMPLATE: small_rhombicosidodecahedron_graph()
FUNCTION: small_rhombicuboctahedron_graph
TEMPLATE: small_rhombicuboctahedron_graph()
FUNCTION: snub_cube_graph
TEMPLATE: snub_cube_graph()
FUNCTION: snub_dodecahedron_graph
TEMPLATE: snub_dodecahedron_graph()
FUNCTION: truncated_cube_graph
TEMPLATE: truncated_cube_graph()
FUNCTION: truncated_dodecahedron_graph
TEMPLATE: truncated_dodecahedron_graph()
FUNCTION: truncated_icosahedron_graph
TEMPLATE: truncated_icosahedron_graph()
FUNCTION: truncated_tetrahedron_graph
TEMPLATE: truncated_tetrahedron_graph()
FUNCTION: tutte_graph
TEMPLATE: tutte_graph()
FUNCTION: underlying_graph
TEMPLATE: underlying_graph(<g>)
FUNCTION: wheel_graph
TEMPLATE: wheel_graph(<n>)
FUNCTION: adjacency_matrix
TEMPLATE: adjacency_matrix(<gr>)
FUNCTION: average_degree
TEMPLATE: average_degree(<gr>)
FUNCTION: biconnected_components
TEMPLATE: biconnected_components(<gr>)
FUNCTION: bipartition
TEMPLATE: bipartition(<gr>)
FUNCTION: chromatic_index
TEMPLATE: chromatic_index(<gr>)
FUNCTION: chromatic_number
TEMPLATE: chromatic_number(<gr>)
FUNCTION: clear_edge_weight
TEMPLATE: clear_edge_weight(<e>, <gr>)
FUNCTION: clear_vertex_label
TEMPLATE: clear_vertex_label(<v>, <gr>)
FUNCTION: connected_components
TEMPLATE: connected_components(<gr>)
FUNCTION: diameter
TEMPLATE: diameter(<gr>)
FUNCTION: edge_coloring
TEMPLATE: edge_coloring(<gr>)
FUNCTION: degree_sequence
TEMPLATE: degree_sequence(<gr>)
FUNCTION: edge_connectivity
TEMPLATE: edge_connectivity(<gr>)
FUNCTION: edges
TEMPLATE: edges(<gr>)
FUNCTION: get_edge_weight
TEMPLATE: get_edge_weight(<e>, <gr>)
TEMPLATE: get_edge_weight(<e>, <gr>, <ifnot>)
FUNCTION: get_vertex_label
TEMPLATE: get_vertex_label(<v>, <gr>)
FUNCTION: graph_charpoly
TEMPLATE: graph_charpoly(<gr>, <x>)
FUNCTION: graph_center
TEMPLATE: graph_center(<gr>)
FUNCTION: graph_eigenvalues
TEMPLATE: graph_eigenvalues(<gr>)
FUNCTION: graph_periphery
TEMPLATE: graph_periphery(<gr>)
FUNCTION: graph_size
TEMPLATE: graph_size(<gr>)
FUNCTION: graph_order
TEMPLATE: graph_order(<gr>)
FUNCTION: girth
TEMPLATE: girth(<gr>)
FUNCTION: hamilton_cycle
TEMPLATE: hamilton_cycle(<gr>)
FUNCTION: hamilton_path
TEMPLATE: hamilton_path(<gr>)
FUNCTION: isomorphism
TEMPLATE: isomorphism(<gr1>, <gr2>)
FUNCTION: in_neighbors
TEMPLATE: in_neighbors(<v>, <gr>)
FUNCTION: is_biconnected
TEMPLATE: is_biconnected(<gr>)
FUNCTION: is_bipartite
TEMPLATE: is_bipartite(<gr>)
FUNCTION: is_connected
TEMPLATE: is_connected(<gr>)
FUNCTION: is_digraph
TEMPLATE: is_digraph(<gr>)
FUNCTION: is_edge_in_graph
TEMPLATE: is_edge_in_graph(<e>, <gr>)
FUNCTION: is_graph
TEMPLATE: is_graph(<gr>)
FUNCTION: is_graph_or_digraph
TEMPLATE: is_graph_or_digraph(<gr>)
FUNCTION: is_isomorphic
TEMPLATE: is_isomorphic(<gr1>, <gr2>)
FUNCTION: is_planar
TEMPLATE: is_planar(<gr>)
FUNCTION: is_sconnected
TEMPLATE: is_sconnected(<gr>)
FUNCTION: is_vertex_in_graph
TEMPLATE: is_vertex_in_graph(<v>, <gr>)
FUNCTION: is_tree
TEMPLATE: is_tree(<gr>)
FUNCTION: laplacian_matrix
TEMPLATE: laplacian_matrix(<gr>)
FUNCTION: max_clique
TEMPLATE: max_clique(<gr>)
FUNCTION: max_degree
TEMPLATE: max_degree(<gr>)
FUNCTION: max_flow
TEMPLATE: max_flow(<net>, <s>, <t>)
FUNCTION: max_independent_set
TEMPLATE: max_independent_set(<gr>)
FUNCTION: max_matching
TEMPLATE: max_matching(<gr>)
FUNCTION: min_degree
TEMPLATE: min_degree(<gr>)
FUNCTION: min_edge_cut
TEMPLATE: min_edge_cut(<gr>)
FUNCTION: min_vertex_cover
TEMPLATE: min_vertex_cover(<gr>)
FUNCTION: min_vertex_cut
TEMPLATE: min_vertex_cut(<gr>)
FUNCTION: minimum_spanning_tree
TEMPLATE: minimum_spanning_tree(<gr>)
FUNCTION: neighbors
TEMPLATE: neighbors(<v>, <gr>)
FUNCTION: odd_girth
TEMPLATE: odd_girth(<gr>)
FUNCTION: out_neighbors
TEMPLATE: out_neighbors(<v>, <gr>)
FUNCTION: planar_embedding
TEMPLATE: planar_embedding(<gr>)
FUNCTION: print_graph
TEMPLATE: print_graph(<gr>)
FUNCTION: radius
TEMPLATE: radius(<gr>)
FUNCTION: set_edge_weight
TEMPLATE: set_edge_weight(<e>, <w>, <gr>)
FUNCTION: set_vertex_label
TEMPLATE: set_vertex_label(<v>, <l>, <gr>)
FUNCTION: shortest_path
TEMPLATE: shortest_path(<u>, <v>, <gr>)
FUNCTION: shortest_weighted_path
TEMPLATE: shortest_weighted_path(<u>, <v>, <gr>)
FUNCTION: strong_components
TEMPLATE: strong_components(<gr>)
FUNCTION: topological_sort
TEMPLATE: topological_sort(<dag>)
FUNCTION: vertex_connectivity
TEMPLATE: vertex_connectivity(<g>)
FUNCTION: vertex_degree
TEMPLATE: vertex_degree(<v>, <gr>)
FUNCTION: vertex_distance
TEMPLATE: vertex_distance(<u>, <v>, <gr>)
FUNCTION: vertex_eccentricity
TEMPLATE: vertex_eccentricity(<v>, <gr>)
FUNCTION: vertex_in_degree
TEMPLATE: vertex_in_degree(<v>, <gr>)
FUNCTION: vertex_out_degree
TEMPLATE: vertex_out_degree(<v>, <gr>)
FUNCTION: vertices
TEMPLATE: vertices(<gr>)
FUNCTION: vertex_coloring
TEMPLATE: vertex_coloring(<gr>)
FUNCTION: wiener_index
TEMPLATE: wiener_index(<gr>)
FUNCTION: add_edge
TEMPLATE: add_edge(<e>, <gr>)
FUNCTION: add_edges
TEMPLATE: add_edges(<e_list>, <gr>)
FUNCTION: add_vertex
TEMPLATE: add_vertex(<v>, <gr>)
FUNCTION: add_vertices
TEMPLATE: add_vertices(<v_list>, <gr>)
FUNCTION: connect_vertices
TEMPLATE: connect_vertices(<v_list>, <u_list>, <gr>)
FUNCTION: contract_edge
TEMPLATE: contract_edge(<e>, <gr>)
FUNCTION: remove_edge
TEMPLATE: remove_edge(<e>, <gr>)
FUNCTION: remove_vertex
TEMPLATE: remove_vertex(<v>, <gr>)
FUNCTION: dimacs_export
TEMPLATE: dimacs_export(<gr>, <fl>)
TEMPLATE: dimacs_export(<gr>, <fl>, <comment1>, ..., <commentn>)
FUNCTION: dimacs_import
TEMPLATE: dimacs_import(<fl>)
FUNCTION: graph6_decode
TEMPLATE: graph6_decode(<str>)
FUNCTION: graph6_encode
TEMPLATE: graph6_encode(<gr>)
FUNCTION: graph6_export
TEMPLATE: graph6_export(<gr_list>, <fl>)
FUNCTION: graph6_import
TEMPLATE: graph6_import(<fl>)
FUNCTION: sparse6_decode
TEMPLATE: sparse6_decode(<str>)
FUNCTION: sparse6_encode
TEMPLATE: sparse6_encode(<gr>)
FUNCTION: sparse6_export
TEMPLATE: sparse6_export(<gr_list>, <fl>)
FUNCTION: sparse6_import
TEMPLATE: sparse6_import(<fl>)
FUNCTION: draw_graph
TEMPLATE: draw_graph(<graph>)
TEMPLATE: draw_graph(<graph>, <option1>, ..., <optionk>)
OPTION  : draw_graph_program
OPTION  : show_id
OPTION  : show_label
OPTION  : label_alignment
OPTION  : show_weight
OPTION  : vertex_type
OPTION  : vertex_size
OPTION  : vertex_color
OPTION  : show_vertices
OPTION  : show_vertex_type
OPTION  : show_vertex_size
OPTION  : show_vertex_color
OPTION  : vertex_partition
OPTION  : vertex_coloring
OPTION  : edge_color
OPTION  : edge_width
OPTION  : edge_type
OPTION  : show_edges
OPTION  : show_edge_color
OPTION  : show_edge_width
OPTION  : show_edge_type
OPTION  : edge_partition
OPTION  : edge_coloring
OPTION  : redraw
OPTION  : head_angle
OPTION  : head_length
OPTION  : spring_embedding_depth
OPTION  : terminal
OPTION  : file_name
OPTION  : program
OPTION  : fixed_vertices
FUNCTION: vertices_to_path
TEMPLATE: vertices_to_path(<v_list>)
FUNCTION: vertices_to_cycle
TEMPLATE: vertices_to_cycle(<v_list>)
OPTION  : poly_monomial_order
OPTION  : poly_coefficient_ring
OPTION  : poly_primary_elimination_order
OPTION  : poly_secondary_elimination_order
OPTION  : poly_elimination_order
OPTION  : poly_return_term_list
OPTION  : poly_grobner_debug
OPTION  : poly_grobner_algorithm
OPTION  : poly_top_reduction_only
FUNCTION: poly_add
TEMPLATE: poly_add(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_subtract
TEMPLATE: poly_subtract(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_multiply
TEMPLATE: poly_multiply(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_s_polynomial
TEMPLATE: poly_s_polynomial(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_primitive_part
TEMPLATE: poly_primitive_part(<poly1>, <varlist>)
FUNCTION: poly_normalize
TEMPLATE: poly_normalize(<poly>, <varlist>)
FUNCTION: poly_expand
TEMPLATE: poly_expand(<poly>, <varlist>)
FUNCTION: poly_expt
TEMPLATE: poly_expt(<poly>, <number>, <varlist>)
FUNCTION: poly_content
TEMPLATE: poly_content(<poly>. <varlist>)
FUNCTION: poly_pseudo_divide
TEMPLATE: poly_pseudo_divide(<poly>, <polylist>, <varlist>)
FUNCTION: poly_exact_divide
TEMPLATE: poly_exact_divide(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_normal_form
TEMPLATE: poly_normal_form(<poly>, <polylist>, <varlist>)
FUNCTION: poly_buchberger_criterion
TEMPLATE: poly_buchberger_criterion(<polylist>, <varlist>)
FUNCTION: poly_buchberger
TEMPLATE: poly_buchberger(<polylist_fl>, <varlist>)
FUNCTION: poly_reduction
TEMPLATE: poly_reduction(<polylist>, <varlist>)
FUNCTION: poly_minimization
TEMPLATE: poly_minimization(<polylist>, <varlist>)
FUNCTION: poly_normalize_list
TEMPLATE: poly_normalize_list(<polylist>, <varlist>)
FUNCTION: poly_grobner
TEMPLATE: poly_grobner(<polylist>, <varlist>)
FUNCTION: poly_reduced_grobner
TEMPLATE: poly_reduced_grobner(<polylist>, <varlist>)
FUNCTION: poly_depends_p
TEMPLATE: poly_depends_p(<poly>, <var>, <varlist>)
FUNCTION: poly_elimination_ideal
TEMPLATE: poly_elimination_ideal(<polylist>, <number>, <varlist>)
FUNCTION: poly_colon_ideal
TEMPLATE: poly_colon_ideal(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_ideal_intersection
TEMPLATE: poly_ideal_intersection(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_lcm
TEMPLATE: poly_lcm(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_gcd
TEMPLATE: poly_gcd(<poly1>, <poly2>, <varlist>)
FUNCTION: poly_grobner_equal
TEMPLATE: poly_grobner_equal(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_grobner_subsetp
TEMPLATE: poly_grobner_subsetp(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_grobner_member
TEMPLATE: poly_grobner_member(<poly>, <polylist>, <varlist>)
FUNCTION: poly_ideal_saturation1
TEMPLATE: poly_ideal_saturation1(<polylist>, <poly>, <varlist>)
FUNCTION: poly_ideal_saturation
TEMPLATE: poly_ideal_saturation(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_ideal_polysaturation1
TEMPLATE: poly_ideal_polysaturation1(<polylist1>, <polylist2>, <varlist>)
FUNCTION: poly_ideal_polysaturation
TEMPLATE: poly_ideal_polysaturation(<polylist>, <polylistlist>, <varlist>)
FUNCTION: poly_saturation_extension
TEMPLATE: poly_saturation_extension(<poly>, <polylist>, <varlist1>, <varlist2>)
FUNCTION: poly_polysaturation_extension
TEMPLATE: poly_polysaturation_extension(<poly>, <polylist>, <varlist1>, <varlist2>)
FUNCTION: todd_coxeter
TEMPLATE: todd_coxeter(<relations>, <subgroup>)
TEMPLATE: todd_coxeter(<relations>)
FUNCTION: apropos
TEMPLATE: apropos(<string>)
FUNCTION: demo
TEMPLATE: demo(<filename>)
FUNCTION: describe
TEMPLATE: describe(<string>)
TEMPLATE: describe(<string>, exact)
TEMPLATE: describe(<string>, inexact)
FUNCTION: example
TEMPLATE: example(<topic>)
TEMPLATE: example()
OPTION  : manual_demo
FUNCTION: implicit_derivative
TEMPLATE: implicit_derivative(<f>,<indvarlist>,<orderlist>,<depvar>)
FUNCTION: implicit_plot
TEMPLATE: implicit_plot(<expr>, <x_range>, <y_range>)
TEMPLATE: implicit_plot([<expr_1>, ..., <expr_n>], <x_range>, <y_range>)
OPTION  : __
OPTION  : _
OPTION  : %
OPTION  : %%
OPTION  : %edispflag
FUNCTION: %th
TEMPLATE: %th(<i>)
OPTION  : absboxchar
OPTION  : file_output_append
FUNCTION: appendfile
TEMPLATE: appendfile(<filename>)
FUNCTION: batch
TEMPLATE: batch(<filename>)
FUNCTION: batchload
TEMPLATE: batchload(<filename>)
FUNCTION: closefile
TEMPLATE: closefile()
FUNCTION: collapse
TEMPLATE: collapse(<expr>)
FUNCTION: concat
TEMPLATE: concat(<arg_1>, <arg_2>, ...)
FUNCTION: sconcat
TEMPLATE: sconcat(<arg_1>, <arg_2>, ...)
FUNCTION: disp
TEMPLATE: disp(<expr_1>, <expr_2>, ...)
FUNCTION: dispcon
TEMPLATE: dispcon(<tensor_1>, <tensor_2>, ...)
TEMPLATE: dispcon(all)
FUNCTION: display
TEMPLATE: display(<expr_1>, <expr_2>, ...)
OPTION  : display2d
OPTION  : display_format_internal
FUNCTION: dispterms
TEMPLATE: dispterms(<expr>)
OPTION  : error_size
OPTION  : error_syms
FUNCTION: expt
TEMPLATE: expt(<a>, <b>)
OPTION  : exptdispflag
FUNCTION: filename_merge
TEMPLATE: filename_merge(<path>, <filename>)
FUNCTION: file_search
TEMPLATE: file_search(<filename>)
TEMPLATE: file_search(<filename>, <pathlist>)
OPTION  : file_search_maxima
FUNCTION: file_type
TEMPLATE: file_type(<filename>)
FUNCTION: grind
TEMPLATE: grind(<expr>)
OPTION  : ibase
OPTION  : inchar
FUNCTION: ldisp
TEMPLATE: ldisp(<expr_1>, ..., <expr_n>)
FUNCTION: ldisplay
TEMPLATE: ldisplay(<expr_1>, ..., <expr_n>)
OPTION  : linechar
OPTION  : linel
OPTION  : lispdisp
FUNCTION: load
TEMPLATE: load(<filename>)
FUNCTION: loadfile
TEMPLATE: loadfile(<filename>)
OPTION  : loadprint
OPTION  : obase
OPTION  : outchar
OPTION  : packagefile
OPTION  : pfeformat
FUNCTION: print
TEMPLATE: print(<expr_1>, ..., <expr_n>)
FUNCTION: printfile
TEMPLATE: printfile(<path>)
FUNCTION: tcl_output
TEMPLATE: tcl_output(<list>, <i0>, <skip>)
TEMPLATE: tcl_output(<list>, <i0>)
TEMPLATE: tcl_output([<list_1>, ..., <list_n>], <i>)
FUNCTION: read
TEMPLATE: read(<expr_1>, ..., <expr_n>)
FUNCTION: readonly
TEMPLATE: readonly(<expr_1>, ..., <expr_n>)
FUNCTION: reveal
TEMPLATE: reveal(<expr>, <depth>)
OPTION  : rmxchar
FUNCTION: save
TEMPLATE: save(<filename>, <name_1>, <name_2>, <name_3>, ...)
TEMPLATE: save(<filename>, values, functions, labels, ...)
TEMPLATE: save(<filename>, [<m>, <n>])
TEMPLATE: save(<filename>, <name_1>=<expr_1>, ...)
TEMPLATE: save(<filename>, all)
TEMPLATE: save(<filename>, <name_1>=<expr_1>, <name_2>=<expr_2>, ...)
OPTION  : savedef
FUNCTION: show
TEMPLATE: show(<expr>)
FUNCTION: showratvars
TEMPLATE: showratvars(<expr>)
OPTION  : stardisp
FUNCTION: string
TEMPLATE: string(<expr>)
OPTION  : stringdisp
FUNCTION: stringout
TEMPLATE: stringout(<filename>, <expr_1>, <expr_2>, <expr_3>, ...)
TEMPLATE: stringout(<filename>, [<m>, <n>])
TEMPLATE: stringout(<filename>, input)
TEMPLATE: stringout(<filename>, functions)
TEMPLATE: stringout(<filename>, values)
FUNCTION: tex
TEMPLATE: tex(<expr>)
TEMPLATE: tex(<expr>, <destination>)
TEMPLATE: tex(<expr>, false)
TEMPLATE: tex(<label>)
TEMPLATE: tex(<label>, <destination>)
TEMPLATE: tex(<label>, false)
FUNCTION: tex1
TEMPLATE: tex1(<e>)
FUNCTION: texput
TEMPLATE: texput(<a>, <s>)
TEMPLATE: texput(<a>, <f>)
TEMPLATE: texput(<a>, <s>, <operator_type>)
TEMPLATE: texput(<a>, [<s_1>, <s_2>], matchfix)
TEMPLATE: texput(<a>, [<s_1>, <s_2>, <s_3>], matchfix)
FUNCTION: get_tex_environment
TEMPLATE: get_tex_environment(<op>)
TEMPLATE: set_tex_environment(<op>, <before>, <after>)
FUNCTION: get_tex_environment_default
TEMPLATE: get_tex_environment_default()
TEMPLATE: set_tex_environment_default(<before>, <after>)
FUNCTION: system
TEMPLATE: system(<command>)
OPTION  : ttyoff
FUNCTION: with_stdout
TEMPLATE: with_stdout(<f>, <expr_1>, <expr_2>, <expr_3>, ...)
TEMPLATE: with_stdout(<s>, <expr_1>, <expr_2>, <expr_3>, ...)
FUNCTION: writefile
TEMPLATE: writefile(<filename>)
FUNCTION: changevar
TEMPLATE: changevar(<expr>, <f(x,y)>, <y>, <x>)
FUNCTION: dblint
TEMPLATE: dblint(<f>, <r>, <s>, <a>, <b>)
FUNCTION: defint
TEMPLATE: defint(<expr>, <x>, <a>, <b>)
OPTION  : erfflag
FUNCTION: ilt
TEMPLATE: ilt(<expr>, <s>, <t>)
OPTION  : intanalysis
FUNCTION: integrate
TEMPLATE: integrate(<expr>, <x>)
TEMPLATE: integrate(<expr>, <x>, <a>, <b>)
OPTION  : integration_constant
OPTION  : integration_constant_counter
OPTION  : integrate_use_rootsof
FUNCTION: ldefint
TEMPLATE: ldefint(<expr>, <x>, <a>, <b>)
FUNCTION: potential
TEMPLATE: potential(<givengradient>)
FUNCTION: residue
TEMPLATE: residue(<expr>, <z>, <z_0>)
FUNCTION: risch
TEMPLATE: risch(<expr>, <x>)
FUNCTION: tldefint
TEMPLATE: tldefint(<expr>, <x>, <a>, <b>)
FUNCTION: quad_qag
TEMPLATE: quad_qag(<f(x)>, <x>, <a>, <b>, <key>, [<epsrel>, <epsabs>, <limit>])
TEMPLATE: quad_qag(<f>, <x>, <a>, <b>, <key>, [<epsrel>, <epsabs>, <limit>])
FUNCTION: quad_qags
TEMPLATE: quad_qags(<f(x)>, <x>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
TEMPLATE: quad_qags(<f>, <x>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
FUNCTION: quad_qagi
TEMPLATE: quad_qagi(<f(x)>, <x>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
TEMPLATE: quad_qagi(<f>, <x>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
FUNCTION: quad_qawc
TEMPLATE: quad_qawc(<f(x)>, <x>, <c>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
TEMPLATE: quad_qawc(<f>, <x>, <c>, <a>, <b>, [<epsrel>, <epsabs>, <limit>])
FUNCTION: quad_qawf
TEMPLATE: quad_qawf(<f(x)>, <x>, <a>, <omega>, <trig>, [<epsabs>, <limit>, <maxp1>, <limlst>])
TEMPLATE: quad_qawf(<f>, <x>, <a>, <omega>, <trig>, [<epsabs>, <limit>, <maxp1>, <limlst>])
FUNCTION: quad_qawo
TEMPLATE: quad_qawo(<f(x)>, <x>, <a>, <b>, <omega>, <trig>, [<epsrel>, <epsabs>, <limit>, <maxp1>, <limlst>])
TEMPLATE: quad_qawo(<f>, <x>, <a>, <b>, <omega>, <trig>, [<epsrel>, <epsabs>, <limit>, <maxp1>, <limlst>])
FUNCTION: quad_qaws
TEMPLATE: quad_qaws(<f(x)>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, [<epsrel>, <epsabs>, <limit>])
TEMPLATE: quad_qaws(<f>, <x>, <a>, <b>, <alpha>, <beta>, <wfun>, [<epsrel>, <epsabs>, <limit>])
FUNCTION: lagrange
TEMPLATE: lagrange(<points>)
TEMPLATE: lagrange(<points>, <option>)
FUNCTION: charfun2
TEMPLATE: charfun2(<x>, <a>, <b>)
FUNCTION: linearinterpol
TEMPLATE: linearinterpol(<points>)
TEMPLATE: linearinterpol(<points>, <option>)
FUNCTION: cspline
TEMPLATE: cspline(<points>)
TEMPLATE: cspline(<points>, <option1>, <option2>, ...)
FUNCTION: ratinterpol
TEMPLATE: ratinterpol(<points>, <numdeg>)
TEMPLATE: ratinterpol(<points>, <numdeg>, <option1>, <option2>, ...)
FUNCTION: entertensor
TEMPLATE: entertensor(<name>)
FUNCTION: changename
TEMPLATE: changename(<old>, <new>, <expr>)
FUNCTION: ishow
TEMPLATE: ishow(<expr>)
FUNCTION: indices
TEMPLATE: indices(<expr>)
FUNCTION: rename
TEMPLATE: rename(<expr>)
TEMPLATE: rename(<expr>, <count>)
OPTION  : flipflag
FUNCTION: defcon
TEMPLATE: defcon(<tensor_1>)
TEMPLATE: defcon(<tensor_1>, <tensor_2>, <tensor_3>)
FUNCTION: remcon
TEMPLATE: remcon(<tensor_1>, ..., <tensor_n>)
TEMPLATE: remcon(all)
FUNCTION: contract
TEMPLATE: contract(<expr>)
FUNCTION: indexed_tensor
TEMPLATE: indexed_tensor(<tensor>)
FUNCTION: components
TEMPLATE: components(<tensor>, <expr>)
FUNCTION: remcomps
TEMPLATE: remcomps(<tensor>)
FUNCTION: showcomps
TEMPLATE: showcomps(<tensor>)
FUNCTION: idummy
TEMPLATE: idummy()
OPTION  : idummyx
OPTION  : icounter
FUNCTION: kdelta
TEMPLATE: kdelta(<L1>, <L2>)
FUNCTION: kdels
TEMPLATE: kdels(<L1>, <L2>)
FUNCTION: levi_civita
TEMPLATE: levi_civita(<L>)
FUNCTION: lc2kdt
TEMPLATE: lc2kdt(<expr>)
FUNCTION: canten
TEMPLATE: canten(<expr>)
FUNCTION: concan
TEMPLATE: concan(<expr>)
OPTION  : allsym
FUNCTION: decsym
TEMPLATE: decsym(<tensor>, <m>, <n>, [<cov_1>, <cov_2>, ...], [<contr_1>, <contr_2>, ...])
FUNCTION: remsym
TEMPLATE: remsym(<tensor>, <m>, <n>)
FUNCTION: canform
TEMPLATE: canform(<expr>)
TEMPLATE: canform(<expr>, <rename>)
FUNCTION: diff
TEMPLATE: diff(<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])
FUNCTION: idiff
TEMPLATE: idiff(<expr>, <v_1>, [<n_1>, [<v_2>, <n_2>] ...])
FUNCTION: liediff
TEMPLATE: liediff(<v>, <ten>)
FUNCTION: rediff
TEMPLATE: rediff(<ten>)
FUNCTION: undiff
TEMPLATE: undiff(<expr>)
FUNCTION: evundiff
TEMPLATE: evundiff(<expr>)
FUNCTION: flush
TEMPLATE: flush(<expr>, <tensor_1>, <tensor_2>, ...)
FUNCTION: flushd
TEMPLATE: flushd(<expr>, <tensor_1>, <tensor_2>, ...)
FUNCTION: flushnd
TEMPLATE: flushnd(<expr>, <tensor>, <n>)
FUNCTION: coord
TEMPLATE: coord(<tensor_1>, <tensor_2>, ...)
FUNCTION: remcoord
TEMPLATE: remcoord(<tensor_1>, <tensor_2>, ...)
TEMPLATE: remcoord(all)
FUNCTION: makebox
TEMPLATE: makebox(<expr>)
FUNCTION: conmetderiv
TEMPLATE: conmetderiv(<expr>, <tensor>)
FUNCTION: simpmetderiv
TEMPLATE: simpmetderiv(<expr>)
TEMPLATE: simpmetderiv(<expr>[, <stop>])
FUNCTION: flush1deriv
TEMPLATE: flush1deriv(<expr>, <tensor>)
FUNCTION: imetric
TEMPLATE: imetric(<g>)
FUNCTION: idim
TEMPLATE: idim(<n>)
FUNCTION: ichr1
TEMPLATE: ichr1([<i>, <j>, <k>])
FUNCTION: ichr2
TEMPLATE: ichr2([<i>, <j>], [<k>])
FUNCTION: icurvature
TEMPLATE: icurvature([<i>, <j>, <k>], [<h>])
FUNCTION: covdiff
TEMPLATE: covdiff(<expr>, <v_1>, <v_2>, ...)
FUNCTION: lorentz_gauge
TEMPLATE: lorentz_gauge(<expr>)
FUNCTION: igeodesic_coords
TEMPLATE: igeodesic_coords(<expr>, <name>)
FUNCTION: iframes
TEMPLATE: iframes()
OPTION  : ifb
OPTION  : icc1
OPTION  : icc2
OPTION  : ifc1
OPTION  : ifc2
OPTION  : ifr
OPTION  : ifri
OPTION  : ifg
OPTION  : ifgi
OPTION  : iframe_bracket_form
OPTION  : inm
OPTION  : inmc1
OPTION  : inmc2
OPTION  : ikt1
OPTION  : ikt2
OPTION  : itr
FUNCTION: extdiff
TEMPLATE: extdiff(<expr>, <i>)
FUNCTION: hodge
TEMPLATE: hodge(<expr>)
OPTION  : igeowedge_flag
FUNCTION: tentex
TEMPLATE: tentex(<expr>)
FUNCTION: ic_convert
TEMPLATE: ic_convert(<eqn>)
FUNCTION: dgeev
TEMPLATE: dgeev(<A>)
TEMPLATE: dgeev(<A>, <right_p>, <left_p>)
FUNCTION: dgesv
TEMPLATE: dgesv(<A>, <b>)
FUNCTION: dgesvd
TEMPLATE: dgesvd(<A>)
TEMPLATE: dgesvd(<A>, <left_p>, <right_p>)
FUNCTION: dlange
TEMPLATE: dlange(<norm>, <A>)
TEMPLATE: zlange(<norm>, <A>)
FUNCTION: lbfgs
TEMPLATE: lbfgs(<FOM>, <X>, <X0>, <epsilon>, <iprint>)
TEMPLATE: lbfgs([<FOM>, <grad>] <X>, <X0>, <epsilon>, <iprint>)
OPTION  : lbfgs_nfeval_max
OPTION  : lbfgs_ncorrections
OPTION  : lhospitallim
FUNCTION: limit
TEMPLATE: limit(<expr>, <x>, <val>, <dir>)
TEMPLATE: limit(<expr>, <x>, <val>)
TEMPLATE: limit(<expr>)
OPTION  : limsubst
FUNCTION: tlimit
TEMPLATE: tlimit(<expr>, <x>, <val>, <dir>)
TEMPLATE: tlimit(<expr>, <x>, <val>)
TEMPLATE: tlimit(<expr>)
OPTION  : tlimswitch
FUNCTION: Lindstedt
TEMPLATE: Lindstedt(<eq>,<pvar>,<torder>,<ic>)
FUNCTION: addmatrices
TEMPLATE: addmatrices(<f>, <M_1>, ..., <M_n>)
FUNCTION: blockmatrixp
TEMPLATE: blockmatrixp(<M>)
FUNCTION: columnop
TEMPLATE: columnop(<M>, <i>, <j>, <theta>)
FUNCTION: columnswap
TEMPLATE: columnswap(<M>, <i>, <j>)
FUNCTION: columnspace
TEMPLATE: columnspace(<M>)
FUNCTION: copy
TEMPLATE: copy(<e>)
FUNCTION: cholesky
TEMPLATE: cholesky(<M>)
TEMPLATE: cholesky(<M>, <field>)
FUNCTION: ctranspose
TEMPLATE: ctranspose(<M>)
FUNCTION: diag_matrix
TEMPLATE: diag_matrix(<d_1>, <d_2>,...,<d_n>)
FUNCTION: dotproduct
TEMPLATE: dotproduct(<u>, <v>)
FUNCTION: eigens_by_jacobi
TEMPLATE: eigens_by_jacobi(<A>)
TEMPLATE: eigens_by_jacobi(<A>, <field_type>)
FUNCTION: get_lu_factors
TEMPLATE: get_lu_factors(<x>) 
FUNCTION: hankel
TEMPLATE: hankel(<col>)
TEMPLATE: hankel(<col>, <row>)
FUNCTION: hessian
TEMPLATE: hessian(<f>, <x>)
FUNCTION: hilbert_matrix
TEMPLATE: hilbert_matrix(<n>)
FUNCTION: identfor
TEMPLATE: identfor(<M>)
TEMPLATE: identfor(<M>, <fld>)
FUNCTION: invert_by_lu
TEMPLATE: invert_by_lu(<M>, <(rng generalring)>)
FUNCTION: jacobian
TEMPLATE: jacobian(<f>, <x>)
FUNCTION: kronecker_product
TEMPLATE: kronecker_product(<A>, <B>)
FUNCTION: listp
TEMPLATE: listp(<e>, <p>)
TEMPLATE: listp(<e>)
FUNCTION: locate_matrix_entry
TEMPLATE: locate_matrix_entry(<M>, <r_1>, <c_1>, <r_2>, <c_2>, <f>, <rel>)
FUNCTION: lu_backsub
TEMPLATE: lu_backsub(<M>, <b>)
FUNCTION: lu_factor
TEMPLATE: lu_factor(<M>, <field>)
FUNCTION: mat_cond
TEMPLATE: mat_cond(<M>, 1)
TEMPLATE: mat_cond(<M>, inf)
FUNCTION: mat_norm
TEMPLATE: mat_norm(<M>, 1)
TEMPLATE: mat_norm(<M>, inf)
TEMPLATE: mat_norm(<M>, frobenius)
FUNCTION: matrixp
TEMPLATE: matrixp(<e>, <p>)
TEMPLATE: matrixp(<e>)
FUNCTION: matrix_size
TEMPLATE: matrix_size(<M>)
FUNCTION: mat_fullunblocker
TEMPLATE: mat_fullunblocker(<M>)
FUNCTION: mat_trace
TEMPLATE: mat_trace(<M>)
FUNCTION: mat_unblocker
TEMPLATE: mat_unblocker(<M>)
FUNCTION: nonnegintegerp
TEMPLATE: nonnegintegerp(<n>)
FUNCTION: nullspace
TEMPLATE: nullspace(<M>)
FUNCTION: nullity
TEMPLATE: nullity(<M>)
FUNCTION: orthogonal_complement
TEMPLATE: orthogonal_complement(<v_1>, ..., <v_n>)
FUNCTION: polynomialp
TEMPLATE: polynomialp(<p>, <L>, <coeffp>, <exponp>)
TEMPLATE: polynomialp(<p>, <L>, <coeffp>)
TEMPLATE: polynomialp(<p>, <L>)
FUNCTION: polytocompanion
TEMPLATE: polytocompanion(<p>, <x>)
FUNCTION: ptriangularize
TEMPLATE: ptriangularize(<M>, <v>)
FUNCTION: rowop
TEMPLATE: rowop(<M>, <i>, <j>, <theta>)
FUNCTION: rank
TEMPLATE: rank(<M>)
FUNCTION: rowswap
TEMPLATE: rowswap(<M>, <i>, <j>)
FUNCTION: toeplitz
TEMPLATE: toeplitz(<col>)
TEMPLATE: toeplitz(<col>, <row>)
FUNCTION: vandermonde_matrix
TEMPLATE: vandermonde_matrix([<x_1>, ..., <x_n>])
FUNCTION: zerofor
TEMPLATE: zerofor(<M>)
TEMPLATE: zerofor(<M>, <fld>)
FUNCTION: zeromatrixp
TEMPLATE: zeromatrixp(<M>)
FUNCTION: append
TEMPLATE: append(<list_1>, ..., <list_n>)
FUNCTION: assoc
TEMPLATE: assoc(<key>, <list>, <default>)
TEMPLATE: assoc(<key>, <list>)
FUNCTION: atom
TEMPLATE: atom(<expr>)
FUNCTION: cons
TEMPLATE: cons(<expr>, <list>)
FUNCTION: copylist
TEMPLATE: copylist(<list>)
FUNCTION: create_list
TEMPLATE: create_list(<form>, <x_1>, <list_1>, ..., <x_n>, <list_n>)
FUNCTION: delete
TEMPLATE: delete(<expr_1>, <expr_2>)
TEMPLATE: delete(<expr_1>, <expr_2>, <n>)
FUNCTION: eighth
TEMPLATE: eighth(<expr>)
FUNCTION: endcons
TEMPLATE: endcons(<expr>, <list>)
FUNCTION: fifth
TEMPLATE: fifth(<expr>)
FUNCTION: first
TEMPLATE: first(<expr>)
FUNCTION: fourth
TEMPLATE: fourth(<expr>)
FUNCTION: get
TEMPLATE: get(<a>, <i>)
FUNCTION: join
TEMPLATE: join(<l>, <m>)
FUNCTION: last
TEMPLATE: last(<expr>)
FUNCTION: length
TEMPLATE: length(<expr>)
OPTION  : listarith
FUNCTION: listp
TEMPLATE: listp(<expr>)
FUNCTION: makelist
TEMPLATE: makelist(<expr>, <i>, <i_0>, <i_1>)
TEMPLATE: makelist(<expr>, <x>, <list>)
FUNCTION: member
TEMPLATE: member(<expr_1>, <expr_2>)
FUNCTION: ninth
TEMPLATE: ninth(<expr>)
FUNCTION: pop
TEMPLATE: pop(<list>)
FUNCTION: push
TEMPLATE: push(<item>, <list>)
FUNCTION: unique
TEMPLATE: unique(<L>)
FUNCTION: rest
TEMPLATE: rest(<expr>, <n>)
TEMPLATE: rest(<expr>)
FUNCTION: reverse
TEMPLATE: reverse(<list>)
FUNCTION: second
TEMPLATE: second(<expr>)
FUNCTION: seventh
TEMPLATE: seventh(<expr>)
FUNCTION: sixth
TEMPLATE: sixth(<expr>)
FUNCTION: sublist_indices
TEMPLATE: sublist_indices(<L>, <P>)
FUNCTION: tenth
TEMPLATE: tenth(<expr>)
FUNCTION: third
TEMPLATE: third(<expr>)
OPTION  : %e_to_numlog
FUNCTION: li
TEMPLATE: li[<s>] (<z>)
FUNCTION: log
TEMPLATE: log(<x>)
OPTION  : logabs
OPTION  : logarc
OPTION  : logconcoeffp
FUNCTION: logcontract
TEMPLATE: logcontract(<expr>)
OPTION  : logexpand
OPTION  : lognegint
OPTION  : lognumer
OPTION  : logsimp
FUNCTION: plog
TEMPLATE: plog(<x>)
FUNCTION: lsquares_estimates
TEMPLATE: lsquares_estimates(<D>, <x>, <e>, <a>)
TEMPLATE: lsquares_estimates(<D>, <x>, <e>, <a>, initial = <L>, tol = <t>)
FUNCTION: lsquares_estimates_exact
TEMPLATE: lsquares_estimates_exact(<MSE>, <a>)
FUNCTION: lsquares_estimates_approximate
TEMPLATE: lsquares_estimates_approximate(<MSE>, <a>, initial = <L>, tol = <t>)
FUNCTION: lsquares_mse
TEMPLATE: lsquares_mse(<D>, <x>, <e>)
FUNCTION: lsquares_residuals
TEMPLATE: lsquares_residuals(<D>, <x>, <e>, <a>)
FUNCTION: lsquares_residual_mse
TEMPLATE: lsquares_residual_mse(<D>, <x>, <e>, <a>)
FUNCTION: plsquares
TEMPLATE: plsquares(<Mat>,<VarList>,<depvars>)
TEMPLATE: plsquares(<Mat>,<VarList>,<depvars>,<maxexpon>)
TEMPLATE: plsquares(<Mat>,<VarList>,<depvars>,<maxexpon>,<maxdegree>)
FUNCTION: makeOrders
TEMPLATE: makeOrders(<indvarlist>,<orderlist>)
FUNCTION: addcol
TEMPLATE: addcol(<M>, <list_1>, ..., <list_n>)
FUNCTION: addrow
TEMPLATE: addrow(<M>, <list_1>, ..., <list_n>)
FUNCTION: adjoint
TEMPLATE: adjoint(<M>)
FUNCTION: augcoefmatrix
TEMPLATE: augcoefmatrix([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
FUNCTION: charpoly
TEMPLATE: charpoly(<M>, <x>)
FUNCTION: coefmatrix
TEMPLATE: coefmatrix([<eqn_1>, ..., <eqn_m>], [<x_1>, ..., <x_n>])
FUNCTION: col
TEMPLATE: col(<M>, <i>)
FUNCTION: columnvector
TEMPLATE: columnvector(<L>)
TEMPLATE: covect(<L>)
FUNCTION: conjugate
TEMPLATE: conjugate(<x>)
FUNCTION: copymatrix
TEMPLATE: copymatrix(<M>)
FUNCTION: determinant
TEMPLATE: determinant(<M>)
OPTION  : detout
FUNCTION: diagmatrix
TEMPLATE: diagmatrix(<n>, <x>)
OPTION  : doallmxops
OPTION  : domxexpt
OPTION  : domxmxops
OPTION  : domxnctimes
OPTION  : dontfactor
OPTION  : doscmxops
OPTION  : doscmxplus
OPTION  : dot0nscsimp
OPTION  : dot0simp
OPTION  : dot1simp
OPTION  : dotassoc
OPTION  : dotconstrules
OPTION  : dotdistrib
OPTION  : dotexptsimp
OPTION  : dotident
OPTION  : dotscrules
FUNCTION: echelon
TEMPLATE: echelon(<M>)
FUNCTION: eigenvalues
TEMPLATE: eigenvalues(<M>)
TEMPLATE: eivals(<M>)
FUNCTION: eigenvectors
TEMPLATE: eigenvectors(<M>)
TEMPLATE: eivects(<M>)
FUNCTION: ematrix
TEMPLATE: ematrix(<m>, <n>, <x>, <i>, <j>)
FUNCTION: entermatrix
TEMPLATE: entermatrix(<m>, <n>)
FUNCTION: genmatrix
TEMPLATE: genmatrix(<a>, <i_2>, <j_2>, <i_1>, <j_1>)
TEMPLATE: genmatrix(<a>, <i_2>, <j_2>, <i_1>)
TEMPLATE: genmatrix(<a>, <i_2>, <j_2>)
FUNCTION: gramschmidt
TEMPLATE: gramschmidt(<x>)
TEMPLATE: gramschmidt(<x>, <F>)
FUNCTION: ident
TEMPLATE: ident(<n>)
FUNCTION: innerproduct
TEMPLATE: innerproduct(<x>, <y>)
TEMPLATE: inprod(<x>, <y>)
FUNCTION: invert
TEMPLATE: invert(<M>)
OPTION  : lmxchar
FUNCTION: matrix
TEMPLATE: matrix(<row_1>, ..., <row_n>)
FUNCTION: matrixmap
TEMPLATE: matrixmap(<f>, <M>)
FUNCTION: matrixp
TEMPLATE: matrixp(<expr>)
OPTION  : matrix_element_add
OPTION  : matrix_element_mult
OPTION  : matrix_element_transpose
FUNCTION: mattrace
TEMPLATE: mattrace(<M>)
FUNCTION: minor
TEMPLATE: minor(<M>, <i>, <j>)
FUNCTION: ncexpt
TEMPLATE: ncexpt(<a>, <b>)
FUNCTION: ncharpoly
TEMPLATE: ncharpoly(<M>, <x>)
FUNCTION: newdet
TEMPLATE: newdet(<M>)
OPTION  : nonscalar
FUNCTION: nonscalarp
TEMPLATE: nonscalarp(<expr>)
FUNCTION: permanent
TEMPLATE: permanent(<M>)
FUNCTION: rank
TEMPLATE: rank(<M>)
OPTION  : ratmx
FUNCTION: row
TEMPLATE: row(<M>, <i>)
OPTION  : scalarmatrixp
FUNCTION: scalefactors
TEMPLATE: scalefactors(<coordinatetransform>)
FUNCTION: setelmx
TEMPLATE: setelmx(<x>, <i>, <j>, <M>)
FUNCTION: similaritytransform
TEMPLATE: similaritytransform(<M>)
TEMPLATE: simtran(<M>)
OPTION  : sparse
FUNCTION: submatrix
TEMPLATE: submatrix(<i_1>, ..., <i_m>, <M>, <j_1>, ..., <j_n>)
TEMPLATE: submatrix(<i_1>, ..., <i_m>, <M>)
TEMPLATE: submatrix(<M>, <j_1>, ..., <j_n>)
FUNCTION: transpose
TEMPLATE: transpose(<M>)
FUNCTION: triangularize
TEMPLATE: triangularize(<M>)
FUNCTION: uniteigenvectors
TEMPLATE: uniteigenvectors(<M>)
TEMPLATE: ueivects(<M>)
FUNCTION: unitvector
TEMPLATE: unitvector(<x>)
TEMPLATE: uvect(<x>)
FUNCTION: vectorsimp
TEMPLATE: vectorsimp(<expr>)
OPTION  : vect_cross
FUNCTION: zeromatrix
TEMPLATE: zeromatrix(<m>, <n>)
FUNCTION: minpack_lsquares
TEMPLATE: minpack_lsquares(<flist>, <varlist>, <guess> [, <tolerance>, <jacobian>])
FUNCTION: minpack_solve
TEMPLATE: minpack_solve(<flist>, <varlist>, <guess> [, <tolerance>, <jacobian>])
OPTION  : aliases
OPTION  : alphabetic
FUNCTION: args
TEMPLATE: args(<expr>)
OPTION  : genindex
OPTION  : gensumnum
TEMPLATE: gensym(<x>)
OPTION  : infolists
FUNCTION: integerp
TEMPLATE: integerp(<expr>)
OPTION  : m1pbranch
FUNCTION: numberp
TEMPLATE: numberp(<expr>)
FUNCTION: properties
TEMPLATE: properties(<a>)
OPTION  : props
FUNCTION: propvars
TEMPLATE: propvars(<prop>)
FUNCTION: put
TEMPLATE: put(<atom>, <value>, <indicator>)
FUNCTION: qput
TEMPLATE: qput(<atom>, <value>, <indicator>)
FUNCTION: rem
TEMPLATE: rem(<atom>, <indicator>)
FUNCTION: remove
TEMPLATE: remove(<a_1>, <p_1>, ..., <a_n>, <p_n>)
TEMPLATE: remove([<a_1>, ..., <a_m>], [<p_1>, ..., <p_n>], ...)
TEMPLATE: remove("<a>", operator)
TEMPLATE: remove(<a>, transfun)
TEMPLATE: remove(all, <p>)
FUNCTION: remvalue
TEMPLATE: remvalue(<name_1>, ..., <name_n>)
TEMPLATE: remvalue(all)
FUNCTION: rncombine
TEMPLATE: rncombine(<expr>)
FUNCTION: scalarp
TEMPLATE: scalarp(<expr>)
FUNCTION: setup_autoload
TEMPLATE: setup_autoload(<filename>, <function_1>, ..., <function_n>)
OPTION  : newtonepsilon
OPTION  : newtonmaxiter
FUNCTION: mnewton
TEMPLATE: mnewton(<FuncList>,<VarList>,<GuessList>)
FUNCTION: adjoin
TEMPLATE: adjoin(<x>, <a>) 
FUNCTION: belln
TEMPLATE: belln(<n>)
FUNCTION: cardinality
TEMPLATE: cardinality(<a>)
FUNCTION: cartesian_product
TEMPLATE: cartesian_product(<b_1>, ... , <b_n>)
FUNCTION: disjoin
TEMPLATE: disjoin(<x>, <a>)
FUNCTION: disjointp
TEMPLATE: disjointp(<a>, <b>) 
FUNCTION: divisors
TEMPLATE: divisors(<n>)
FUNCTION: elementp
TEMPLATE: elementp(<x>, <a>)
FUNCTION: emptyp
TEMPLATE: emptyp(<a>)
FUNCTION: equiv_classes
TEMPLATE: equiv_classes(<s>, <F>)
FUNCTION: every
TEMPLATE: every(<f>, <s>)
TEMPLATE: every(<f>, <L_1>, ..., <L_n>)
FUNCTION: extremal_subset
TEMPLATE: extremal_subset(<s>, <f>, max)
TEMPLATE: extremal_subset(<s>, <f>, min)
FUNCTION: flatten
TEMPLATE: flatten(<expr>)
FUNCTION: full_listify
TEMPLATE: full_listify(<a>)
FUNCTION: fullsetify
TEMPLATE: fullsetify(<a>)
FUNCTION: identity
TEMPLATE: identity(<x>)
FUNCTION: integer_partitions
TEMPLATE: integer_partitions(<n>)
TEMPLATE: integer_partitions(<n>, <len>)
FUNCTION: intersect
TEMPLATE: intersect(<a_1>, ..., <a_n>)
FUNCTION: intersection
TEMPLATE: intersection(<a_1>, ..., <a_n>)
FUNCTION: kron_delta
TEMPLATE: kron_delta(<x>, <y>)
FUNCTION: listify
TEMPLATE: listify(<a>)
FUNCTION: lreduce
TEMPLATE: lreduce(<F>, <s>)
TEMPLATE: lreduce(<F>, <s>, <s_0>)
FUNCTION: makeset
TEMPLATE: makeset(<expr>, <x>, <s>)
FUNCTION: moebius
TEMPLATE: moebius(<n>)
FUNCTION: multinomial_coeff
TEMPLATE: multinomial_coeff(<a_1>, ..., <a_n>)
TEMPLATE: multinomial_coeff()
FUNCTION: num_distinct_partitions
TEMPLATE: num_distinct_partitions(<n>)
TEMPLATE: num_distinct_partitions(<n>, list)
FUNCTION: num_partitions
TEMPLATE: num_partitions(<n>)
TEMPLATE: num_partitions(<n>, list)
FUNCTION: partition_set
TEMPLATE: partition_set(<a>, <f>)
FUNCTION: permutations
TEMPLATE: permutations(<a>)
FUNCTION: powerset
TEMPLATE: powerset(<a>)
TEMPLATE: powerset(<a>, <n>)
FUNCTION: random_permutation
TEMPLATE: random_permutation(<a>)
FUNCTION: rreduce
TEMPLATE: rreduce(<F>, <s>)
TEMPLATE: rreduce(<F>, <s>, @var{s_@{n + 1@}})
FUNCTION: setdifference
TEMPLATE: setdifference(<a>, <b>)
FUNCTION: setequalp
TEMPLATE: setequalp(<a>, <b>)
FUNCTION: setify
TEMPLATE: setify(<a>)
FUNCTION: setp
TEMPLATE: setp(<a>)
FUNCTION: set_partitions
TEMPLATE: set_partitions(<a>)
TEMPLATE: set_partitions(<a>, <n>)
FUNCTION: some
TEMPLATE: some(<f>, <a>)
TEMPLATE: some(<f>, <L_1>, ..., <L_n>)
FUNCTION: stirling1
TEMPLATE: stirling1(<n>, <m>)
FUNCTION: stirling2
TEMPLATE: stirling2(<n>, <m>)
FUNCTION: subset
TEMPLATE: subset(<a>, <f>)
FUNCTION: subsetp
TEMPLATE: subsetp(<a>, <b>)
FUNCTION: symmdifference
TEMPLATE: symmdifference(<a_1>, ..., <a_n>)
FUNCTION: tree_reduce
TEMPLATE: tree_reduce(<F>, <s>)
TEMPLATE: tree_reduce(<F>, <s>, <s_0>)
FUNCTION: union
TEMPLATE: union(<a_1>, ..., <a_n>)
FUNCTION: xreduce
TEMPLATE: xreduce(<F>, <s>)
TEMPLATE: xreduce(<F>, <s>, <s_0>)
FUNCTION: bern
TEMPLATE: bern(<n>)
FUNCTION: bernpoly
TEMPLATE: bernpoly(<x>, <n>)
FUNCTION: bfzeta
TEMPLATE: bfzeta(<s>, <n>)
FUNCTION: bfhzeta
TEMPLATE: bfhzeta(<s>, <h>, <n>)
FUNCTION: binomial
TEMPLATE: binomial(<x>, <y>)
FUNCTION: burn
TEMPLATE: burn(<n>)
FUNCTION: cf
TEMPLATE: cf(<expr>)
FUNCTION: cfdisrep
TEMPLATE: cfdisrep(<list>)
FUNCTION: cfexpand
TEMPLATE: cfexpand(<x>)
OPTION  : cflength
FUNCTION: divsum
TEMPLATE: divsum(<n>, <k>)
TEMPLATE: divsum(<n>)
FUNCTION: euler
TEMPLATE: euler(<n>)
OPTION  : %gamma
FUNCTION: factorial
TEMPLATE: factorial(<x>)
OPTION  : factorial_expand
FUNCTION: fib
TEMPLATE: fib(<n>)
FUNCTION: fibtophi
TEMPLATE: fibtophi(<expr>)
FUNCTION: ifactors
TEMPLATE: ifactors(<n>)
FUNCTION: inrt
TEMPLATE: inrt(<x>, <n>)
FUNCTION: inv_mod
TEMPLATE: inv_mod(<n>, <m>)
FUNCTION: jacobi
TEMPLATE: jacobi(<p>, <q>)
FUNCTION: lcm
TEMPLATE: lcm(<expr_1>, ..., <expr_n>)
FUNCTION: minfactorial
TEMPLATE: minfactorial(<expr>)
FUNCTION: next_prime
TEMPLATE: next_prime(<n>)
FUNCTION: partfrac
TEMPLATE: partfrac(<expr>, <var>)
FUNCTION: power_mod
TEMPLATE: power_mod(<a>, <n>, <m>)
FUNCTION: primep
TEMPLATE: primep(<n>)
OPTION  : primep_number_of_tests
FUNCTION: prev_prime
TEMPLATE: prev_prime(<n>)
FUNCTION: qunit
TEMPLATE: qunit(<n>)
FUNCTION: totient
TEMPLATE: totient(<n>)
OPTION  : zerobern
FUNCTION: zeta
TEMPLATE: zeta(<n>)
OPTION  : zeta%pi
FUNCTION: polartorect
TEMPLATE: polartorect(<r>, <t>)
FUNCTION: recttopolar
TEMPLATE: recttopolar(<a>, <b>)
FUNCTION: inverse_fft
TEMPLATE: inverse_fft(<y>)
FUNCTION: fft
TEMPLATE: fft(<x>)
OPTION  : fortindent
FUNCTION: fortran
TEMPLATE: fortran(<expr>)
OPTION  : fortspaces
FUNCTION: horner
TEMPLATE: horner(<expr>, <x>)
TEMPLATE: horner(<expr>)
FUNCTION: find_root
TEMPLATE: find_root(<expr>, <x>, <a>, <b>)
TEMPLATE: find_root(<f>, <a>, <b>)
FUNCTION: newton
TEMPLATE: newton(<expr>, <x>, <x_0>, <eps>)
FUNCTION: equalp
TEMPLATE: equalp(<x>, <y>)
FUNCTION: remfun
TEMPLATE: remfun(<f>, <expr>)
TEMPLATE: remfun(<f>, <expr>, <x>)
FUNCTION: funp
TEMPLATE: funp(<f>, <expr>)
TEMPLATE: funp(<f>, <expr>, <x>)
FUNCTION: absint
TEMPLATE: absint(<f>, <x>, <halfplane>)
TEMPLATE: absint(<f>, <x>)
TEMPLATE: absint(<f>, <x>, <a>, <b>)
FUNCTION: fourier
TEMPLATE: fourier(<f>, <x>, <p>)
FUNCTION: foursimp
TEMPLATE: foursimp(<l>)
OPTION  : sinnpiflag
OPTION  : cosnpiflag
FUNCTION: fourexpand
TEMPLATE: fourexpand(<l>, <x>, <p>, <limit>)
FUNCTION: fourcos
TEMPLATE: fourcos(<f>, <x>, <p>)
FUNCTION: foursin
TEMPLATE: foursin(<f>, <x>, <p>)
FUNCTION: totalfourier
TEMPLATE: totalfourier(<f>, <x>, <p>)
FUNCTION: fourint
TEMPLATE: fourint(<f>, <x>)
FUNCTION: fourintcos
TEMPLATE: fourintcos(<f>, <x>)
FUNCTION: fourintsin
TEMPLATE: fourintsin(<f>, <x>)
FUNCTION: read_matrix
TEMPLATE: read_matrix(<S>)
TEMPLATE: read_matrix(<S>, <M>)
TEMPLATE: read_matrix(<S>, <separator_flag>)
TEMPLATE: read_matrix(<S>, <M>, <separator_flag>)
FUNCTION: read_array
TEMPLATE: read_array(<S>, <A>)
TEMPLATE: read_array(<S>, <A>, <separator_flag>)
FUNCTION: read_hashed_array
TEMPLATE: read_hashed_array(<S>, <A>)
TEMPLATE: read_hashed_array(<S>, <A>, <separator_flag>)
FUNCTION: read_nested_list
TEMPLATE: read_nested_list(<S>)
TEMPLATE: read_nested_list(<S>, <separator_flag>)
FUNCTION: read_list
TEMPLATE: read_list(<S>)
TEMPLATE: read_list(<S>, <L>)
TEMPLATE: read_list(<S>, <separator_flag>)
TEMPLATE: read_list(<S>, <L>, <separator_flag>)
FUNCTION: write_data
TEMPLATE: write_data(<X>, <D>)
TEMPLATE: write_data(<X>, <D>, <separator_flag>)
FUNCTION: assume_external_byte_order
TEMPLATE: assume_external_byte_order(<byte_order_flag>)
FUNCTION: openr_binary
TEMPLATE: openr_binary(<file_name>)
FUNCTION: openw_binary
TEMPLATE: openw_binary(<file_name>)
FUNCTION: opena_binary
TEMPLATE: opena_binary(<file_name>)
FUNCTION: read_binary_matrix
TEMPLATE: read_binary_matrix(<S>, <M>)
FUNCTION: read_binary_array
TEMPLATE: read_binary_array(<S>, <A>)
FUNCTION: read_binary_list
TEMPLATE: read_binary_list(<S>)
TEMPLATE: read_binary_list(<S>, <L>)
FUNCTION: write_binary_data
TEMPLATE: write_binary_data(<X>, <D>)
FUNCTION: abs
TEMPLATE: abs(<expr>)
OPTION  : additive
OPTION  : allbut
OPTION  : antisymmetric
FUNCTION: cabs
TEMPLATE: cabs(<expr>)
FUNCTION: ceiling
TEMPLATE: ceiling(<x>)
FUNCTION: charfun
TEMPLATE: charfun(<p>)
OPTION  : commutative
FUNCTION: compare
TEMPLATE: compare(<x>, <y>)
FUNCTION: entier
TEMPLATE: entier(<x>)
FUNCTION: equal
TEMPLATE: equal(<a>, <b>)
FUNCTION: floor
TEMPLATE: floor(<x>)
FUNCTION: notequal
TEMPLATE: notequal(<a>, <b>)
FUNCTION: evenp
TEMPLATE: evenp(<expr>)
FUNCTION: fix
TEMPLATE: fix(<x>)
FUNCTION: fullmap
TEMPLATE: fullmap(<f>, <expr_1>, <...>)
FUNCTION: fullmapl
TEMPLATE: fullmapl(<f>, <list_1>, <...>)
FUNCTION: is
TEMPLATE: is(<expr>)
FUNCTION: maybe
TEMPLATE: maybe(<expr>)
FUNCTION: isqrt
TEMPLATE: isqrt(<x>)
FUNCTION: lmax
TEMPLATE: lmax(<L>)
FUNCTION: lmin
TEMPLATE: lmin(<L>)
FUNCTION: max
TEMPLATE: max(<x_1>, <...>, <x_n>)
FUNCTION: min
TEMPLATE: min(<x_1>, <...>, <x_n>)
FUNCTION: polymod
TEMPLATE: polymod(<p>)
TEMPLATE: polymod(<p>, <m>)
FUNCTION: mod
TEMPLATE: mod(<x>, <y>)
FUNCTION: oddp
TEMPLATE: oddp(<expr>)
FUNCTION: psubst
TEMPLATE: psubst(<list>, <expr>)
TEMPLATE: psubst(<a>, <b>, <expr>)
FUNCTION: make_random_state
TEMPLATE: make_random_state(<n>)
TEMPLATE: make_random_state(<s>)
FUNCTION: set_random_state
TEMPLATE: set_random_state(<s>)
FUNCTION: random
TEMPLATE: random(<x>)
FUNCTION: rationalize
TEMPLATE: rationalize(<expr>)
FUNCTION: round
TEMPLATE: round(<x>)
FUNCTION: sign
TEMPLATE: sign(<expr>)
FUNCTION: signum
TEMPLATE: signum(<x>)
FUNCTION: sort
TEMPLATE: sort(<L>, <P>)
TEMPLATE: sort(<L>)
FUNCTION: sqrt
TEMPLATE: sqrt(<x>)
OPTION  : sqrtdispflag
FUNCTION: sublis
TEMPLATE: sublis(<list>, <expr>)
FUNCTION: sublist
TEMPLATE: sublist(<list>, <p>)
OPTION  : sublis_apply_lambda
FUNCTION: subst
TEMPLATE: subst(<a>, <b>, <c>)
FUNCTION: substinpart
TEMPLATE: substinpart(<x>, <expr>, <n_1>, <n_k>)
FUNCTION: substpart
TEMPLATE: substpart(<x>, <expr>, <n_1>, <n_k>)
FUNCTION: subvarp
TEMPLATE: subvarp(<expr>)
FUNCTION: symbolp
TEMPLATE: symbolp(<expr>)
FUNCTION: vectorpotential
TEMPLATE: vectorpotential(<givencurl>)
FUNCTION: xthru
TEMPLATE: xthru(<expr>)
FUNCTION: zeroequiv
TEMPLATE: zeroequiv(<expr>, <v>)
FUNCTION: opsubst
TEMPLATE: opsubst(<f>,<g>,<e>)
TEMPLATE: opsubst(<g>=<f>,<e>)
TEMPLATE: opsubst([<g1>=<f1>,<g2>=<f2>,<gn>=<fn>],<e>)
FUNCTION: assoc_legendre_p
TEMPLATE: assoc_legendre_p(<n>, <m>, <x>)
FUNCTION: assoc_legendre_q
TEMPLATE: assoc_legendre_q(<n>, <m>, <x>)
FUNCTION: chebyshev_t
TEMPLATE: chebyshev_t(<n>, <x>)
FUNCTION: chebyshev_u
TEMPLATE: chebyshev_u(<n>, <x>)
FUNCTION: gen_laguerre
TEMPLATE: gen_laguerre(<n>, <a>, <x>)
FUNCTION: hermite
TEMPLATE: hermite(<n>, <x>)
FUNCTION: intervalp
TEMPLATE: intervalp(<e>)
FUNCTION: jacobi_p
TEMPLATE: jacobi_p(<n>, <a>, <b>, <x>)
FUNCTION: laguerre
TEMPLATE: laguerre(<n>, <x>)
FUNCTION: legendre_p
TEMPLATE: legendre_p(<n>, <x>)
FUNCTION: legendre_q
TEMPLATE: legendre_q(<n>, <x>)
FUNCTION: orthopoly_recur
TEMPLATE: orthopoly_recur(<f>, <args>)
OPTION  : orthopoly_returns_intervals
FUNCTION: orthopoly_weight
TEMPLATE: orthopoly_weight(<f>, <args>)
FUNCTION: pochhammer
TEMPLATE: pochhammer(<n>, <x>)
OPTION  : pochhammer_max_index
FUNCTION: spherical_bessel_j
TEMPLATE: spherical_bessel_j(<n>, <x>)
FUNCTION: spherical_bessel_y
TEMPLATE: spherical_bessel_y(<n>, <x>)
FUNCTION: spherical_hankel1
TEMPLATE: spherical_hankel1(<n>, <x>)
FUNCTION: spherical_hankel2
TEMPLATE: spherical_hankel2(<n>, <x>)
FUNCTION: spherical_harmonic
TEMPLATE: spherical_harmonic(<n>, <m>, <x>, <y>)
FUNCTION: unit_step
TEMPLATE: unit_step(<x>)
FUNCTION: ultraspherical
TEMPLATE: ultraspherical(<n>, <a>, <x>)
FUNCTION: plotdf
TEMPLATE: plotdf(<dydx>, <options>)
TEMPLATE: plotdf(<dvdu>, [<u>,<v>], <options>)
TEMPLATE: plotdf([<dxdt>,<dydt>], <options>)
TEMPLATE: plotdf([<dudt>,<dvdt>], [<u>,<v>], <options>)
FUNCTION: contour_plot
TEMPLATE: contour_plot(<expr>, <x_range>, <y_range>, <options>)
FUNCTION: get_plot_option
TEMPLATE: get_plot_option(<keyword>, <index>)
FUNCTION: make_transform
TEMPLATE: make_transform([<var1>, <var2>, <var3>], <fx>, <fy>, <fz>)
FUNCTION: plot2d
TEMPLATE: plot2d(<plot>, <x_range>, <[options]>)
TEMPLATE: plot2d([<plot_1>, <plot_n>], <options>)
TEMPLATE: plot2d([<plot_1>, <plot_n>], <x_range>, <[options]>)
FUNCTION: plot3d
TEMPLATE: plot3d(<expr>, <x_range>, <y_range>, <[options]>)
TEMPLATE: plot3d([<expr_1>, <...>, <expr_n>], <x_range>, <y_range>, <[options]>)
OPTION  : plot_options
FUNCTION: set_plot_option
TEMPLATE: set_plot_option(<option>)
OPTION  : adapth_depth
OPTION  : axes
OPTION  : azimut
OPTION  : box
OPTION  : color
OPTION  : colorbox
OPTION  : elevation
OPTION  : grid
OPTION  : legend
OPTION  : logx
OPTION  : logy
OPTION  : mesh_lines_color
OPTION  : nticks
OPTION  : palette
OPTION  : plot_format
OPTION  : plot_real_part
OPTION  : point_type
OPTION  : psfile
OPTION  : run_viewer
OPTION  : style
OPTION  : t
OPTION  : transform_xy
OPTION  : x
OPTION  : xlabel
OPTION  : y
OPTION  : ylabel
OPTION  : z
OPTION  : zlabel
OPTION  : gnuplot_term
OPTION  : gnuplot_out_file
OPTION  : gnuplot_pm3d
OPTION  : gnuplot_preamble
OPTION  : gnuplot_curve_titles
OPTION  : gnuplot_curve_styles
OPTION  : gnuplot_default_term_command
OPTION  : gnuplot_dumb_term_command
OPTION  : gnuplot_ps_term_command
FUNCTION: gnuplot_start
TEMPLATE: gnuplot_start()
FUNCTION: gnuplot_close
TEMPLATE: gnuplot_close()
FUNCTION: gnuplot_restart
TEMPLATE: gnuplot_restart()
FUNCTION: gnuplot_replot
TEMPLATE: gnuplot_replot()
TEMPLATE: gnuplot_replot(<s>)
FUNCTION: gnuplot_reset
TEMPLATE: gnuplot_reset()
OPTION  : algebraic
OPTION  : berlefact
FUNCTION: bezout
TEMPLATE: bezout(<p1>, <p2>, <x>)
FUNCTION: bothcoef
TEMPLATE: bothcoef(<expr>, <x>)
FUNCTION: coeff
TEMPLATE: coeff(<expr>, <x>, <n>)
TEMPLATE: coeff(<expr>, <x>)
FUNCTION: combine
TEMPLATE: combine(<expr>)
FUNCTION: content
TEMPLATE: content(<p_1>, <x_1>, <...>, <x_n>)
FUNCTION: denom
TEMPLATE: denom(<expr>)
FUNCTION: divide
TEMPLATE: divide(<p_1>, <p_2>, <x_1>, <...>, <x_n>)
FUNCTION: eliminate
TEMPLATE: eliminate([<eqn_1>, <...>, <eqn_n>], [<x_1>, <...>, <x_k>])
FUNCTION: ezgcd
TEMPLATE: ezgcd(<p_1>, <p_2>, <p_3>, ...)
OPTION  : facexpand
FUNCTION: factcomb
TEMPLATE: factcomb(<expr>)
FUNCTION: factor
TEMPLATE: factor(<expr>)
TEMPLATE: factor(<expr>, <p>)
OPTION  : factorflag
FUNCTION: factorout
TEMPLATE: factorout(<expr>, <x_1>, <x_2>, <...>)
FUNCTION: factorsum
TEMPLATE: factorsum(<expr>)
FUNCTION: fasttimes
TEMPLATE: fasttimes(<p_1>, <p_2>)
FUNCTION: fullratsimp
TEMPLATE: fullratsimp(<expr>)
FUNCTION: fullratsubst
TEMPLATE: fullratsubst(<a>, <b>, <c>)
FUNCTION: gcd
TEMPLATE: gcd(<p_1>, <p_2>, <x_1>, <...>)
FUNCTION: gcdex
TEMPLATE: gcdex(<f>, <g>)
TEMPLATE: gcdex(<f>, <g>, <x>)
FUNCTION: gcfactor
TEMPLATE: gcfactor(<n>)
FUNCTION: gfactor
TEMPLATE: gfactor(<expr>)
FUNCTION: gfactorsum
TEMPLATE: gfactorsum(<expr>)
FUNCTION: hipow
TEMPLATE: hipow(<expr>, <x>)
OPTION  : intfaclim
OPTION  : keepfloat
FUNCTION: lratsubst
TEMPLATE: lratsubst(<L>, <expr>)
OPTION  : modulus
FUNCTION: num
TEMPLATE: num(<expr>)
FUNCTION: polydecomp
TEMPLATE: polydecomp(<p>, <x>)
FUNCTION: quotient
TEMPLATE: quotient(<p_1>, <p_2>)
TEMPLATE: quotient(<p_1>, <p_2>, <x_1>, <...>, <x_n>)
FUNCTION: rat
TEMPLATE: rat(<expr>)
TEMPLATE: rat(<expr>, <x_1>, <...>, <x_n>)
OPTION  : ratalgdenom
FUNCTION: ratcoef
TEMPLATE: ratcoef(<expr>, <x>, <n>)
TEMPLATE: ratcoef(<expr>, <x>)
FUNCTION: ratdenom
TEMPLATE: ratdenom(<expr>)
OPTION  : ratdenomdivide
FUNCTION: ratdiff
TEMPLATE: ratdiff(<expr>, <x>)
FUNCTION: ratdisrep
TEMPLATE: ratdisrep(<expr>)
OPTION  : ratepsilon
FUNCTION: ratexpand
TEMPLATE: ratexpand(<expr>)
OPTION  : ratfac
FUNCTION: ratnumer
TEMPLATE: ratnumer(<expr>)
FUNCTION: ratnump
TEMPLATE: ratnump(<expr>)
FUNCTION: ratp
TEMPLATE: ratp(<expr>)
OPTION  : ratprint
FUNCTION: ratsimp
TEMPLATE: ratsimp(<expr>)
TEMPLATE: ratsimp(<expr>, <x_1>, <...>, <x_n>)
OPTION  : ratsimpexpons
FUNCTION: ratsubst
TEMPLATE: ratsubst(<a>, <b>, <c>)
FUNCTION: ratvars
TEMPLATE: ratvars(<x_1>, <...>, <x_n>)
TEMPLATE: ratvars()
FUNCTION: ratweight
TEMPLATE: ratweight(<x_1>, <w_1>, <...>, <x_n>, <w_n>)
TEMPLATE: ratweight()
OPTION  : ratweights
OPTION  : ratwtlvl
FUNCTION: remainder
TEMPLATE: remainder(<p_1>, <p_2>)
TEMPLATE: remainder(<p_1>, <p_2>, <x_1>, <...>, <x_n>)
FUNCTION: resultant
TEMPLATE: resultant(<p_1>, <p_2>, <x>)
OPTION  : savefactors
FUNCTION: sqfr
TEMPLATE: sqfr(<expr>)
FUNCTION: tellrat
TEMPLATE: tellrat(<p_1>, <...>, <p_n>)
TEMPLATE: tellrat()
FUNCTION: totaldisrep
TEMPLATE: totaldisrep(<expr>)
FUNCTION: untellrat
TEMPLATE: untellrat(<x_1>, <...>, <x_n>)
FUNCTION: backtrace
TEMPLATE: backtrace()
TEMPLATE: backtrace(<n>)
FUNCTION: errcatch
TEMPLATE: errcatch(<expr_1>, <...>, <expr_n>)
FUNCTION: error
TEMPLATE: error(<expr_1>, <...>, <expr_n>)
FUNCTION: errormsg
TEMPLATE: errormsg()
OPTION  : errormsg
FUNCTION: go
TEMPLATE: go(<tag>)
FUNCTION: map
TEMPLATE: map(<f>, <expr_1>, <...>, <expr_n>)
FUNCTION: mapatom
TEMPLATE: mapatom(<expr>)
OPTION  : maperror
OPTION  : mapprint
FUNCTION: maplist
TEMPLATE: maplist(<f>, <expr_1>, <...>, <expr_n>)
OPTION  : prederror
FUNCTION: return
TEMPLATE: return(<value>)
FUNCTION: scanmap
TEMPLATE: scanmap(<f>, <expr>)
TEMPLATE: scanmap(<f>, <expr>, bottomup)
FUNCTION: throw
TEMPLATE: throw(<expr>)
FUNCTION: outermap
TEMPLATE: outermap(<f>, <a_1>, <...>, <a_n>)
FUNCTION: romberg
TEMPLATE: romberg(<expr>, <x>, <a>, <b>)
TEMPLATE: romberg(<F>, <a>, <b>)
OPTION  : rombergabs
OPTION  : rombergit
OPTION  : rombergmin
OPTION  : rombergtol
FUNCTION: apply1
TEMPLATE: apply1(<expr>, <rule_1>, <...>, <rule_n>)
FUNCTION: apply2
TEMPLATE: apply2(<expr>, <rule_1>, <...>, <rule_n>)
FUNCTION: applyb1
TEMPLATE: applyb1(<expr>, <rule_1>, <...>, <rule_n>)
OPTION  : current_let_rule_package
OPTION  : default_let_rule_package
FUNCTION: defmatch
TEMPLATE: defmatch(<progname>, <pattern>, <x_1>, <...>, <x_n>)
TEMPLATE: defmatch(<progname>, <pattern>)
FUNCTION: defrule
TEMPLATE: defrule(<rulename>, <pattern>, <replacement>)
FUNCTION: disprule
TEMPLATE: disprule(<rulename_1>, <...>, <rulename_2>)
TEMPLATE: disprule(all)
FUNCTION: let
TEMPLATE: let(<prod>, <repl>, <predname>, <arg_1>, <...>, <arg_n>)
TEMPLATE: let([<prod>, <repl>, <predname>, <arg_1>, <...>, <arg_n>], <package_name>)
OPTION  : letrat
FUNCTION: letrules
TEMPLATE: letrules()
TEMPLATE: letrules(<package_name>)
FUNCTION: letsimp
TEMPLATE: letsimp(<expr>)
TEMPLATE: letsimp(<expr>, <package_name>)
TEMPLATE: letsimp(<expr>, <package_name_1>, <...>, <package_name_n>)
OPTION  : let_rule_packages
FUNCTION: matchdeclare
TEMPLATE: matchdeclare(<a_1>, <pred_1>, <...>, <a_n>, <pred_n>)
FUNCTION: matchfix
TEMPLATE: matchfix(<ldelimiter>, <rdelimiter>)
TEMPLATE: matchfix(<ldelimiter>, <rdelimiter>, <arg_pos>, <pos>)
FUNCTION: remlet
TEMPLATE: remlet(<prod>, <name>)
TEMPLATE: remlet()
TEMPLATE: remlet(all)
TEMPLATE: remlet(all, <name>)
FUNCTION: remrule
TEMPLATE: remrule(<op>, <rulename>)
TEMPLATE: remrule(<op>, all)
FUNCTION: tellsimp
TEMPLATE: tellsimp(<pattern>, <replacement>)
FUNCTION: tellsimpafter
TEMPLATE: tellsimpafter(<pattern>, <replacement>)
FUNCTION: clear_rules
TEMPLATE: clear_rules()
OPTION  : feature
FUNCTION: featurep
TEMPLATE: featurep(<a>, <f>)
OPTION  : maxima_tempdir
OPTION  : maxima_userdir
FUNCTION: room
TEMPLATE: room()
TEMPLATE: room(true)
TEMPLATE: room(false)
FUNCTION: sstatus
TEMPLATE: sstatus(<keyword>, <item>)
FUNCTION: status
TEMPLATE: status(<feature>)
TEMPLATE: status(<feature>, <item>)
FUNCTION: time
TEMPLATE: time(<%o1>, <%o2>, <%o3>, <...>)
FUNCTION: timedate
TEMPLATE: timedate()
TEMPLATE: timedate(<T>)
FUNCTION: absolute_real_time
TEMPLATE: absolute_real_time()
FUNCTION: elapsed_real_time
TEMPLATE: elapsed_real_time()
FUNCTION: elapsed_run_time
TEMPLATE: elapsed_run_time()
OPTION  : cauchysum
FUNCTION: deftaylor
TEMPLATE: deftaylor(<f_1>(<x_1>), <expr_1>, <...>, <f_n>(<x_n>), <expr_n>)
OPTION  : maxtayorder
FUNCTION: niceindices
TEMPLATE: niceindices(<expr>)
OPTION  : niceindicespref
FUNCTION: nusum
TEMPLATE: nusum(<expr>, <x>, <i_0>, <i_1>)
FUNCTION: pade
TEMPLATE: pade(<taylor_series>, <numer_deg_bound>, <denom_deg_bound>)
OPTION  : powerdisp
FUNCTION: powerseries
TEMPLATE: powerseries(<expr>, <x>, <a>)
OPTION  : psexpand
FUNCTION: revert
TEMPLATE: revert(<expr>, <x>)
TEMPLATE: revert2(<expr>, <x>, <n>)
FUNCTION: taylor
TEMPLATE: taylor(<expr>, <x>, <a>, <n>)
TEMPLATE: taylor(<expr>, [<x_1>, <x_2>, <...>], <a>, <n>)
TEMPLATE: taylor(<expr>, [<x>, <a>, <n>, 'asymp])
TEMPLATE: taylor(<expr>, [<x_1>, <x_2>, <...>], [<a_1>, <a_2>, <...>], [<n_1>, <n_2>, <...>])
TEMPLATE: taylor(<expr>, [<x_1>, <a_1>, <n_1>], [<x_2>, <a_2>, <n_2>], <...>)
OPTION  : taylordepth
FUNCTION: taylorinfo
TEMPLATE: taylorinfo(<expr>)
FUNCTION: taylorp
TEMPLATE: taylorp(<expr>)
OPTION  : taylor_logexpand
OPTION  : taylor_order_coefficients
FUNCTION: taylor_simplifier
TEMPLATE: taylor_simplifier(<expr>)
OPTION  : taylor_truncate_polynomials
FUNCTION: taytorat
TEMPLATE: taytorat(<expr>)
FUNCTION: trunc
TEMPLATE: trunc(<expr>)
FUNCTION: unsum
TEMPLATE: unsum(<f>, <n>)
OPTION  : verbose
FUNCTION: intopois
TEMPLATE: intopois(<a>)
FUNCTION: outofpois
TEMPLATE: outofpois(<a>)
FUNCTION: poisdiff
TEMPLATE: poisdiff(<a>, <b>)
FUNCTION: poisexpt
TEMPLATE: poisexpt(<a>, <b>)
FUNCTION: poisint
TEMPLATE: poisint(<a>, <b>)
OPTION  : poislim
FUNCTION: poismap
TEMPLATE: poismap(<series>, <sinfn>, <cosfn>)
FUNCTION: poisplus
TEMPLATE: poisplus(<a>, <b>)
FUNCTION: poissimp
TEMPLATE: poissimp(<a>)
OPTION  : poisson
FUNCTION: poissubst
TEMPLATE: poissubst(<a>, <b>, <c>)
FUNCTION: poistimes
TEMPLATE: poistimes(<a>, <b>)
FUNCTION: poistrim
TEMPLATE: poistrim()
FUNCTION: printpois
TEMPLATE: printpois(<a>)
OPTION  : epsilon_lp
FUNCTION: linear_program
TEMPLATE: linear_program(<A>, <b>, <c>)
FUNCTION: maximize_lp
TEMPLATE: maximize_lp(<obj>, <cond>, [<pos>])
FUNCTION: minimize_lp
TEMPLATE: minimize_lp(<obj>, <cond>, [<pos>])
OPTION  : nonegative_lp
OPTION  : askexp
FUNCTION: askinteger
TEMPLATE: askinteger(<expr>, integer)
TEMPLATE: askinteger(<expr>)
TEMPLATE: askinteger(<expr>, even)
TEMPLATE: askinteger(<expr>, odd)
FUNCTION: asksign
TEMPLATE: asksign(<expr>)
FUNCTION: demoivre
TEMPLATE: demoivre(<expr>)
OPTION  : distribute_over
OPTION  : domain
FUNCTION: expand
TEMPLATE: expand(<expr>)
TEMPLATE: expand(<expr>, <p>, <n>)
FUNCTION: expandwrt
TEMPLATE: expandwrt(<expr>, <x_1>, <...>, <x_n>)
OPTION  : expandwrt_denom
FUNCTION: expandwrt_factored
TEMPLATE: expandwrt_factored(<expr>, <x_1>, <...>, <x_n>)
OPTION  : expon
FUNCTION: exponentialize
TEMPLATE: exponentialize(<expr>)
OPTION  : expop
OPTION  : factlim
FUNCTION: intosum
TEMPLATE: intosum(<expr>)
OPTION  : lassociative
OPTION  : linear
OPTION  : mainvar
OPTION  : maxapplydepth
OPTION  : maxapplyheight
OPTION  : maxnegex
OPTION  : maxposex
OPTION  : multiplicative
OPTION  : negdistrib
OPTION  : negsumdispflag
OPTION  : noeval
OPTION  : noun
OPTION  : noundisp
OPTION  : nouns
OPTION  : numer
FUNCTION: numerval
TEMPLATE: numerval(<x_1>, <expr_1>, <...>, <var_n>, <expr_n>)
OPTION  : opproperties
OPTION  : opsubst
OPTION  : outative
OPTION  : posfun
OPTION  : pred
FUNCTION: radcan
TEMPLATE: radcan(<expr>)
OPTION  : radexpand
OPTION  : radsubstflag
OPTION  : rassociative
FUNCTION: scsimp
TEMPLATE: scsimp(<expr>, <rule_1>, <...>, <rule_n>)
OPTION  : simp
OPTION  : simpsum
FUNCTION: sumcontract
TEMPLATE: sumcontract(<expr>)
OPTION  : sumexpand
OPTION  : sumsplitfact
OPTION  : symmetric
FUNCTION: unknown
TEMPLATE: unknown(<expr>)
FUNCTION: facsum
TEMPLATE: facsum(<expr>, <arg_1>, <...>, <arg_n>)
OPTION  : nextlayerfactor
OPTION  : facsum_combine
FUNCTION: factorfacsum
TEMPLATE: factorfacsum(<expr>, <arg_1>, <...>, <arg_n>)
FUNCTION: collectterms
TEMPLATE: collectterms(<expr>, <arg_1>, <...>, <arg_n>)
FUNCTION: rempart
TEMPLATE: rempart(<expr>, <n>)
FUNCTION: wronskian
TEMPLATE: wronskian([<f_1>, <...>, <f_n>], <x>)
FUNCTION: tracematrix
TEMPLATE: tracematrix(<M>)
FUNCTION: rational
TEMPLATE: rational(<z>)
FUNCTION: logand
TEMPLATE: logand(<x>,<y>)
FUNCTION: logor
TEMPLATE: logor(<x>,<y>)
FUNCTION: logxor
TEMPLATE: logxor(<x>,<y>)
FUNCTION: nonzeroandfreeof
TEMPLATE: nonzeroandfreeof(<x>, <expr>)
FUNCTION: linear
TEMPLATE: linear(<expr>, <x>)
FUNCTION: gcdivide
TEMPLATE: gcdivide(<p>, <q>)
FUNCTION: arithmetic
TEMPLATE: arithmetic(<a>, <d>, <n>)
FUNCTION: geometric
TEMPLATE: geometric(<a>, <r>, <n>)
FUNCTION: harmonic
TEMPLATE: harmonic(<a>, <b>, <c>, <n>)
FUNCTION: arithsum
TEMPLATE: arithsum(<a>, <d>, <n>)
FUNCTION: geosum
TEMPLATE: geosum(<a>, <r>, <n>)
FUNCTION: gaussprob
TEMPLATE: gaussprob(<x>)
FUNCTION: gd
TEMPLATE: gd(<x>)
FUNCTION: agd
TEMPLATE: agd(<x>)
FUNCTION: vers
TEMPLATE: vers(<x>)
FUNCTION: covers
TEMPLATE: covers(<x>)
FUNCTION: exsec
TEMPLATE: exsec(<x>)
FUNCTION: hav
TEMPLATE: hav(<x>)
FUNCTION: combination
TEMPLATE: combination(<n>, <r>)
FUNCTION: permutation
TEMPLATE: permutation(<n>, <r>)
FUNCTION: reduce_consts
TEMPLATE: reduce_consts(<expr>)
FUNCTION: gcfac
TEMPLATE: gcfac(<expr>)
FUNCTION: sqrtdenest
TEMPLATE: sqrtdenest(<expr>)
FUNCTION: reduce_order
TEMPLATE: reduce_order(<rec>, <sol>, <var>)
OPTION  : simplify_products
FUNCTION: simplify_sum
TEMPLATE: simplify_sum(<expr>)
FUNCTION: solve_rec
TEMPLATE: solve_rec(<eqn>, <var>, [<init>])
FUNCTION: solve_rec_rat
TEMPLATE: solve_rec_rat(<eqn>, <var>, [<init>])
OPTION  : product_use_gamma
FUNCTION: summand_to_rec
TEMPLATE: summand_to_rec(<summand>, <k>, <n>)
TEMPLATE: summand_to_rec(<summand>, [<k>, <lo>, <hi>], <n>)
FUNCTION: bessel_j
TEMPLATE: bessel_j(<v>, <z>)
FUNCTION: bessel_y
TEMPLATE: bessel_y(<v>, <z>)
FUNCTION: bessel_i
TEMPLATE: bessel_i(<v>, <z>)
FUNCTION: bessel_k
TEMPLATE: bessel_k(<v>, <z>)
FUNCTION: hankel_1
TEMPLATE: hankel_1(<v>, <z>)
FUNCTION: hankel_2
TEMPLATE: hankel_2(<v>, <z>)
OPTION  : besselexpand
FUNCTION: scaled_bessel_i
TEMPLATE: scaled_bessel_i(<v>, <z>) 
FUNCTION: scaled_bessel_i0
TEMPLATE: scaled_bessel_i0(<z>) 
FUNCTION: scaled_bessel_i1
TEMPLATE: scaled_bessel_i1(<z>) 
FUNCTION: %s
TEMPLATE: %s[<u>,<v>] (<z>) 
FUNCTION: airy_ai
TEMPLATE: airy_ai(<x>)
FUNCTION: airy_dai
TEMPLATE: airy_dai(<x>)
FUNCTION: airy_bi
TEMPLATE: airy_bi(<x>)
FUNCTION: airy_dbi
TEMPLATE: airy_dbi(<x>)
FUNCTION: gamma
TEMPLATE: gamma(<z>)
FUNCTION: log_gamma
TEMPLATE: log_gamma(<z>)
FUNCTION: gamma_incomplete
TEMPLATE: gamma_incomplete(<a>, <z>)
FUNCTION: gamma_incomplete_regularized
TEMPLATE: gamma_incomplete_regularized(<a>,<z>)
FUNCTION: gamma_incomplete_generalized
TEMPLATE: gamma_incomplete_generalized(<a>,<z1>,<z1> )
OPTION  : gammalim
FUNCTION: makegamma
TEMPLATE: makegamma(<expr>)
FUNCTION: beta
TEMPLATE: beta(<a>, <b>)
FUNCTION: beta_incomplete
TEMPLATE: beta_incomplete(<a>, <b>, <z>)
FUNCTION: beta_incomplete_regularized
TEMPLATE: beta_incomplete_regularized(<a>, <b>, <z>)
FUNCTION: beta_incomplete_generalized
TEMPLATE: beta_incomplete_generalized(<a>, <b>, <z1>, <z2>)
OPTION  : beta_expand
OPTION  : beta_args_sum_to_integer
FUNCTION: psi
TEMPLATE: psi[<n>](<x>)
OPTION  : maxpsiposint
OPTION  : maxpsinegint
OPTION  : maxpsifracnum
OPTION  : maxpsifracdenom
FUNCTION: makefact
TEMPLATE: makefact(<expr>)
FUNCTION: numfactor
TEMPLATE: numfactor(<expr>)
FUNCTION: expintegral_e1
TEMPLATE: expintegral_e1(<z>)
FUNCTION: expintegral_ei
TEMPLATE: expintegral_ei(<z>)
FUNCTION: expintegral_li
TEMPLATE: expintegral_li(<z>)
FUNCTION: expintegral_e
TEMPLATE: expintegral_e(<n>,<z>)
FUNCTION: expintegral_si
TEMPLATE: expintegral_si(<z>)
FUNCTION: expintegral_ci
TEMPLATE: expintegral_ci(<z>)
FUNCTION: expintegral_shi
TEMPLATE: expintegral_shi(<z>)
FUNCTION: expintegral_chi
TEMPLATE: expintegral_chi(<z>)
OPTION  : expintrep
OPTION  : expintexpand
FUNCTION: erf
TEMPLATE: erf(<z>)
FUNCTION: erfc
TEMPLATE: erfc(<z>)
FUNCTION: erfi
TEMPLATE: erfi(<z>)
FUNCTION: erf_generalized
TEMPLATE: erf_generalized(<z1>,<z2>)
FUNCTION: fresnel_c
TEMPLATE: fresnel_c(<z>)
FUNCTION: fresnel_s
TEMPLATE: fresnel_s(<z>)
OPTION  : erf_representation
OPTION  : hypergeometric_representation
FUNCTION: struve_h
TEMPLATE: struve_h(<v>, <z>)
FUNCTION: struve_l
TEMPLATE: struve_l(<v>, <z>)
FUNCTION: %m
TEMPLATE: %m[<k>,<u>] (<z>) 
FUNCTION: %w
TEMPLATE: %w[<k>,<u>] (<z>) 
FUNCTION: %f
TEMPLATE: %f[<p>,<q>] (<[a],[b],z>) 
FUNCTION: hypergeometric
TEMPLATE: hypergeometric([<a1>, <...>, <ap>],[<b1>, <...> ,<bq>], x)
FUNCTION: parabolic_cylinder_d
TEMPLATE: parabolic_cylinder_d(<v>, <z>) 
FUNCTION: specint
TEMPLATE: specint(exp(- s*<t>) * <expr>, <t>)
FUNCTION: hgfred
TEMPLATE: hgfred(<a>, <b>, <t>)
FUNCTION: lambert_w
TEMPLATE: lambert_w(<z>)
FUNCTION: nzeta
TEMPLATE: nzeta(<z>)
FUNCTION: nzetar
TEMPLATE: nzetar(<z>)
FUNCTION: nzetai
TEMPLATE: nzetai(<z>)
FUNCTION: inference_result
TEMPLATE: inference_result(<title>, <values>, <numbers>)
FUNCTION: inferencep
TEMPLATE: inferencep(<obj>)
FUNCTION: items_inference
TEMPLATE: items_inference(<obj>)
FUNCTION: take_inference
TEMPLATE: take_inference(<n>, <obj>)
TEMPLATE: take_inference(<name>, <obj>)
TEMPLATE: take_inference(<list>, <obj>)
OPTION  : stats_numer
FUNCTION: test_mean
TEMPLATE: test_mean(<x>)
TEMPLATE: test_mean(<x>, <options>, <...>)
FUNCTION: test_means_difference
TEMPLATE: test_means_difference(<x1>, <x2>)
TEMPLATE: test_means_difference(<x1>, <x2>, <options>, <...>)
FUNCTION: test_variance
TEMPLATE: test_variance(<x>)
TEMPLATE: test_variance(<x>, <options>, <...>)
FUNCTION: test_variance_ratio
TEMPLATE: test_variance_ratio(<x1>, <x2>)
TEMPLATE: test_variance_ratio(<x1>, <x2>, <options>, <...>)
FUNCTION: test_proportion
TEMPLATE: test_proportion(<x>, <n>)
TEMPLATE: test_proportion(<x>, <n>, <options>, <...>)
FUNCTION: test_proportions_difference
TEMPLATE: test_proportions_difference(<x1>, <n1>, <x2>, <n2>)
TEMPLATE: test_proportions_difference(<x1>, <n1>, <x2>, <n2>, <options>, <...>)
FUNCTION: test_sign
TEMPLATE: test_sign(<x>)
TEMPLATE: test_sign(<x>, <options>, <...>)
FUNCTION: test_signed_rank
TEMPLATE: test_signed_rank(<x>)
TEMPLATE: test_signed_rank(<x>, <options>, <...>)
FUNCTION: test_rank_sum
TEMPLATE: test_rank_sum(<x1>, <x2>)
TEMPLATE: test_rank_sum(<x1>, <x2>, <option>)
FUNCTION: test_normality
TEMPLATE: test_normality(<x>)
FUNCTION: simple_linear_regression
TEMPLATE: simple_linear_regression(<x>)
TEMPLATE: simple_linear_regression(<x>, <option>)
FUNCTION: pdf_signed_rank
TEMPLATE: pdf_signed_rank(<x>, <n>)
FUNCTION: cdf_signed_rank
TEMPLATE: cdf_signed_rank(<x>, <n>)
FUNCTION: pdf_rank_sum
TEMPLATE: pdf_rank_sum(<x>, <n>, <m>)
FUNCTION: cdf_rank_sum
TEMPLATE: cdf_rank_sum(<x>, <n>, <m>)
FUNCTION: stirling
TEMPLATE: stirling(<z>,<n>)
TEMPLATE: stirling(<z>,<n>,<pred>)
FUNCTION: close
TEMPLATE: close(<stream>) 
FUNCTION: flength
TEMPLATE: flength(<stream>)
FUNCTION: fposition
TEMPLATE: fposition(<stream>)
TEMPLATE: fposition(<stream>, <pos>)
FUNCTION: freshline
TEMPLATE: freshline() 
TEMPLATE: freshline(<stream>) 
FUNCTION: newline
TEMPLATE: newline() 
TEMPLATE: newline(<stream>) 
FUNCTION: opena
TEMPLATE: opena(<file>) 
FUNCTION: openr
TEMPLATE: openr(<file>) 
FUNCTION: openw
TEMPLATE: openw(<file>) 
FUNCTION: printf
TEMPLATE: printf(<dest>, <string>)
TEMPLATE: printf(<dest>, <string>, <expr_1>, <...>, <expr_n>)
FUNCTION: readline
TEMPLATE: readline(<stream>) 
FUNCTION: sprint
TEMPLATE: sprint(<expr_1>, <...>, <expr_n>)
FUNCTION: alphacharp
TEMPLATE: alphacharp(<char>)    
FUNCTION: alphanumericp
TEMPLATE: alphanumericp(<char>) 
FUNCTION: ascii
TEMPLATE: ascii(<int>) 
FUNCTION: cequal
TEMPLATE: cequal(<char_1>, <char_2>)          
FUNCTION: cequalignore
TEMPLATE: cequalignore(<char_1>, <char_2>)    
FUNCTION: cgreaterp
TEMPLATE: cgreaterp(<char_1>, <char_2>)       
FUNCTION: cgreaterpignore
TEMPLATE: cgreaterpignore(<char_1>, <char_2>)
FUNCTION: charp
TEMPLATE: charp(<obj>) 
FUNCTION: cint
TEMPLATE: cint(<char>) 
FUNCTION: clessp
TEMPLATE: clessp(<char_1>, <char_2>)
FUNCTION: clesspignore
TEMPLATE: clesspignore(<char_1>, <char_2>)
FUNCTION: constituent
TEMPLATE: constituent(<char>)   
FUNCTION: cunlisp
TEMPLATE: cunlisp(<lisp_char>) 
FUNCTION: digitcharp
TEMPLATE: digitcharp(<char>)    
FUNCTION: lcharp
TEMPLATE: lcharp(<obj>) 
FUNCTION: lowercasep
TEMPLATE: lowercasep(<char>)    
OPTION  : newline
OPTION  : space
OPTION  : tab
FUNCTION: uppercasep
TEMPLATE: uppercasep(<char>)    
FUNCTION: stringp
TEMPLATE: stringp(<obj>) 
FUNCTION: charat
TEMPLATE: charat(<string>, <n>) 
FUNCTION: charlist
TEMPLATE: charlist(<string>) 
FUNCTION: eval_string
TEMPLATE: eval_string(<str>)
FUNCTION: parse_string
TEMPLATE: parse_string(<str>)
FUNCTION: scopy
TEMPLATE: scopy(<string>) 
FUNCTION: sdowncase
TEMPLATE: sdowncase(<string>) 
TEMPLATE: sdowncase(<string>, <start>) 
TEMPLATE: sdowncase(<string>, <start>, <end>) 
FUNCTION: sequal
TEMPLATE: sequal(<string_1>, <string_2>) 
FUNCTION: sequalignore
TEMPLATE: sequalignore(<string_1>, <string_2>)
FUNCTION: sexplode
TEMPLATE: sexplode(<string>)
FUNCTION: simplode
TEMPLATE: simplode(<list>)  
TEMPLATE: simplode(<list>, <delim>)  
FUNCTION: sinsert
TEMPLATE: sinsert(<seq>, <string>, <pos>)  
FUNCTION: sinvertcase
TEMPLATE: sinvertcase(<string>)  
TEMPLATE: sinvertcase(<string>, <start>)  
TEMPLATE: sinvertcase(<string>, <start>, <end>)  
FUNCTION: slength
TEMPLATE: slength(<string>) 
FUNCTION: smake
TEMPLATE: smake(<num>, <char>) 
FUNCTION: smismatch
TEMPLATE: smismatch(<string_1>, <string_2>) 
TEMPLATE: smismatch(<string_1>, <string_2>, <test>) 
FUNCTION: split
TEMPLATE: split(<string>)  
TEMPLATE: split(<string>, <delim>)  
TEMPLATE: split(<string>, <delim>, <multiple>)  
FUNCTION: sposition
TEMPLATE: sposition(<char>, <string>) 
FUNCTION: sremove
TEMPLATE: sremove(<seq>, <string>)  
TEMPLATE: sremove(<seq>, <string>, <test>)  
TEMPLATE: sremove(<seq>, <string>, <test>, <start>)  
TEMPLATE: sremove(<seq>, <string>, <test>, <start>, <end>)  
FUNCTION: sremovefirst
TEMPLATE: sremovefirst(<seq>, <string>)  
TEMPLATE: sremovefirst(<seq>, <string>, <test>)  
TEMPLATE: sremovefirst(<seq>, <string>, <test>, <start>)  
TEMPLATE: sremovefirst(<seq>, <string>, <test>, <start>, <end>)  
FUNCTION: sreverse
TEMPLATE: sreverse(<string>) 
FUNCTION: ssearch
TEMPLATE: ssearch(<seq>, <string>)  
TEMPLATE: ssearch(<seq>, <string>, <test>)  
TEMPLATE: ssearch(<seq>, <string>, <test>, <start>)  
TEMPLATE: ssearch(<seq>, <string>, <test>, <start>, <end>)
FUNCTION: ssort
TEMPLATE: ssort(<string>) 
TEMPLATE: ssort(<string>, <test>) 
FUNCTION: ssubst
TEMPLATE: ssubst(<new>, <old>, <string>) 
TEMPLATE: ssubst(<new>, <old>, <string>, <test>) 
TEMPLATE: ssubst(<new>, <old>, <string>, <test>, <start>) 
TEMPLATE: ssubst(<new>, <old>, <string>, <test>, <start>, <end>) 
FUNCTION: ssubstfirst
TEMPLATE: ssubstfirst(<new>, <old>, <string>) 
TEMPLATE: ssubstfirst(<new>, <old>, <string>, <test>) 
TEMPLATE: ssubstfirst(<new>, <old>, <string>, <test>, <start>) 
TEMPLATE: ssubstfirst(<new>, <old>, <string>, <test>, <start>, <end>) 
FUNCTION: strim
TEMPLATE: strim(<seq>,<string>) 
FUNCTION: striml
TEMPLATE: striml(<seq>, <string>) 
FUNCTION: strimr
TEMPLATE: strimr(<seq>, <string>) 
FUNCTION: substring
TEMPLATE: substring(<string>, <start>)
TEMPLATE: substring(<string>, <start>, <end>) 
FUNCTION: supcase
TEMPLATE: supcase(<string>) 
TEMPLATE: supcase(<string>, <start>) 
TEMPLATE: supcase(<string>, <start>, <end>) 
FUNCTION: tokens
TEMPLATE: tokens(<string>) 
TEMPLATE: tokens(<string>, <test>) 
FUNCTION: comp2pui
TEMPLATE: comp2pui(<n>, <L>)
FUNCTION: ele2pui
TEMPLATE: ele2pui(<m>, <L>)
FUNCTION: ele2comp
TEMPLATE: ele2comp(<m>, <L>)
FUNCTION: elem
TEMPLATE: elem(<ele>, <sym>, <lvar>)
FUNCTION: mon2schur
TEMPLATE: mon2schur(<L>)
FUNCTION: multi_elem
TEMPLATE: multi_elem(<l_elem>, <multi_pc>, <l_var>)
FUNCTION: pui
TEMPLATE: pui(<L>, <sym>, <lvar>)
FUNCTION: pui2comp
TEMPLATE: pui2comp(<n>, <lpui>)
FUNCTION: pui2ele
TEMPLATE: pui2ele(<n>, <lpui>)
FUNCTION: puireduc
TEMPLATE: puireduc(<n>, <lpui>)
FUNCTION: schur2comp
TEMPLATE: schur2comp(<P>, <l_var>)
FUNCTION: cont2part
TEMPLATE: cont2part(<pc>, <lvar>)
FUNCTION: contract
TEMPLATE: contract(<psym>, <lvar>)
FUNCTION: explose
TEMPLATE: explose(<pc>, <lvar>)
FUNCTION: part2cont
TEMPLATE: part2cont(<ppart>, <lvar>)
FUNCTION: partpol
TEMPLATE: partpol(<psym>, <lvar>)
FUNCTION: tcontract
TEMPLATE: tcontract(<pol>, <lvar>)
FUNCTION: tpartpol
TEMPLATE: tpartpol(<pol>, <lvar>)
FUNCTION: direct
TEMPLATE: direct([<p_1>, <...>, <p_n>], <y>, <f>, [<lvar_1>, <...>, <lvar_n>])
FUNCTION: multi_orbit
TEMPLATE: multi_orbit(<P>, [<lvar_1>, <lvar_2>,<...>, <lvar_p>])
FUNCTION: multsym
TEMPLATE: multsym(<ppart_1>, <ppart_2>, <n>)
FUNCTION: orbit
TEMPLATE: orbit(<P>, <lvar>)
FUNCTION: pui_direct
TEMPLATE: pui_direct(<orbite>, [<lvar_1>, <...>, <lvar_n>], [<d_1>, <d_2>, <...>, <d_n>])
FUNCTION: kostka
TEMPLATE: kostka(<part_1>, <part_2>)
FUNCTION: lgtreillis
TEMPLATE: lgtreillis(<n>, <m>)
FUNCTION: ltreillis
TEMPLATE: ltreillis(<n>, <m>)
FUNCTION: treillis
TEMPLATE: treillis(<n>)
FUNCTION: treinat
TEMPLATE: treinat(<part>)
FUNCTION: ele2polynome
TEMPLATE: ele2polynome(<L>, <z>)
FUNCTION: polynome2ele
TEMPLATE: polynome2ele(<P>, <x>)
FUNCTION: prodrac
TEMPLATE: prodrac(<L>, <k>)
FUNCTION: pui2polynome
TEMPLATE: pui2polynome(<x>, <lpui>)
FUNCTION: somrac
TEMPLATE: somrac(<L>, <k>)
FUNCTION: resolvante
TEMPLATE: resolvante(<P>, <x>, <f>, [<x_1>,<...>, <x_d>]) 
FUNCTION: resolvante_alternee1
TEMPLATE: resolvante_alternee1(<P>, <x>)
FUNCTION: resolvante_bipartite
TEMPLATE: resolvante_bipartite(<P>, <x>)
FUNCTION: resolvante_diedrale
TEMPLATE: resolvante_diedrale(<P>, <x>)
FUNCTION: resolvante_klein
TEMPLATE: resolvante_klein(<P>, <x>)
FUNCTION: resolvante_klein3
TEMPLATE: resolvante_klein3(<P>, <x>)
FUNCTION: resolvante_produit_sym
TEMPLATE: resolvante_produit_sym(<P>, <x>)
FUNCTION: resolvante_unitaire
TEMPLATE: resolvante_unitaire(<P>, <Q>, <x>)
FUNCTION: resolvante_vierer
TEMPLATE: resolvante_vierer(<P>, <x>)
FUNCTION: multinomial
TEMPLATE: multinomial(<r>, <part>)
FUNCTION: permut
TEMPLATE: permut(<L>)
OPTION  : %piargs
OPTION  : %iargs
FUNCTION: acos
TEMPLATE: acos(<x>)
FUNCTION: acosh
TEMPLATE: acosh(<x>)
FUNCTION: acot
TEMPLATE: acot(<x>)
FUNCTION: acoth
TEMPLATE: acoth(<x>)
FUNCTION: acsc
TEMPLATE: acsc(<x>)
FUNCTION: acsch
TEMPLATE: acsch(<x>)
FUNCTION: asec
TEMPLATE: asec(<x>)
FUNCTION: asech
TEMPLATE: asech(<x>)
FUNCTION: asin
TEMPLATE: asin(<x>)
FUNCTION: asinh
TEMPLATE: asinh(<x>)
FUNCTION: atan
TEMPLATE: atan(<x>)
FUNCTION: atan2
TEMPLATE: atan2(<y>, <x>)
FUNCTION: atanh
TEMPLATE: atanh(<x>)
OPTION  : atrig1
FUNCTION: cos
TEMPLATE: cos(<x>)
FUNCTION: cosh
TEMPLATE: cosh(<x>)
FUNCTION: cot
TEMPLATE: cot(<x>)
FUNCTION: coth
TEMPLATE: coth(<x>)
FUNCTION: csc
TEMPLATE: csc(<x>)
FUNCTION: csch
TEMPLATE: csch(<x>)
OPTION  : halfangles
OPTION  : ntrig
FUNCTION: sec
TEMPLATE: sec(<x>)
FUNCTION: sech
TEMPLATE: sech(<x>)
FUNCTION: sin
TEMPLATE: sin(<x>)
FUNCTION: sinh
TEMPLATE: sinh(<x>)
FUNCTION: tan
TEMPLATE: tan(<x>)
FUNCTION: tanh
TEMPLATE: tanh(<x>)
FUNCTION: trigexpand
TEMPLATE: trigexpand(<expr>)
OPTION  : trigexpandplus
OPTION  : trigexpandtimes
OPTION  : triginverses
FUNCTION: trigreduce
TEMPLATE: trigreduce(<expr>, <x>)
TEMPLATE: trigreduce(<expr>)
OPTION  : trigsign
FUNCTION: trigsimp
TEMPLATE: trigsimp(<expr>)
FUNCTION: trigrat
TEMPLATE: trigrat(<expr>)
FUNCTION: setunits
TEMPLATE: setunits(<list>)
FUNCTION: uforget
TEMPLATE: uforget(<list>)
FUNCTION: convert
TEMPLATE: convert(<expr>, <list>)
OPTION  : usersetunits
FUNCTION: metricexpandall
TEMPLATE: metricexpandall(<x>)
OPTION  : %unitexpand
FUNCTION: AntiDifference
TEMPLATE: AntiDifference(<F_k>, <k>)
FUNCTION: Gosper
TEMPLATE: Gosper(<F_k>, <k>)
FUNCTION: GosperSum
TEMPLATE: GosperSum(<F_k>, <k>, <a>, <b>)
FUNCTION: parGosper
TEMPLATE: parGosper(<F_{n,k}>, <k>, <n>, <d>)
FUNCTION: parGosper
TEMPLATE: parGosper(<F_(n,k)>, <k>, <n>, <d>)
FUNCTION: Zeilberger
TEMPLATE: Zeilberger(<F_{n,k}>, <k>, <n>)
FUNCTION: Zeilberger
TEMPLATE: Zeilberger(<F_(n,k)>, <k>, <n>)
OPTION  : MAX_ORD
OPTION  : simplified_output
OPTION  : linear_solver
OPTION  : warnings
OPTION  : Gosper_in_Zeilberger
OPTION  : trivial_solutions
OPTION  : mod_test
OPTION  : modular_linear_solver
OPTION  : ev_point
OPTION  : mod_big_prime
OPTION  : mod_threshold
FUNCTION: days360
TEMPLATE: days360(<year1>,<month1>,<day1>,<year2>,<month2>,<day2>)
FUNCTION: fv
TEMPLATE: fv(<rate>,<PV>,<num>)
FUNCTION: pv
TEMPLATE: pv(<rate>,<FV>,<num>)
FUNCTION: graph_flow
TEMPLATE: graph_flow(<val>)
FUNCTION: annuity_pv
TEMPLATE: annuity_pv(<rate>,<PV>,<num>)
FUNCTION: annuity_fv
TEMPLATE: annuity_fv(<rate>,<FV>,<num>)
FUNCTION: geo_annuity_pv
TEMPLATE: geo_annuity_pv(<rate>,<growing_rate>,<PV>,<num>)
FUNCTION: geo_annuity_fv
TEMPLATE: geo_annuity_fv(<rate>,<growing_rate>,<FV>,<num>)
FUNCTION: amortization
TEMPLATE: amortization(<rate>,<ammount>,<num>)
FUNCTION: arit_amortization
TEMPLATE: arit_amortization(<rate>,<increment>,<ammount>,<num>)
FUNCTION: geo_amortization
TEMPLATE: geo_amortization(<rate>,<growing_rate>,<ammount>,<num>)
FUNCTION: saving
TEMPLATE: saving(<rate>,<ammount>,<num>)
FUNCTION: npv
TEMPLATE: npv(<rate>,<val>)
FUNCTION: irr
TEMPLATE: irr(<val>,<IO>)
FUNCTION: benefit_cost
TEMPLATE: benefit_cost(<rate>,<input>,<output>)
FUNCTION: sierpinskiale
TEMPLATE: sierpinskiale(<n>)
FUNCTION: treefale
TEMPLATE: treefale(<n>)
FUNCTION: fernfale
TEMPLATE: fernfale(<n>)
FUNCTION: mandelbrot_set
TEMPLATE: mandelbrot_set(<x>, <y>)
FUNCTION: julia_set
TEMPLATE: julia_set(<x>, <y>)
OPTION  : julia_parameter
FUNCTION: julia_sin
TEMPLATE: julia_sin(<x>, <y>)
FUNCTION: snowmap
TEMPLATE: snowmap(<ent>, <nn>)
FUNCTION: hilbertmap
TEMPLATE: hilbertmap(<nn>)
FUNCTION: sierpinskimap
TEMPLATE: sierpinskimap(<nn>)
OPTION  : extra_integration_methods
OPTION  : extra_definite_integration_methods
FUNCTION: intfugudu
TEMPLATE: intfugudu(<e>, <x>)
FUNCTION: signum_to_abs
TEMPLATE: signum_to_abs(<e>)
FUNCTION: convert_to_signum
TEMPLATE: convert_to_signum(<e>)
FUNCTION: complex_number_p
TEMPLATE: complex_number_p(<x>)
FUNCTION: compose_functions
TEMPLATE: compose_functions(<l>)
FUNCTION: dfloat
TEMPLATE: dfloat(<x>)
FUNCTION: elim
TEMPLATE: elim(<l>, <x>)
FUNCTION: elim_allbut
TEMPLATE: elim_allbut(<l>, <x>)
FUNCTION: eliminate_using
TEMPLATE: eliminate_using(<l>, <e>, <x>)
FUNCTION: fourier_elim
TEMPLATE: fourier_elim([<eq1>, <eq2>, <...>], [<var1>, <var>, <...>])
FUNCTION: isreal_p
TEMPLATE: isreal_p(<e>)
FUNCTION: new_variable
TEMPLATE: new_variable(<type>)
FUNCTION: parg
TEMPLATE: parg(<x>)
FUNCTION: real_imagpart_to_conjugate
TEMPLATE: real_imagpart_to_conjugate(<e>)
FUNCTION: rectform_log_if_constant
TEMPLATE: rectform_log_if_constant(<e>)
FUNCTION: simp_inequality
TEMPLATE: simp_inequality(<e>)
FUNCTION: standardize_inverse_trig
TEMPLATE: standardize_inverse_trig(<e>)
FUNCTION: subst_parallel
TEMPLATE: subst_parallel(<l>, <e>)
FUNCTION: to_poly
TEMPLATE: to_poly(<e>, <l>)
FUNCTION: to_poly_solve
TEMPLATE: to_poly_solve(<e>, <l>, <[options]>)