**MATRIX_AUGMENT** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

Matrix augment, matrix stack:

(If you are feeling lazy then the braces can be omitted.)

<matrix\_list> :- matrices.

*matrix_augment*sticks the matrices in <matrix\_list>
together horizontally.

*matrix_stack*sticks the matrices in <matrix\_list>
together vertically.

matrix_augment({A,A}); [1 2 3 1 2 3] [ ] [4 5 6 4 5 6] [ ] [7 8 9 7 8 9] matrix_stack(A,A); [1 2 3] [ ] [4 5 6] [ ] [7 8 9] [ ] [1 2 3] [ ] [4 5 6] [ ] [7 8 9]

Related functions: augment_columns, stack_rows, sub_matrix.

**MATRIXP** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<test\_input> :- anything you like.

*matrixp*is a boolean function that returns t if the input is a
matrix and nil otherwise.

matrixp A; t matrixp(doodlesackbanana); nil

Related functions: squarep, symmetricp.

**MATRIX_STACK** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: matrix_augment.

**MINOR** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix. <r>,<c> :- positive integers.

*minor*computes the (<r>,<c>)'th minor of <matrix>.
This is created by removing the <r>'th row and the <c>'th
column from <matrix>.

minor(A,1,3); [4 5] [ ] [7 8]

Related functions: remove_columns, remove_rows.

**MULT_COLUMNS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

Mult columns, mult rows:

<matrix> :- a matrix.

<column\_list> :- a positive integer or a list of positive integers.

<expr> :- an algebraic expression.

*mult_columns*returns a copy of <matrix> in which the
columns specified in <column\_list> have been multiplied by
<expr>.

*mult_rows*performs the same task on the rows of <matrix>.

mult_columns(A,{1,3},x); [ x 2 3*x] [ ] [4*x 5 6*x] [ ] [7*x 8 9*x] mult_rows(A,2,10); [1 2 3 ] [ ] [40 50 60] [ ] [7 8 9 ]

Related functions: add_to_columns, add_to_rows.

**MULT_ROWS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: mult_columns.

**PIVOT** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix.

<r>,<c> :- positive integers such that <matrix>(<r>, <c>) neq 0.

*pivot*pivots <matrix> about it's (<r>,<c>)'th
entry.

To do this, multiples of the <r>'th row are added to every other row in the matrix.

This means that the <c>'th column will be 0 except for the (<r>,<c>)'th entry.

pivot(A,2,3); [ - 1 ] [-1 ------ 0] [ 2 ] [ ] [4 5 6] [ ] [ 1 ] [1 --- 0] [ 2 ]

Related functions: rows_pivot.

**PSEUDO_INVERSE** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix.

*pseudo_inverse*, also known as the Moore-Penrose inverse,
computes the pseudo inverse of <matrix>.

Given the singular value decomposition of <matrix>, i.e: A = U*P*V^T, then the pseudo inverse A^-1 is defined by A^-1 = V^T*P^-1*U.

Thus <matrix> * pseudo_inverse(A) = Id. (Id is the identity matrix).

R := mat((1,2,3,4),(9,8,7,6)); [1 2 3 4] r := [ ] [9 8 7 6] on rounded; pseudo_inverse(R); [ - 0.199999999996 0.100000000013 ] [ ] [ - 0.0499999999988 0.0500000000037 ] [ ] [ 0.0999999999982 - 5.57825497203e-12] [ ] [ 0.249999999995 - 0.0500000000148 ]

Related functions: svd.

**RANDOM_MATRIX** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<r>,<c>,<limit> :- positive integers.

*random_matrix*creates an <r> by <c> matrix with random
entries in the range -limit <entry <limit.

Switches:

*imaginary*:- if on then matrix entries are x+i*y where -limit <x,y
<<limit>.

*not_negative*:- if on then 0 <entry <<limit>. In the imagina
ry
case we have 0 <x,y <<limit>.

*only_integer*:- if on then each entry is an integer. In the imaginary
case x and y are integers.

*symmetric*:- if on then the matrix is symmetric.

*upper_matrix*:- if on then the matrix is upper triangular.

*lower_matrix*:- if on then the matrix is lower triangular.

on rounded; random_matrix(3,3,10); [ - 8.11911717343 - 5.71677292768 0.620580830035 ] [ ] [ - 0.032596262422 7.1655452861 5.86742633837 ] [ ] [ - 9.37155438255 - 7.55636708637 - 8.88618627557] on only_integer, not_negative, upper_matrix, imaginary; random_matrix(4,4,10); [70*i + 15 28*i + 8 2*i + 79 27*i + 44] [ ] [ 0 46*i + 95 9*i + 63 95*i + 50] [ ] [ 0 0 31*i + 75 14*i + 65] [ ] [ 0 0 0 5*i + 52 ]

**REMOVE_COLUMNS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

Remove columns, remove rows:

<matrix> :- a matrix. <column\_list> :- either a positive integer or a list of positive integers.

*remove_columns*removes the columns specified in
<column\_list> from <matrix>.

*remove_rows*performs the same task on the rows of <matrix>.

remove_columns(A,2); [1 3] [ ] [4 6] [ ] [7 9] remove_rows(A,{1,3}); [4 5 6]

Related functions: minor.

**REMOVE_ROWS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: remove_columns.

**ROW_DIM** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: column_dim.

**ROWS_PIVOT** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a namerefmatrix.

<r>,<c> :- positive integers such that <matrix>(<r>, <c>) neq 0.

<row\_list> :- positive integer or a list of positive integers.

*rows_pivot*performs the same task as *pivot* but applies
the pivot only to the rows specified in <row\_list>.

N := mat((1,2,3),(4,5,6),(7,8,9),(1,2,3),(4,5,6)); [1 2 3] [ ] [4 5 6] [ ] n := [7 8 9] [ ] [1 2 3] [ ] [4 5 6] rows_pivot(N,2,3,{4,5}); [1 2 3] [ ] [4 5 6] [ ] [7 8 9] [ ] [ - 1 ] [-1 ------ 0] [ 2 ] [ ] [0 0 0]

Related functions: pivot.

**SIMPLEX** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<max/min> :- either max or min (signifying maximize and minimize).

<objective function> :- the function you are maximizing or minimizing.

<linear inequalities> :- the constraint inequalities. Each one must be of the form sum of variables ( <=,=,>=) number.

*simplex*applies the revised simplex algorithm to find the
optimal(either maximum or minimum) value of the
<objective function> under the linear inequality constraints.

It returns {optimal value,{ values of variables at this optimal}}.

The algorithm implies that all the variables are non-negative.

simplex(max,x+y,{x>=10,y>=20,x+y<=25}); ***** Error in simplex: Problem has no feasible solution simplex(max,10x+5y+5.5z,{5x+3z<=200,x+0.1y+0.5z<=12, 0.1x+0.2y+0.3z<=9, 30x+10y+50z<=1500}); {525.0,{x=40.0,y=25.0,z=0}}

**SQUAREP** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix.

*squarep*is a predicate that returns t if the <matrix> is
square and nil otherwise.

squarep(mat((1,3,5))); nil squarep(A); t

Related functions: matrixp, symmetricp.

**STACK_ROWS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: augment_columns.

**SUB_MATRIX** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix. <row\_list>, <column\_list> :- either a positive integer or a list of positive integers.

namesub_matrix produces the matrix consisting of the intersection of the rows specified in <row\_list> and the columns specified in <column\_list>.

sub_matrix(A,{1,3},{2,3}); [2 3] [ ] [8 9]

Related functions: augment_columns, stack_rows.

**SVD** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

Singular value decomposition:

<matrix> :- a matrix containing only numeric entries.

*svd*computes the singular value decomposition of <matrix>.

It returns

{U,P,V}

where A = U*P*V^T

and P = diag(sigma(1) ... sigma(n)).

sigma(i) for i= 1 ... n are the singular values of <matrix>.

n is the column dimension of <matrix>.

The singular values of <matrix> are the non-negative square roots of the eigenvalues of A^T*A.

U and V are such that U*U^T = V*V^T = V^T*V = Id. Id is the identity matrix.

Q := mat((1,3),(-4,3)); [1 3] q := [ ] [-4 3] on rounded; svd(Q); { [ 0.289784137735 0.957092029805] [ ] [ - 0.957092029805 0.289784137735] , [5.1491628629 0 ] [ ] [ 0 2.9130948854] , [ - 0.687215403194 0.726453707825 ] [ ] [ - 0.726453707825 - 0.687215403194] }

**SWAP_COLUMNS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

Swap columns, swap rows:

<matrix> :- a matrix.

<c1>,<c1> :- positive integers.

*swap_columns*swaps column <c1> of <matrix> with
column <c2>.

*swap_rows*performs the same task on two rows of <matrix>.

swap_columns(A,2,3); [1 3 2] [ ] [4 6 5] [ ] [7 9 8] swap_rows(A,1,3); [7 8 9] [ ] [4 5 6] [ ] [1 2 3]

Related functions: swap_entries.

**SWAP_ENTRIES** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix.

<r1>,<c1>,<r2>,<c2> :- positive integers.

*swap_entries*swaps <matrix>(<r1>,<c1>) with
<matrix>(<r2>,<c2>).

swap_entries(A,{1,1},{3,3}); [9 2 3] [ ] [4 5 6] [ ] [7 8 1]

Related functions: swap_columns, swap_rows.

**SWAP_ROWS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

see: swap_columns.

**SYMMETRICP** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

<matrix> :- a matrix.

*symmetricp*is a predicate that returns t if the matrix is symmetric
and nil otherwise.

symmetricp(make_identity(11)); t symmetricp(A); nil

Related functions: matrixp, squarep.

**TOEPLITZ** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

(If you are feeling lazy then the braces can be omitted.)

<expr\_list> :- list of algebraic expressions.

*toeplitz*creates the toeplitz matrix from the <expr\_list>.

This is a square symmetric matrix in which the first expression is placed on the diagonal and the i'th expression is placed on the (i-1)'th sub and super diagonals.

It has dimension n where n is the number of expressions.

toeplitz({w,x,y,z}); [w x y z] [ ] [x w x y] [ ] [y x w x] [ ] [z y x w]

**VANDERMONDE** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

(If you are feeling lazy then the braces can be omitted.)

<expr\_list> :- list of algebraic expressions.

*vandermonde*creates the vandermonde matrix from the
<expr\_list>.

This is the square matrix in which the (i,j)'th entry is <expr\_list>(i)^(j-1).

It has dimension n where n is the number of expressions.

vandermonde({x,2*y,3*z}); [ 2 ] [1 x x ] [ ] [ 2] [1 2*y 4*y ] [ ] [ 2] [1 3*z 9*z ]

**Linear Algebra package**

**SMITHEX** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *smithex* computes the Smith normal form S of a
matrix A (say). It returns {S,P,P^-1} where P
*S*P^-1 = A.

<matrix> :- a rectangular matrix of univariate polynomials in <variable>. <variable> :- the variable.

a := mat((x,x+1),(0,3*x^2)); [x x + 1] [ ] a := [ 2 ] [0 3*x ] smithex(a,x); [1 0 ] [1 0] [x x + 1] { [ ], [ ], [ ] } [ 3] [ 2 ] [ ] [0 x ] [3*x 1] [-3 -3 ]

**SMITHEX\_INT** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *smithex_int* performs the same task as *smithex*
but on matrices containing only integer entries. Namely,
*smithex_int* returns {S,P,P^-1} where S is the smith normal
form of the input
matrix (A say), and P*S*P^-1 = A.

<matrix> :- a rectangular matrix of integer entries.

a := mat((9,-36,30),(-36,192,-180),(30,-180,180)); [ 9 -36 30 ] [ ] a := [-36 192 -180] [ ] [30 -180 180 ] smithex_int(a); [3 0 0 ] [-17 -5 -4 ] [1 -24 30 ] [ ] [ ] [ ] { [0 12 0 ], [64 19 15 ], [-1 25 -30] } [ ] [ ] [ ] [0 0 60] [-50 -15 -12] [0 -1 1 ]

**FROBENIUS** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *frobenius* computes the *frobenius* normal form F of
a
matrix (A say). It returns {F,P,P^-1} where P
*F*P^-1 = A.

<matrix> :- a square matrix.

Field Extensions:

By default, calculations are performed in the rational numbers. To extend this field the arnum package can be used. The package must first be loaded by load_package arnum;. The field can now be extended by using the defpoly command. For example, defpoly sqrt2**2-2; will extend the field to include the square root of 2 (now defined by sqrt2).

Modular Arithmetic:

*Frobenius*can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
ratjordan for an example.

a := mat((x,x^2),(3,5*x)); [ 2 ] [x x ] a := [ ] [3 5*x] frobenius(a); [ 2] [1 x] [ - x ] { [0 - 2*x ], [ ], [1 -----] } [ ] [0 3] [ 3 ] [1 6*x ] [ ] [ 1 ] [0 --- ] [ 3 ] load_package arnum; defpoly sqrt2**2-2; a := mat((sqrt2,5),(7*sqrt2,sqrt2)); [ sqrt2 5 ] a := [ ] [7*sqrt2 sqrt2] frobenius(a); [0 35*sqrt2 - 2] [1 sqrt2 ] [ 1 ] { [ ], [ ], [1 - --- ] } [1 2*sqrt2 ] [1 7*sqrt2] [ 7 ] [ ] [ 1 ] [0 ----*sqrt2] [ 14 ]

**RATJORDAN** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *ratjordan* computes the rational Jordan normal form R
of a
matrix (A say). It returns {R,P,P^-1} where P
*R*P^-1 = A.

<matrix> :- a square matrix.

Field Extensions:

By default, calculations are performed in the rational numbers. To
extend this field the *arnum* package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
See
frobenius for an example.

Modular Arithmetic:

*ratjordan*can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation.

a := mat((5,4*x),(2,x^2)); [5 4*x] [ ] a := [ 2 ] [2 x ] ratjordan(a); [0 x*( - 5*x + 8)] [1 5] [ -5 ] { [ ], [ ], [1 -----] } [ 2 ] [0 2] [ 2 ] [1 x + 5 ] [ ] [ 1 ] [0 -----] [ 2 ] on modular; setmod 23; a := mat((12,34),(56,78)); [12 11] a := [ ] [10 9 ] ratjordan(a); [15 0] [16 8] [1 21] { [ ], [ ], [ ] } [0 6] [19 4] [1 4 ] on balanced_mod; ratjordan(a); [- 8 0] [ - 7 8] [1 - 2] { [ ], [ ], [ ] } [ 0 6] [ - 4 4] [1 4 ]

**JORDANSYMBOLIC** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *jordansymbolic* computes the Jordan normal form J
of a
matrix (A say). It returns {J,L,P,P^-1} where
P*J*P^-1 = A. L = {ll,mm} where mm is a name and ll is a list of
irreducible factors of p(mm).

<matrix> :- a square matrix.

Field Extensions:

By default, calculations are performed in the rational numbers. To extend this field the arnum package can be used. The package must first be loaded by load_package arnum;. The field can now be extended by using the defpoly command. For example, defpoly sqrt2**2-2; will extend the field to include the square root of 2 (now defined by sqrt2). See frobenius for an example.

Modular Arithmetic:

*jordansymbolic*can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
ratjordan for an example.

a := mat((1,y),(2,5*y)); [1 y ] a := [ ] [2 5*y] jordansymbolic(a); { [lambda11 0 ] [ ] [ 0 lambda12] , 2 lambda - 5*lambda*y - lambda + 3*y,lambda, [lambda11 - 5*y lambda12 - 5*y] [ ] [ 2 2 ] , [ 2*lambda11 - 5*y - 1 5*lambda11*y - lambda11 - y + 1 ] [---------------------- ---------------------------------] [ 2 2 ] [ 25*y - 2*y + 1 2*(25*y - 2*y + 1) ] [ ] [ 2*lambda12 - 5*y - 1 5*lambda12*y - lambda12 - y + 1 ] [---------------------- ---------------------------------] [ 2 2 ] [ 25*y - 2*y + 1 2*(25*y - 2*y + 1) ] }

**JORDAN** _ _ _ _ _ _ _ _ _ _ _ _ **operator**

The operator *jordan* computes the Jordan normal form J
of a
matrix (A say). It returns {J,P,P^-1} where P
*J*P^-1 = A.

<matrix> :- a square matrix.

Field Extensions:
By default, calculations are performed in the rational numbers. To
extend this field the *arnum* package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
See
frobenius for an example.

Modular Arithmetic:
*Jordan* can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
ratjordan for an example.

a := mat((1,x),(0,x)); [1 x] a := [ ] [0 x] jordan(a); { [1 0] [ ] [0 x] , [ 1 x ] [------- --------------] [ x - 1 2 ] [ x - 2*x + 1 ] [ ] [ 1 ] [ 0 ------- ] [ x - 1 ] , [x - 1 - x ] [ ] [ 0 x - 1] }

**Matrix Normal Forms**

**MISCELLANEOUS PACKAGES** _ _ _ _ _ _ _ _ _ _ _ _ **introduction**

REDUCE includes a large number of packages that have been contributed by
users from various fields. Some of these, together with their relevant
commands, switches and so on (e.g., the NUMERIC package), have
been described elsewhere. This section describes those packages for which
no separate help material exists. Each has its own switches, commands,
and operators, and some redefine special characters to aid in their
notation. However, the brief descriptions given here do not include all
such information. Readers are referred to the general package
documentation in this case, which can be found, along with the source
code, under the subdirectories *doc* and *src* in the
*reduce* directory. The
load_package command is used to
load the files you wish into your system. There will be a short delay
while the package is loaded. A package cannot be unloaded. Once it
is in your system, it stays there until you end the session. Each package
also has a test file, which you will find under its name in the
*$reduce/xmpl* directory.

Finally, it should be mentioned that such user-contributed packages are unsupported; any questions or problems should be directed to their authors.

**ALGINT** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: James H. Davenport

The *algint* package provides indefinite integration of square roots.
This package, which is an extension of the basic integration package
distributed with REDUCE, will analytically integrate a wide range of
expressions involving square roots. The
algint switch provides for
the use of the facilities given by the package, and is automatically turned
on when the package is loaded. If you want to return to the standard
integration algorithms, turn
algint off. An error message is given
if you try to turn the
algint switch on when its package is not
loaded.

**APPLYSYM** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Thomas Wolf

This package provides programs APPLYSYM, QUASILINPDE and DETRAFO for computing with infinitesimal symmetries of differential equations.

**ARNUM** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Eberhard Schruefer

This package provides facilities for handling algebraic numbers as polynomial coefficients in REDUCE calculations. It includes facilities for introducing indeterminates to represent algebraic numbers, for calculating splitting fields, and for factoring and finding greatest common divisors in such domains.

**ASSIST** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Hubert Caprasse

ASSIST contains a large number of additional general purpose functions that allow a user to better adapt REDUCE to various calculational strategies and to make the programming task more straightforward and more efficient.

**AVECTOR** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: David Harper

This package provides REDUCE with the ability to perform vector algebra using the same notation as scalar algebra. The basic algebraic operations are supported, as are differentiation and integration of vectors with respect to scalar variables, cross product and dot product, component manipulation and application of scalar functions (e.g. cosine) to a vector to yield a vector result.

**BOOLEAN** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Herbert Melenk

This package supports the computation with boolean expressions in the propositional calculus. The data objects are composed from algebraic expressions connected by the infix boolean operators and, or, implies, equiv, and the unary prefix operator not. Boolean allows you to simplify expressions built from these operators, and to test properties like equivalence, subset property etc.

**CALI** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Hans-Gert Gr"abe

This package contains algorithms for computations in commutative algebra closely related to the Groebner algorithm for ideals and modules. Its heart is a new implementation of the Groebner algorithm that also allows for the computation of syzygies. This implementation is also applicable to submodules of free modules with generators represented as rows of a matrix.

**CAMAL** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: John P. Fitch

This package implements in REDUCE the Fourier transform procedures of the CAMAL package for celestial mechanics.

**CHANGEVR** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: G. Ucoluk

This package provides facilities for changing the independent variables in a differential equation. It is basically the application of the chain rule.

**COMPACT** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Anthony C. Hearn

COMPACT is a package of functions for the reduction of a polynomial in the presence of side relations. COMPACT applies the side relations to the polynomial so that an equivalent expression results with as few terms as possible. For example, the evaluation of

compact(s*(1-sin x^2)+c*(1-cos x^2)+sin x^2+cos x^2, {cos x^2+sin x^2=1});

yields the result

2 2 SIN(X) *C + COS(X) *S + 1

The first argument to the operator *compact* is the expression
and the second is a list of side relations that can be
equations or simple expressions (implicitly equated to zero). The
kernels in the side relations may also be free variables with the
same meaning as in rules, e.g.

sin_cos_identity := {cos ~w^2+sin ~w^2=1}$ compact(u,in_cos_identity);

Also the full rule syntax with the replacement operator is allowed here.

**CRACK** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Authors: Andreas Brand, Thomas Wolf

CRACK is a package for solving overdetermined systems of partial or ordinary differential equations (PDEs, ODEs). Examples of programs which make use of CRACK for investigating ODEs (finding symmetries, first integrals, an equivalent Lagrangian or a ``differential factorization'') are included.

**CVIT** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Authors: V.Ilyin, A.Kryukov, A.Rodionov, A.Taranov

This package provides an alternative method for computing traces of Dirac gamma matrices, based on an algorithm by Cvitanovich that treats gamma matrices as 3-j symbols.

**DEFINT** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Authors: Kerry Gaskell, Stanley M. Kameny, Winfried Neun

This package finds the definite integral of an expression in a stated interval. It uses several techniques, including an innovative approach based on the Meijer G-function, and contour integration.

**DESIR** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Authors: C. Dicrescenzo, F. Richard-Jung, E. Tournier

This package enables the basis of formal solutions to be computed for an ordinary homogeneous differential equation with polynomial coefficients over Q of any order, in the neighborhood of zero (regular or irregular singular point, or ordinary point).

**DFPART** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Herbert Melenk

This package supports computations with total and partial derivatives of formal function objects. Such computations can be useful in the context of differential equations or power series expansions.

**DUMMY** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Alain Dresse

This package allows a user to find the canonical form of expressions involving dummy variables. In that way, the simplification of polynomial expressions can be fully done. The indeterminates are general operator objects endowed with as few properties as possible. In that way the package may be used in a large spectrum of applications.

**EXCALC** _ _ _ _ _ _ _ _ _ _ _ _ **package**

Author: Eberhard Schruefer

The *excalc* package is designed for easy use by all who are familiar
with the calculus of Modern Differential Geometry. The program is currently
able to handle scalar-valued exterior forms, vectors and operations between
them, as well as non-scalar valued forms (indexed forms). It is thus an ideal
tool for studying differential equations, doing calculations in general
relativity and field theories, or doing simple things such as calculating the
Laplacian of a tensor field for an arbitrary given frame.