matrix_augment

REDUC
E

INDEX

MATRIX_AUGMENT _ _ _ _ _ _ _ _ _ _ _ _ operator

Matrix augment, matrix stack:

syntax:

matrix_augment{<matrix\_list>}

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

<matrix\_list> :- matrices.

matrix_augmentsticks the matrices in <matrix\_list> together horizontally.

matrix_stacksticks the matrices in <matrix\_list> together vertically.

examples:



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

REDUC
E

INDEX

MATRIXP _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

matrixp(<test\_input>)

<test\_input> :- anything you like.

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

examples:



matrixp A; 

  t 


matrixp(doodlesackbanana);

  nil 

Related functions: squarep, symmetricp.

matrix_stack

REDUC
E

INDEX

MATRIX_STACK _ _ _ _ _ _ _ _ _ _ _ _ operator

see: matrix_augment.

minor

REDUC
E

INDEX

MINOR _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

minor(<matrix>,<r>,<c>)

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

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

examples:



minor(A,1,3); 

  [4  5]
  [    ]
  [7  8]

Related functions: remove_columns, remove_rows.

mult_columns

REDUC
E

INDEX

MULT_COLUMNS _ _ _ _ _ _ _ _ _ _ _ _ operator

Mult columns, mult rows:

syntax:

mult_columns(<matrix>,<column\_list>,<expr>)

<matrix> :- a matrix.

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

<expr> :- an algebraic expression.

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

mult_rowsperforms the same task on the rows of <matrix>.

examples:



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

REDUC
E

INDEX

MULT_ROWS _ _ _ _ _ _ _ _ _ _ _ _ operator

see: mult_columns.

pivot

REDUC
E

INDEX

PIVOT _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

pivot(<matrix>,<r>,<c>)

<matrix> :- a matrix.

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

pivotpivots <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.

examples:



pivot(A,2,3); 

  [      - 1    ]
  [-1  ------  0]
  [      2      ]
  [             ]
  [4     5     6]
  [             ]
  [      1      ]
  [1    ---    0]
  [      2      ]

Related functions: rows_pivot.

pseudo_inverse

REDUC
E

INDEX

PSEUDO_INVERSE _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

pseudo_inverse(<matrix>)

<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).

examples:



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

REDUC
E

INDEX

RANDOM_MATRIX _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

random_matrix(<r>,<c>,<limit>)

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

random_matrixcreates 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.

examples:



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

REDUC
E

INDEX

REMOVE_COLUMNS _ _ _ _ _ _ _ _ _ _ _ _ operator

Remove columns, remove rows:

syntax:

remove_columns(<matrix>,<column\_list>)

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

remove_columnsremoves the columns specified in <column\_list> from <matrix>.

remove_rowsperforms the same task on the rows of <matrix>.

examples:

 

remove_columns(A,2); 

  [1  3]
  [    ]
  [4  6]
  [    ]
  [7  9]



remove_rows(A,{1,3}); 

  [4  5  6]

Related functions: minor.

remove_rows

REDUC
E

INDEX

REMOVE_ROWS _ _ _ _ _ _ _ _ _ _ _ _ operator

see: remove_columns.

row_dim

REDUC
E

INDEX

ROW_DIM _ _ _ _ _ _ _ _ _ _ _ _ operator

see: column_dim.

rows_pivot

REDUC
E

INDEX

ROWS_PIVOT _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

rows_pivot(<matrix>,<r>,<c>,{<row\_list>})

<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_pivotperforms the same task as pivot but applies the pivot only to the rows specified in <row\_list>.

examples:



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

REDUC
E

INDEX

SIMPLEX _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

simplex(<max/min>,<objective function>, {<linear inequalities>})

<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.

simplexapplies 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.

examples:



 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

REDUC
E

INDEX

SQUAREP _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

squarep(<matrix>)

<matrix> :- a matrix.

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

examples:



squarep(mat((1,3,5))); 

  nil 


squarep(A);
t

Related functions: matrixp, symmetricp.

stack_rows

REDUC
E

INDEX

STACK_ROWS _ _ _ _ _ _ _ _ _ _ _ _ operator

see: augment_columns.

sub_matrix

REDUC
E

INDEX

SUB_MATRIX _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

sub_matrix(<matrix>,<row\_list>,<column\_list>)

<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>.

examples:



sub_matrix(A,{1,3},{2,3}); 

  [2  3]
  [    ]
  [8  9]

Related functions: augment_columns, stack_rows.

svd

REDUC
E

INDEX

SVD _ _ _ _ _ _ _ _ _ _ _ _ operator

Singular value decomposition:

syntax:

svd(<matrix>)

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

svdcomputes 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.

examples:



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

REDUC
E

INDEX

SWAP_COLUMNS _ _ _ _ _ _ _ _ _ _ _ _ operator

Swap columns, swap rows:

syntax:

swap_columns(<matrix>,<c1>,<c2>)

<matrix> :- a matrix.

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

swap_columnsswaps column <c1> of <matrix> with column <c2>.

swap_rowsperforms the same task on two rows of <matrix>.

examples:



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

REDUC
E

INDEX

SWAP_ENTRIES _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

swap_entries(<matrix>,{<r1>,<c1>},{<r2>, <c2>})

<matrix> :- a matrix.

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

swap_entriesswaps <matrix>(<r1>,<c1>) with <matrix>(<r2>,<c2>).

examples:



swap_entries(A,{1,1},{3,3}); 

  [9  2  3]
  [       ]
  [4  5  6]
  [       ]
  [7  8  1]

Related functions: swap_columns, swap_rows.

swap_rows

REDUC
E

INDEX

SWAP_ROWS _ _ _ _ _ _ _ _ _ _ _ _ operator

see: swap_columns.

symmetricp

REDUC
E

INDEX

SYMMETRICP _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

symmetricp(<matrix>)

<matrix> :- a matrix.

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

examples:



symmetricp(make_identity(11)); 

  t 


symmetricp(A); 

  nil

Related functions: matrixp, squarep.

toeplitz

REDUC
E

INDEX

TOEPLITZ _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

toeplitz(<expr\_list>)

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

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

toeplitzcreates 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.

examples:



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

  [w  x  y  z]
  [          ]
  [x  w  x  y]
  [          ]
  [y  x  w  x]
  [          ]
  [z  y  x  w]

vandermonde

REDUC
E

INDEX

VANDERMONDE _ _ _ _ _ _ _ _ _ _ _ _ operator

syntax:

vandermonde({<expr\_list>})

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

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

vandermondecreates 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.

examples:

             
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

REDUC
E

INDEX

Linear Algebra package

  • Linear Algebra package introduction

  • fast_la switch

  • add_columns operator

  • add_rows operator

  • add_to_columns operator

  • add_to_rows operator

  • augment_columns operator

  • band_matrix operator

  • block_matrix operator

  • char_matrix operator

  • char_poly operator

  • cholesky operator

  • coeff_matrix operator

  • column_dim operator

  • companion operator

  • copy_into operator

  • diagonal operator

  • extend operator

  • find_companion operator

  • get_columns operator

  • get_rows operator

  • gram_schmidt operator

  • hermitian_tp operator

  • hessian operator

  • hilbert operator

  • jacobian operator

  • jordan_block operator

  • lu_decom operator

  • make_identity operator

  • matrix_augment operator

  • matrixp operator

  • matrix_stack operator

  • minor operator

  • mult_columns operator

  • mult_rows operator

  • pivot operator

  • pseudo_inverse operator

  • random_matrix operator

  • remove_columns operator

  • remove_rows operator

  • row_dim operator

  • rows_pivot operator

  • simplex operator

  • squarep operator

  • stack_rows operator

  • sub_matrix operator

  • svd operator

  • swap_columns operator

  • swap_entries operator

  • swap_rows operator

  • symmetricp operator

  • toeplitz operator

  • vandermonde operator

  • Smithex

    REDUC
E

    INDEX

    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.

    syntax:

    smithex(<matrix>,<variable>)

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

    examples:

    
     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

    REDUC
E

    INDEX

    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.

    syntax:

    smithex_int(<matrix>)

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

    examples:

    
     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

    REDUC
E

    INDEX

    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.

    syntax:

    frobenius(<matrix>)

    <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:

    Frobeniuscan 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.

    examples:

    
     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

    REDUC
E

    INDEX

    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.

    syntax:

    ratjordan(<matrix>)

    <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:

    ratjordancan 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.

    examples:

    
     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

    REDUC
E

    INDEX

    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).

    syntax:

    jordansymbolic(<matrix>)

    <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:

    jordansymboliccan 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.

    examples:

    
    
     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

    REDUC
E

    INDEX

    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.

    syntax:

    jordan(<matrix>)

    <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.

    examples:

    
    
     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

    REDUC
E

    INDEX

    Matrix Normal Forms

  • Smithex operator

  • Smithex\_int operator

  • Frobenius operator

  • Ratjordan operator

  • Jordansymbolic operator

  • Jordan operator

  • Miscellaneous_Packages

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    APPLYSYM _ _ _ _ _ _ _ _ _ _ _ _ package

    Author: Thomas Wolf

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

    ARNUM

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    CAMAL _ _ _ _ _ _ _ _ _ _ _ _ package

    Author: John P. Fitch

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

    CHANGEVR

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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

    REDUC
E

    INDEX

    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.