OutputForm

outform.spad line 190 [edit on github]

This domain is used to create and manipulate mathematical expressions for output. It is intended to provide an insulating layer between the expression rendering software (e.g. TeX, or Script) and the output coercions in the various domains.

*: (%, %) -> %

f * g creates the equivalent infix form.

+: (%, %) -> %

f + g creates the equivalent infix form.

-: % -> %

- f creates the equivalent prefix form.

-: (%, %) -> %

f - g creates the equivalent infix form.

/: (%, %) -> %

f / g creates the equivalent infix form.

<=: (%, %) -> %

f <= g creates the equivalent infix form.

<: (%, %) -> %

f < g creates the equivalent infix form.

=: (%, %) -> %

f = g creates the equivalent infix form.

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> %

f >= g creates the equivalent infix form.

>: (%, %) -> %

f > g creates the equivalent infix form.

^: (%, %) -> %

f ^ g creates the equivalent infix form.

~=: (%, %) -> %

f ~= g creates the equivalent infix form.

~=: (%, %) -> Boolean

from BasicType

and: (%, %) -> %

f and g creates the equivalent infix form.

assign: (%, %) -> %

assign(f, g) creates a form for the assignment f := g.

binomial: (%, %) -> %

binomial(n, m) creates a form for the binomial coefficient of n and m.

blankSeparate: List % -> %

blankSeparate(l) creates the form separating the elements of l by blanks.

box: % -> %

box(f) encloses f in a box.

brace: % -> %

brace(f) creates the form enclosing f in braces (curly brackets).

brace: List % -> %

brace(lf) creates the form separating the elements of lf by commas and encloses the result in curly brackets.

bracket: % -> %

bracket(f) creates the form enclosing f in square brackets.

bracket: List % -> %

bracket(lf) creates the form separating the elements of lf by commas and encloses the result in square brackets.

center: % -> %

center(f) centers form f in total space.

center: (%, Integer) -> %

center(f, n) centers form f within space of width n.

coerce: % -> OutputForm

from CoercibleTo OutputForm

commaSeparate: List % -> %

commaSeparate(l) creates the form separating the elements of l by commas.

convert: % -> InputForm

from ConvertibleTo InputForm

differentiate: (%, NonNegativeInteger) -> %

differentiate(f, n) creates a form for the nth derivative of f, e.g. f', f'', f''', "f super iv“.

dot: % -> %

dot(f) creates the form with one dot overhead.

dot: (%, NonNegativeInteger) -> %

dot(f, n) creates the form f with n dots overhead.

elt: (%, List %) -> %

elt(op, l) creates a form for application of op to list of arguments l.

empty: () -> %

empty() creates an empty form.

exquo: (%, %) -> %

exquo(f, g) creates the equivalent infix form.

hconcat: (%, %) -> %

hconcat(f, g) horizontally concatenate forms f and g.

hconcat: List % -> %

hconcat(u) horizontally concatenates all forms in list u.

hspace: Integer -> %

hspace(n) creates white space of width n.

infix?: % -> Boolean

infix?(op) returns true if op is an infix operator, and false otherwise.

infix: (%, %, %) -> %

infix(op, a, b) creates a form which prints as: a op b.

infix: (%, List %) -> %

infix(f, l) creates a form depicting the n-ary application of infix operation f to a tuple of arguments l.

int: % -> %

int(expr) creates the form prefixing expr with an integral sign.

int: (%, %) -> %

int(expr, lowerlimit) creates the form prefixing expr by an integral sign with a lowerlimit.

int: (%, %, %) -> %

int(expr, lowerlimit, upperlimit) creates the form prefixing expr by an integral sign with both a lowerlimit and upperlimit.

label: (%, %) -> %

label(n, f) gives form f an equation label n.

latex: % -> String

from SetCategory

left: % -> %

left(f) left-justifies form f in total space.

left: (%, Integer) -> %

left(f, n) left-justifies form f within space of width n.

matrix: List List % -> %

matrix(llf) makes llf (a list of lists of forms) into a form which displays as a matrix.

message: String -> %

message(s) creates an form with no string quotes from string s.

messagePrint: String -> Void

messagePrint(s) prints s without string quotes. Note: messagePrint(s) is equivalent to print message(s).

not: % -> %

not f creates the equivalent prefix form.

or: (%, %) -> %

f or g creates the equivalent infix form.

outputForm: Integer -> %

outputForm(n) creates a form for an integer.

outputForm: String -> %

outputForm(s) creates a form for a string.

outputForm: Symbol -> %

outputForm(s) creates a form for a symbol.

over: (%, %) -> %

over(f, g) creates a form for the vertical fraction of f over g.

overbar: % -> %

overbar(f) creates the form f with an overbar.

overlabel: (%, %) -> %

overlabel(x,f) creates the form f with "x overbar” over the top.

paren: % -> %

paren(f) creates the form enclosing f in parentheses.

paren: List % -> %

paren(lf) creates the form separating the elements of lf by commas and encloses the result in parentheses.

pile: List % -> %

pile(l) creates the form consisting of the elements of l which displays as a pile, i.e. the elements begin on a new line and are indented right to the same margin.

postfix: (%, %) -> %

postfix(op, a) creates a form which prints as: a op.

prefix: (%, List %) -> %

prefix(f, l) creates a form depicting the n-ary prefix application of f to a tuple of arguments given by list l.

presub: (%, %) -> %

presub(f, n) creates a form for f presubscripted by n.

presuper: (%, %) -> %

presuper(f, n) creates a form for f presuperscripted by n.

prime: % -> %

prime(f) creates the form f followed by a suffix prime (single quote).

prime: (%, NonNegativeInteger) -> %

prime(f, n) creates the form f followed by n primes.

print: % -> Void

print(u) prints the form u.

prod: % -> %

prod(expr) creates the form prefixing expr by a capital pi.

prod: (%, %) -> %

prod(expr, lowerlimit) creates the form prefixing expr by a capital pi with a lowerlimit.

prod: (%, %, %) -> %

prod(expr, lowerlimit, upperlimit) creates the form prefixing expr by a capital pi with both a lowerlimit and upperlimit.

quo: (%, %) -> %

f quo g creates the equivalent infix form.

quote: % -> %

quote(f) creates the form f with a prefix quote.

rarrow: (%, %) -> %

rarrow(f, g) creates a form for the mapping f -> g.

rem: (%, %) -> %

f rem g creates the equivalent infix form.

right: % -> %

right(f) right-justifies form f in total space.

right: (%, Integer) -> %

right(f, n) right-justifies form f within space of width n.

root: % -> %

root(f) creates a form for the square root of form f.

root: (%, %) -> %

root(f, n) creates a form for the nth root of form f.

rspace: (Integer, Integer) -> %

rspace(n, m) creates rectangular white space, n wide by m high.

scripts: (%, List %) -> %

scripts(f, l) where l is [sub, super, presuper, presub] creates a form for f with scripts on all 4 corners. If l has less than 4 elements corresponding scripts are absent.

SEGMENT: % -> %

SEGMENT(x) creates the prefix form: x...

SEGMENT: (%, %) -> %

SEGMENT(x, y) creates the infix form: x..y.

semicolonSeparate: List % -> %

semicolonSeparate(l) creates the form separating the elements of l by semicolons.

slash: (%, %) -> %

slash(f, g) creates a form for the horizontal fraction of f over g.

sub: (%, %) -> %

sub(f, n) creates a form for f subscripted by n.

sum: % -> %

sum(expr) creates the form prefixing expr by a capital sigma.

sum: (%, %) -> %

sum(expr, lowerlimit) creates the form prefixing expr by a capital sigma with a lowerlimit.

sum: (%, %, %) -> %

sum(expr, lowerlimit, upperlimit) creates the form prefixing expr by a capital sigma with both a lowerlimit and upperlimit.

super: (%, %) -> %

super(f, n) creates a form for f superscripted by n.

supersub: (%, List %) -> %

supersub(a, [sub1, super1, sub2, super2, ...]) creates a form with each subscript aligned under each superscript.

tensor: (%, %) -> %

tensor(a, b) creates a form for a tensor b

vconcat: (%, %) -> %

vconcat(f, g) vertically concatenates forms f and g.

vconcat: List % -> %

vconcat(u) vertically concatenates all forms in list u.

vspace: Integer -> %

vspace(n) creates white space of height n.

zag: (%, %) -> %

zag(f, g) creates a form for the continued fraction form for f over g.

BasicType

CoercibleTo OutputForm

ConvertibleTo InputForm

SetCategory