61.2.1 Template keywords

Keywords come in several classes: Algebraic, Sums, Products, Fractions, Complex, Bags, General, Targeting, Control, Subtemplate Aids, and Convenience.

A few remarks about keywords: A passive keyword does not transform the expression but treats it as a sum, fraction or whatever. The order of the pieces corresponds to the internal ordering; subtemplate usage may be awkward. See the documentation of coerce_bag for a description of the coercions used. Targeting templates are basically shorthand equivalents of structuring templates using subtemplates.

Example with simplification on subexpression:

(%i1) foo:x^2*sin(y)^4-2*x^2*sin(y)^2+x^4*cos(y)^4-2*x^4*cos(y)^2+x^4+x^2+1$
(%i2) trigsimp(foo);
                     4    2     4         4    2       4
(%o2)              (x  + x ) cos (y) - 2 x  cos (y) + x  + 1
(%i3) format(foo,%p(x),trigsimp);
                                4    4       2    4
(%o3)                     x  sin (y) + x  cos (y) + 1

The following examples illustrate the usage with ‘bags.’

(%i1) format([a=b,c=d,e=f],%equation);
(%o1) [a, c, e] = [b, d, f]
(%i2) format(%,%list);
(%o2) [a = b, c = d, e = f]
(%i3) m1:matrix([a^2+2*a+1=q,b^2+2*b+1=r], [c^2+2*c+1=s,d^2+2*d+1=t])$
(%i4) format(m1,%equation,%matrix[%noop,%list[%noop,%factor]]);
                   [  2             2           ]
                   [ a  + 2 a + 1  b  + 2 b + 1 ]   [ q  r ]
(%o4)              [                            ] = [      ]
                   [  2                     2   ]   [ s  t ]
                   [ c  + 2 c + 1    (d + 1)    ]

61.2.2 User defined templates

New templates can be defined by giving the template keyword the property formatter; the value should be a function (or lambda expression) of the expression to be formatted and any parameters for the template. For example, %rectform and %if could be defined as

put(%rectform,lambda([c],block([r:rectformlist(c)],
      format-piece(r[1]) +%I* format-piece(r[2]))),formatter)

put(%if, lambda([x,test],
      if test(x) then format-piece(x,1)
        else
          format-piece(x,2)),formatter)

Functions used for defining templates are the following.

function: %format_piece (piece,nth) ¶

lratsubst’s eqns into expression and the result is formatted at the next layer. Format a given piece of an expression, automatically accounting for subtemplates and the remaining template chain. A specific subtemplate, rather than the next one, can be selected by specifying nth.

function: %coerce_bag (op,expr) ¶

Attempts to coerce expr into an expression with op (one of =, #, <, <=, >, >=, [ or matrix) as the top-level operator. It coerces the expression by swapping operands between layers but only if adjacent layers are also lists, matrices or relations. This model assumes that a list of equations, for example, can be viewed as an equation whose sides are lists. Certain combinations, particularly those involving inequalities may not be meaningful, however, so some caution is advised.

61.2.3 Determining coefficients

We define the ‘algebras’ of polynomials, trigonometric sums and power series to be those expressions that can be cast into the following forms.

The variables v_i may be any atomic expression in the sense of ratvars. The shorthands operator(op) and match(predicate) may be used to specify all subexpressions having op as an operator, or that pass the predicate, respectively.

The coefficients c_i and s_i are general Maxima expressions. In principle they would be independent of the variables v_i, but in practice they may contain non-polynomial dependence (or non-trigonometric, in the trigonometric case). These non-polynomial cases would include expressions like (1 + x)n, where n is symbolic. Likewise, (xa)b is, in general, multivalued; unless a = 1 or b is a member of Z, or radexpand=all, it will not be interpreted as xab is a member of P. Furthermore, we extend the algebras to include lists, vectors, matrices and equations, by interpreting a list of polynomials, say, as a polynomial with lists as coefficients.

The exponents p_i in series are restricted to numbers, but the exponents c_j,i and multiples m_j,i for polynomials and trigonometric sums may be general expressions (excluding bags).

The following functions construct a list of the coefficients and ‘keys’, that is, the exponents or multiples. Note that these are sparse representations; no coefficients are zero.

coeffs(P,v1,...) → [[%poly,v1,...],[c1,p1,1,...],...]
trig_coeffs(T,v1,...) →
            [[%trig,v1,...],[[c1,m1,1,...],...],[[s1,m'1,1,...],...]]
series_coeffs(S,v,O) → [[%series,v,O],[c1,p1],...,[cn,pn]
Taylor_coeffs(S,v,O) → [[%Taylor,v,O],[c1,p1],...,[cn,pn]

The latter two functions both expand an expression through order O, but the series version only carries expands arithmetic operations and is often considerably faster than Taylor_coeffs.

Examples:

(%i1) cl1:coeffs((a+b*x)*(c-x)^2,x);
                       2          2
(%o1) [[%poly, x], [a c , 0], [b c  - 2 a c, 1], [a - 2 b c, 2], [b, 3]]
(%i2) map('first,rest(coeffs((a+b*x)*(c-x)^2=q0+q1*x+q2*x^2+q3*x^3,x)));
                2          2
(%o2)       [a c  = q0, b c  - 2 a c = q1, a - 2 b c = q2, b = q3]
(%i3) trig_coeffs(2*(a+cos(x))*cos(x+3*y),x,y);
(%o3)      [[%trig, x, y], [], [[1, 0, 3], [2 a, 1, 3], [1, 2, 3]]]
(%i4) series_coeffs((a+b*x)*(c-x)^2,x,2);
                              2          2
(%o4)   [[%series, x, 2], [a c , 0], [b c  - 2 a c, 1], [a - 2 b c, 2]]
(%i5)  coeffs((a+b*x)*sin(x),x);
(%o5)             [[%poly, x], [a sin(x), 0], [b sin(x), 1]]
(%i6)  coeffs((a+log(b)*x)*(c-log(x))^2,operator(log));
                                    2           2
(%o6) [[%poly, log(x), log(b)], [a c , 0, 0], [c  x, 0, 1], [- 2 a c, 1, 0], 
                                         [- 2 c x, 1, 1], [a, 2, 0], [x, 2, 1]]

61.2.4 Related functions

function: get_coef (clist,k₁,...) ¶

Gets the coefficient from the coefficient list clist corresponding to the keys k_i. The keys are matched to variable powers when clist is a %poly, %series or %Taylor form. If clist is a %trig then k₁ should be sin or cos and the remaining keys are matched to multipliers.

function: uncoef (clist) ¶

Reconstructs the expression from a coefficient list clist. The coefficient list can be any of the coefficient list forms.

function: partition_poly (expr,test,v₁,...) ¶

Partitions expr into two polynomials; the first is made of those monomials for which the function test returns true and the second is the remainder. The test function is called on the powers of the v_i.

function: partition_trig (expr,sintest,costest,v₁,...) ¶

Trigonometric analog to partition poly; The functions sintest and costest select sine and cosine terms, respectively; each are called on the multipliers of the v_i.

function: partition_series (expr,test,v,O) ¶

function: partition_Taylor (expr,test,v,O) ¶

Analog to partition_poly for series.

Example:

(%i1)  partition_poly((a+b*x)*(c-x)^2,'evenp,x);
                             2      2     3       2
(%o1)          [(a - 2 b c) x  + a c , b x  + (b c  - 2 a c) x]

Support functions

function: matching_parts (expr,predicate,args...) ¶

Returns a list of all subexpressions of expr for which the application predicate(piece,args ... ) returns true.

function: function_calls (expr,functions...) ¶

Returns a list of all calls in expr involving any of functions.

function: function_arguments (expr,functions...) ¶

Returns a list of all argument lists for calls to functions in expr.

Examples:

(%i1) t2:(a+log(b)*x)*(c-log(x))^2$
(%i2) matching_parts(t2,constantp);
(%o2)                             [2, - 1]
(%i3) function_calls(t2,log);
(%o3)                         [log(x), log(b)]

61.2.5 Implementation

Original documentation is located in the share/contrib/format directory and contains an appendix describing the implementation algorithm in more detail.