Artifact 85e43f313a05148249562efc30ea2841e6549b2293f90f54efc0fb576899dfa6:
- Executable file
r36/mkhelp/REDHELP.INF
— part of check-in
[f2fda60abd]
at
2011-09-02 18:13:33
on branch master
— Some historical releases purely for archival purposes
git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/trunk/historical@1375 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 674339) [annotate] [blame] [check-ins using] [more...]
This is Info file redhelp.inf, produced by Makeinfo-1.55 from the input file redhelp.y. File: redhelp, Node: IDENTIFIER, Next: KERNEL, Up: Concepts section IDENTIFIER type Identifiers in REDUCE consist of one or more alphanumeric characters, of which the first must be alphabetical. The maximum number of characters allowed is system dependent, but is usually over 100. However, printing is simplified if they are kept under 25 characters. You can also use special characters in your identifiers, but each must be preceded by an exclamation point ! as an escape character. Useful special characters are # $ % ^ & * - + = ? < > ^ / ! and the space. Note that the use of the exclamation point as a special character requires a second exclamation point as an escape character. The underscore _ is special in this regard. It must be preceded by an escape character in the first position in an identifier, but is treated like a normal letter within an identifier. Other characters, such as ( ) # ; ' " can also be used if preceded by a ! , but as they have special meanings to the Lisp reader it is best to avoid them to avoid confusion. Many system identifiers have * before or after their names, or - between words. If you accidentally pick one of these names for your own identifier, it could have disastrous effects. For this reason it is wise not to include * or - anywhere in your identifiers. You will notice that REDUCE does not use the escape characters when it prints identifiers containing special characters; however, you still must use them when you refer to these identifiers. Be careful when editing statements containing escaped special characters to treat the character and its escape as an inseparable pair. Identifiers are used for variable names, labels for GO TO statements, and names of arrays, matrices, operators, and procedures. Once an identifier is used as a matrix, array, scalar or operator identifier, it may not be used again as a matrix, array or operator. An operator or array identifier may later be used as a scalar without problems, but a matrix identifier cannot be used as a scalar. All procedures are entered into the system as operators, so the name of a procedure may not be used as a matrix, array, or operator identifier either. File: redhelp, Node: KERNEL, Next: STRING, Prev: IDENTIFIER, Up: Concepts section KERNEL type A KERNEL is a form that cannot be modified further by the REDUCE canonical simplifier. Scalar variables are always kernels. The other important class of kernels are operators with their arguments. Some examples should help clarify this concept: ____________________________________________________________ Expression Kernel? x Yes varname Yes cos(a) Yes log(sin(x**2)) Yes a*b No (x+y)**4 No matrix-identifier No ____________________________________________________________ Many REDUCE operators expect kernels among their arguments. Error messages result from attempts to use non-kernel expressions for these arguments. File: redhelp, Node: STRING, Prev: KERNEL, Up: Concepts section STRING type A STRING is any collection of characters enclosed in double quotation marks (" ). It may be used as an argument for a variety of commands and operators, such as IN , REDERR and WRITE . examples: ____________________________________________________________ write "this is a string"; this is a string write a, " ", b, " ",c,"!"; A B C! ____________________________________________________________ File: redhelp, Node: Concepts section, Next: Variables section, Up: Top Concepts section * Menu: * IDENTIFIER:: type * KERNEL:: type * STRING:: type File: redhelp, Node: assumptions, Next: CARD_NO, Up: Variables section ASSUMPTIONS variable After solving a linear or polynomial equation system with parameters, the variable ASSUMPTIONS contains a list of side relations for the parameters. The solution is valid only as long as none of these expression is zero. examples: ____________________________________________________________ solve({a*x-b*y+x,y-c},{x,y}); b*c {{x=-----,y=c}} a + 1 assumptions; {a + 1} ____________________________________________________________ File: redhelp, Node: CARD_NO, Next: E, Prev: assumptions, Up: Variables section CARD_NO variable CARD_NO sets the total number of cards allowed in a Fortran output statement when FORT is on. Default is 20. examples: ____________________________________________________________ on fort; card_no := 4; CARD_NO=4. z := (x + y)**15; ANS1=5005.*X**6*Y**9+3003.*X**5*Y**10+1365.*X**4*Y** . 11+455.*X**3*Y**12+105.*X**2*Y**13+15.*X*Y**14+Y**15 Z=X**15+15.*X**14*Y+105.*X**13*Y**2+455.*X**12*Y**3+ . 1365.*X**11*Y**4+3003.*X**10*Y**5+5005.*X**9*Y**6+ . 6435.*X**8*Y**7+6435.*X**7*Y**8+ANS1 ____________________________________________________________ Twenty total cards means 19 continuation cards. You may set it for more if your Fortran system allows more. Expressions are broken apart in a Fortran-compatible way if they extend for more than CARD_NO continuation cards. File: redhelp, Node: E, Next: EVAL_MODE, Prev: CARD_NO, Up: Variables section E constant The constant E is reserved for use as the base of the natural logarithm. Its value is approximately 2.71828284590, which REDUCE gives to the current decimal precision when the switch [*note ROUNDED::.] is on. E may be used as an iterative variable in a [*note FOR::.] statement, or as a local variable or a [*note PROCEDURE::.] . If E is defined as a local variable inside the procedure, the normal definition as the base of the natural logarithm would be suspended inside the procedure. File: redhelp, Node: EVAL_MODE, Next: FORT_WIDTH, Prev: E, Up: Variables section EVAL_MODE variable The system variable EVAL_MODE contains the current mode, either [*note ALGEBRAIC::.] or [*note SYMBOLIC::.] . examples: ____________________________________________________________ EVAL_MODE; ALGEBRAIC ____________________________________________________________ Some commands do not behave the same way in algebraic and symbolic modes. File: redhelp, Node: FORT_WIDTH, Next: HIGH_POW, Prev: EVAL_MODE, Up: Variables section FORT_WIDTH variable The FORT_WIDTH variable sets the number of characters in a line of Fortran-compatible output produced when the [*note FORT::.] switch is on. Default is 70. examples: ____________________________________________________________ fort_width := 30; FORT_WIDTH := 30 on fort; df(sin(x**3*y),x); ANS=3.*COS(X . **3*Y)*X**2* . Y ____________________________________________________________ FORT_WIDTH includes the usually blank characters at the beginning of the card. As you may notice above, it is conservative and makes the lines even shorter than it was told. File: redhelp, Node: HIGH_POW, Next: I, Prev: FORT_WIDTH, Up: Variables section HIGH_POW variable The variable HIGH_POW is set by [*note COEFF::.] to the highest power of the variable of interest in the given expression. You can access this variable for use in further computation or display. examples: ____________________________________________________________ coeff((x+1)^5*(x*(y+3)^2)^2,x); {0, 0, 4 3 2 Y + 12*Y + 54*Y + 108*Y + 81, 4 3 2 5*(Y + 12*Y + 54*Y + 108*Y + 81), 4 3 2 10*(Y + 12*Y + 54*Y + 108*Y + 81), 4 3 2 10*(Y + 12*Y + 54*Y + 108*Y + 81), 4 3 2 5*(Y + 12*Y + 54*Y + 108*Y + 81), 4 3 2 Y + 12*Y + 54*Y + 108*Y + 81} high_pow; 7 ____________________________________________________________ File: redhelp, Node: I, Next: INFINITY, Prev: HIGH_POW, Up: Variables section I constant REDUCE knows I is the square root of -1, and that i^2 = -1. examples: ____________________________________________________________ (a + b*i)*(c + d*i); A*C + A*D*I + B*C*I - B*D i**2; -1 ____________________________________________________________ I cannot be used as an identifier. It is all right to use I as an index variable in a FOR loop, or as a local (SCALAR ) variable inside a BEGIN...END block, but it loses its definition as the square root of -1 inside the block in that case. Only the simplest properties of i are known by REDUCE unless the switch [*note COMPLEX::.] is turned on, which implements full complex arithmetic in factoring, simplification, and functional values. COMPLEX is ordinarily off. File: redhelp, Node: INFINITY, Next: LOW_POW, Prev: I, Up: Variables section INFINITY constant The name INFINITY is used to represent the infinite positive number. However, at the present time, arithmetic in terms of this operator reflects finite arithmetic, rather than true operations on infinity. File: redhelp, Node: LOW_POW, Next: NIL, Prev: INFINITY, Up: Variables section LOW_POW variable The variable LOW_POW is set by [*note COEFF::.] to the lowest power of the variable of interest in the given expression. You can access this variable for use in further computation or display. examples: ____________________________________________________________ coeff((x+2*y)**6,y); 6 {X , 5 12*X , 4 60*X , 3 160*X , 2 240*X , 192*X, 64} low_pow; 0 coeff(x**2*(x*sin(y) + 1),x); {0,0,1,SIN(Y)} low_pow; 2 ____________________________________________________________ File: redhelp, Node: NIL, Next: PI, Prev: LOW_POW, Up: Variables section NIL constant NIL represents the truth value false in symbolic mode, and is a synonym for 0 in algebraic mode. It cannot be used for any other purpose, even inside procedures or [*note FOR::.] loops. File: redhelp, Node: PI, Next: requirements, Prev: NIL, Up: Variables section PI constant The identifier PI is reserved for use as the circular constant. Its value is given by 3.14159265358..., which REDUCE gives to the current decimal precision when REDUCE is in a floating-point mode. PI may be used as a looping variable in a [*note FOR::.] statement, or as a local variable in a [*note PROCEDURE::.] . Its value in such cases will be taken from the local environment. File: redhelp, Node: requirements, Next: ROOT_MULTIPLICITIES, Prev: PI, Up: Variables section REQUIREMENTS variable After an attempt to solve an inconsistent equation system with parameters, the variable REQUIREMENTS contains a list of expressions. These expressions define a set of conditions implicitly equated with zero. Any solution to this system defines a setting for the parameters sufficient to make the original system consistent. examples: ____________________________________________________________ solve({x-a,x-y,y-1},{x,y}); {} requirements; {a - 1} ____________________________________________________________ File: redhelp, Node: ROOT_MULTIPLICITIES, Next: T, Prev: requirements, Up: Variables section ROOT_MULTIPLICITIES variable The ROOT_MULTIPLICITIES variable is set to the list of the multiplicities of the roots of an equation by the [*note SOLVE::.] operator. [*note SOLVE::.] returns its solutions in a list. The multiplicities of each solution are put in the corresponding locations of the list ROOT_MULTIPLICITIES . File: redhelp, Node: T, Prev: ROOT_MULTIPLICITIES, Up: Variables section T constant The constant T stands for the truth value true. It cannot be used as a scalar variable in a [*note block::.] , as a looping variable in a [*note FOR::.] statement or as an [*note OPERATOR::.] name. File: redhelp, Node: Variables section, Next: Syntax section, Prev: Concepts section, Up: Top Variables section * Menu: * assumptions:: variable * CARD_NO:: variable * E:: * EVAL_MODE:: variable * FORT_WIDTH:: variable * HIGH_POW:: variable * I:: * INFINITY:: * LOW_POW:: variable * NIL:: * PI:: * requirements:: variable * ROOT_MULTIPLICITIES:: variable * T:: File: redhelp, Node: semicolon, Next: dollar, Up: Syntax section ; SEMICOLON command The semicolon is a statement delimiter, indicating results are to be printed when used in interactive mode. examples: ____________________________________________________________ (x+1)**2; 2 X + 2*X + 1 df(x**2 + 1,x); 2*X ____________________________________________________________ Entering a RETURN without a semicolon or dollar sign results in a prompt on the following line. A semicolon or dollar sign can be added at this point to execute the statement. In interactive mode, a statement that is ended with a semicolon and RETURN has its results printed on the screen. Inside a group statement << ...>> or a BEGIN ...END block, a semicolon or dollar sign separates individual REDUCE statements. Since results are not printed from a block without a specific RETURN statement, there is no difference between using the semicolon or dollar sign. In a group statement, the last value produced is the value returned by the group statement. Thus, if a semicolon or dollar sign is placed between the last statement and the ending brackets, the group statement returns the value 0 or nil, rather than the value of the last statement. File: redhelp, Node: dollar, Next: percent, Prev: semicolon, Up: Syntax section $ DOLLAR command The dollar sign is a statement delimiter, indicating results are not to be printed when used in interactive mode. examples: ____________________________________________________________ (x+1)**2$ ____________________________________________________________ The workspace is set to x^2 + 2x + 1 but nothing shows on the screen ____________________________________________________________ ws; 2 X + 2*X + 1 ____________________________________________________________ Entering a RETURN without a semicolon or dollar sign results in a prompt on the following line. A semicolon or dollar sign can be added at this point to execute the statement. In interactive mode, a statement that ends with a dollar sign $ and a RETURN is executed, but the results not printed. Inside a [*note group::.] statement << ...>> or a BEGIN ...END [*note block::.] , a semicolon or dollar sign separates individual REDUCE statements. Since results are not printed from a [*note block::.] without a specific [*note RETURN::.] statement, there is no difference between using the semicolon or dollar sign. In a group statement, the last value produced is the value returned by the group statement. Thus, if a semicolon or dollar sign is placed between the last statement and the ending brackets, the group statement returns the value 0 or nil, rather than the value of the last statement. File: redhelp, Node: percent, Next: dot, Prev: dollar, Up: Syntax section % PERCENT command The percent sign is used to precede comments; everything from a percent to the end of the line is ignored. examples: ____________________________________________________________ df(x**3 + y,x);% This is a comment (Key){Return} 2 3*X int(3*x**2,x) %This is a comment; (Key){Return} ____________________________________________________________ A prompt is given, waiting for the semicolon that was not detected in the comment ____________________________________________________________ ____________________________________________________________ Statement delimiters ; and $ are not detected between a percent sign and the end of the line. File: redhelp, Node: dot, Next: assign, Prev: percent, Up: Syntax section . DOT operator The . (dot) infix binary operator adds a new item to the beginning of an existing [*note LIST::.] . In high energy physics expressions, it can also be used to represent the scalar product of two Lorentz four-vectors. syntax: <item> . <list> <item> can be any REDUCE scalar expression, including a list; <list> must be a [*note LIST::.] to avoid producing an error message. The dot operator is right associative. examples: ____________________________________________________________ liss := a . {}; LISS := {A} liss := b . liss; LISS := {B,A} newliss := liss . liss; NEWLISS := {{B,A},B,A} firstlis := a . b . {c}; FIRSTLIS := {A,B,C} secondlis := x . y . {z}; SECONDLIS := {X,Y,Z} for i := 1:3 sum part(firstlis,i)*part(secondlis,i); A*X + B*Y + C*Z ____________________________________________________________ File: redhelp, Node: assign, Next: equalsign, Prev: dot, Up: Syntax section := ASSIGN operator The := is the assignment operator, assigning the value on the right-hand side to the identifier or other valid expression on the left-hand side. syntax: <restricted_expression> := <expression> <restricted_expression> is ordinarily a single identifier, though simple expressions may be used (see Comments below). <expression> is any valid REDUCE expression. If <expression> is a [*note MATRIX::.] identifier, then <restricted_expression> can be a matrix identifier (redimensioned if necessary) which has each element set to the corresponding elements of the identifier on the right-hand side. examples: ____________________________________________________________ a := x**2 + 1; 2 A := X + 1 a; 2 X + 1 first := second := third; FIRST := SECOND := THIRD first; THIRD second; THIRD b := for i := 1:5 product i; B := 120 b; 120 w + (c := x + 3) + z; W + X + Z + 3 c; X + 3 y + b := c; Y + B := C y; - (B - C) ____________________________________________________________ The assignment operator is right associative, as shown in the second and third examples. A string of such assignments has all but the last item set to the value of the last item. Embedding an assignment statement in another expression has the side effect of making the assignment, as well as causing the given replacement in the expression. Assignments of values to expressions rather than simple identifiers (such as in the last example above) can also be done, subject to the following remarks: (i) If the left-hand side is an identifier, an operator, or a power, the substitution rule is added to the rule table. (ii) If the operators - + / appear on the left-hand side, all but the first term of the expression is moved to the right-hand side. (iii) If the operator * appears on the left-hand side, any constant terms are moved to the right-hand side, but the symbolic factors remain. Assignment is valid for [*note ARRAY::.] elements, but not for entire arrays. The assignment operator can also be used to attach functionality to operators. A recursive construction such as A := A + B is allowed, but when A is referenced again, the process of resubstitution continues until the expression stack overflows (you get an error message). Recursive assignments can be done safely inside controlled loop expressions, such as [*note FOR::.] ... or [*note REPEAT::.] ...UNTIL . File: redhelp, Node: equalsign, Next: replace, Prev: assign, Up: Syntax section = EQUALSIGN operator The = operator is a prefix or infix equality comparison operator. syntax: = (<expression>, <expression>) or <expression> = <expression> <expression> can be any REDUCE scalar expression. examples: ____________________________________________________________ a := 4; A := 4 if =(a,10) then write "yes" else write "no"; no b := c; B := C if b = c then write "yes" else write "no"; yes on rounded; if 4.0 = 4 then write "yes" else write "no"; yes ____________________________________________________________ This logical equality operator can only be used inside a conditional statement, such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL . In other places the equal sign establishes an algebraic object of type [*note EQUATION::.] . File: redhelp, Node: replace, Next: plussign, Prev: equalsign, Up: Syntax section => REPLACE operator The => operator is a binary operator used in [*note RULE::.] lists to denote replacements. examples: ____________________________________________________________ operator f; let f(x) => x^2; f(x); 2 x ____________________________________________________________ File: redhelp, Node: plussign, Next: minussign, Prev: replace, Up: Syntax section + PLUSSIGN operator The + operator is a prefix or infix n-ary addition operator. syntax: <expression> + <expression>+ or + (<expression> ,<expression>+) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ x**4 + 4*x**2 + 17*x + 1; 4 2 X + 4*X + 17*X + 1 14 + 15 + x; X + 29 +(1,2,3,4,5); 15 ____________________________________________________________ + is also valid as an addition operator for [*note MATRIX::.] variables that are of the same dimensions and for [*note EQUATION::.] s. File: redhelp, Node: minussign, Next: asterisk, Prev: plussign, Up: Syntax section - MINUSSIGN operator The - operator is a prefix or infix binary subtraction operator, as well as the unary minus operator. syntax: <expression> - <expression> or - (<expression>,<expression>) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ 15 - 4; 11 x*(-5); - 5*X a - b - 15; A - B - 15 -(a,4); A - 4 ____________________________________________________________ The subtraction operator is left associative, so that a - b - c is equivalent to (a - b) - c, as shown in the third example. The subtraction operator is also valid with [*note MATRIX::.] expressions of the correct dimensions and with [*note EQUATION::.] s. File: redhelp, Node: asterisk, Next: slash, Prev: minussign, Up: Syntax section * ASTERISK operator The * operator is a prefix or infix n-ary multiplication operator. syntax: <expression> * <expression>+ or * (<expression> ,<expression>+) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ 15*3; 45 24*x*yvalue*2; 48*X*YVALUE *(6,x); 6*X on rounded; 3*1.5*x*x*x; 3 4.5*X off rounded; 2x**2; 2 2*X ____________________________________________________________ REDUCE assumes you are using an implicit multiplication operator when an identifier is preceded by a number, as shown in the last line above. Since no valid identifiers can begin with numbers, there is no ambiguity in making this assumption. The multiplication operator is also valid with [*note MATRIX::.] expressions of the proper dimensions: matrices A and B can be multiplied if A is n x m and B is m x p. Matrices and [*note EQUATION::.] s can also be multiplied by scalars: the result is as if each element was multiplied by the scalar. File: redhelp, Node: slash, Next: power, Prev: asterisk, Up: Syntax section / SLASH operator The / operator is a prefix or infix binary division operator or prefix unary [*note RECIP::.] rocal operator. syntax: <expression>/ <expression> or / <expression> or / (<expression>,<expression>) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ 20/5; 4 100/6; 50 -- 3 16/2/x; 8 - X /b; 1 - B /(y,5); Y - 5 on rounded; 35/4; 8.75 /20; 0.05 ____________________________________________________________ The division operator is left associative, so that A/B/C is equivalent to (A/B)/C . The division operator is also valid with square [*note MATRIX::.] expressions of the same dimensions: With A and B both n x n matrices and B invertible, A/B is given by A*B^-1. Division of a matrix by a scalar is defined, with the results being the division of each element of the matrix by the scalar. Division of a scalar by a matrix is defined if the matrix is invertible, and has the effect of multiplying the scalar by the inverse of the matrix. When / is used as a reciprocal operator for a matrix, the inverse of the matrix is returned if it exists. File: redhelp, Node: power, Next: caret, Prev: slash, Up: Syntax section ** POWER operator The ** operator is a prefix or infix binary exponentiation operator. syntax: <expression> ** <expression> or ** (<expression>,<expression>) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ x**15; 15 X x**y**z; Y*Z X x**(y**z); Z Y X **(y,4); 4 Y on rounded; 2**pi; 8.82497782708 ____________________________________________________________ The exponentiation operator is left associative, so that A**B**C is equivalent to (A**B)**C , as shown in the second example. Note that this is not A**(B**C) , which would be right associative. When [*note NAT::.] is on (the default), REDUCE output produces raised exponents, as shown. The symbol ^ , which is the upper-case 6 on most keyboards, may be used in the place of ** . A square [*note MATRIX::.] may also be raised to positive and negative powers with the exponentiation operator (negative powers require the matrix to be invertible). Scalar expressions and [*note EQUATION::.] s may be raised to fractional and floating-point powers. File: redhelp, Node: caret, Next: geqsign, Prev: power, Up: Syntax section ^ CARET operator The ^ operator is a prefix or infix binary exponentiation operator. It is equivalent to [*note power::.] or **. syntax: <expression> ^ <expression> or ^ (<expression>,<expression>) <expression> may be any valid REDUCE expression. examples: ____________________________________________________________ x^15; 15 X x^y^z; Y*Z X x^(y^z); Z Y X ^(y,4); 4 Y on rounded; 2^pi; 8.82497782708 ____________________________________________________________ The exponentiation operator is left associative, so that A^B^C is equivalent to (A^B)^C , as shown in the second example. Note that this is <not> A^(B^C) , which would be right associative. When [*note NAT::.] is on (the default), REDUCE output produces raised exponents, as shown. A square [*note MATRIX::.] may also be raised to positive and negative powers with the exponentiation operator (negative powers require the matrix to be invertible). Scalar expressions and [*note EQUATION::.] s may be raised to fractional and floating-point powers. File: redhelp, Node: geqsign, Next: greater, Prev: caret, Up: Syntax section >= GEQSIGN operator >= is an infix binary comparison operator, which returns true if its first argument is greater than or equal to its second argument. syntax: <expression> >= <expression> <expression> must evaluate to an integer or floating-point number. examples: ____________________________________________________________ if (3 >= 2) then yes; yes a := 15; A := 15 if a >= 20 then big else small; small ____________________________________________________________ The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL or [*note WHILE::.] ...DO . File: redhelp, Node: greater, Next: leqsign, Prev: geqsign, Up: Syntax section > GREATER operator The > is an infix binary comparison operator that returns true if its first argument is strictly greater than its second. syntax: <expression> > <expression> <expression> must evaluate to a number, e.g., integer, rational or floating point number. examples: ____________________________________________________________ on rounded; if 3.0 > 3 then write "different" else write "same"; same off rounded; a := 20; A := 20 if a > 20 then write "bigger" else write "not bigger"; not bigger ____________________________________________________________ The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL or [*note WHILE::.] ...DO . File: redhelp, Node: leqsign, Next: less, Prev: greater, Up: Syntax section <= LEQSIGN operator <= is an infix binary comparison operator that returns true if its first argument is less than or equal to its second argument. syntax: <expression> <= <expression> <expression> must evaluate to a number, e.g., integer, rational or floating point number. examples: ____________________________________________________________ a := 10; A := 10 if a <= 10 then true; true ____________________________________________________________ The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL or [*note WHILE::.] ...DO . File: redhelp, Node: less, Next: tilde, Prev: leqsign, Up: Syntax section < LESS operator < is an infix binary logical comparison operator that returns true if its first argument is strictly less than its second argument. syntax: <expression> < <expression> <expression> must evaluate to a number, e.g., integer, rational or floating point number. examples: ____________________________________________________________ f := -3; F := -3 if f < -3 then write "yes" else write "no"; no ____________________________________________________________ The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL or [*note WHILE::.] ...DO . File: redhelp, Node: tilde, Next: group, Prev: less, Up: Syntax section ~ TILDE operator The ^ is used as a unary prefix operator in the left-hand sides of [*note RULE::.] s to mark [*note Free Variable::.] s. A double tilde marks an optional [*note Free Variable::.] . File: redhelp, Node: group, Next: AND, Prev: tilde, Up: Syntax section << GROUP command The << ...>> command is a group statement, used to group statements together where REDUCE expects a single statement. syntax: << <statement>; <statement> OR <statement>* >> <statement> may be any valid REDUCE statement or expression. examples: ____________________________________________________________ a := 2; A := 2 if a < 5 then <<b := a + 10; write b>>; 12 <<d := c/15; f := d + 3; f**2>>; 2 C + 90*C + 202 ---------------- 225 ____________________________________________________________ The value returned from a group statement is the value of the last individual statement executed inside it. Note that when a semicolon is placed between the last statement and the closing brackets, 0 or nil is returned. Group statements are often used in the consequence portions of [*note IF::.] ...THEN , [*note REPEAT::.] ...UNTIL , and [*note WHILE::.] ...DO clauses. They may also be used in interactive operation to execute several statements at one time. Statements inside the group statement are separated by semicolons or dollar signs. File: redhelp, Node: AND, Next: BEGIN, Prev: group, Up: Syntax section AND operator The AND binary logical operator returns true if both of its arguments are true. syntax: <logical_expression> AND <logical_expression> <logical_expression> must evaluate to true or nil. examples: ____________________________________________________________ a := 12; A := 12 if numberp a and a < 15 then write a**2 else write "no"; 144 clear a; if numberp a and a < 15 then write a**2 else write "no"; no ____________________________________________________________ Logical operators can only be used inside conditional statements, such as [*note WHILE::.] ...DO or [*note IF::.] ...THEN ...ELSE . AND examines each of its arguments in order, and quits, returning nil, on finding an argument that is not true. An error results if it is used in other contexts. AND is left associative: X AND Y AND Z is equivalent to (X AND Y) AND Z . File: redhelp, Node: BEGIN, Next: block, Prev: AND, Up: Syntax section BEGIN command BEGIN is used to start a [*note block::.] statement, which is closed with END . syntax: BEGIN <statement>; <statement>* END <statement> is any valid REDUCE statement. examples: ____________________________________________________________ begin for i := 1:3 do write i end; 1 2 3 begin scalar n;n:=1;b:=for i:=1:4 product(x-i);return n end; 1 b; 4 3 2 X - 10*X + 35*X - 50*X + 24 ____________________________________________________________ A BEGIN ...END block can do actions (such as WRITE ), but does not return a value unless instructed to by a [*note RETURN::.] statement, which must be the last statement executed in the block. It is unnecessary to insert a semicolon before the END . Local variables, if any, are declared in the first statement immediately after BEGIN , and may be defined as SCALAR, INTEGER, or REAL . [*note ARRAY::.] variables declared within a BEGIN ...END block are global in every case, and [*note LET::.] statements have global effects. A [*note LET::.] statement involving a formal parameter affects the calling parameter that corresponds to it. [*note LET::.] statements involving local variables make global assignments, overwriting outside variables by the same name or creating them if they do not exist. You can use this feature to affect global variables from procedures, but be careful that you do not do it inadvertently. File: redhelp, Node: block, Next: COMMENT, Prev: BEGIN, Up: Syntax section BLOCK command A BLOCK is a sequence of statements enclosed by commands [*note BEGIN::.] and [*note END::.] . syntax: BEGIN <statement>; <statement>* END For more details see [*note BEGIN::.] . File: redhelp, Node: COMMENT, Next: CONS, Prev: block, Up: Syntax section COMMENT command Beginning with the word COMMENT , all text until the next statement terminator (; or $ ) is ignored. examples: ____________________________________________________________ x := a**2 comment--a is the velocity of the particle;; 2 X := A ____________________________________________________________ Note that the first semicolon ends the comment and the second one terminates the original REDUCE statement. Multiple-line comments are often needed in interactive files. The COMMENT command allows a normal-looking text to accompany the REDUCE statements in the file. File: redhelp, Node: CONS, Next: END, Prev: COMMENT, Up: Syntax section CONS operator The CONS operator adds a new element to the beginning of a [*note LIST::.] . Its operation is identical to the symbol [*note dot::.] (dot). It can be used infix or prefix. syntax: CONS (<item>,<list>) or <item> CONS <list> <item> can be any REDUCE scalar expression, including a list; <list> must be a list. examples: ____________________________________________________________ liss := cons(a,{b}); {A,B} liss := c cons liss; {C,A,B} newliss := for each y in liss collect cons(y,list x); NEWLISS := {{C,X},{A,X},{B,X}} for each y in newliss sum (first y)*(second y); X*(A + B + C) ____________________________________________________________ If you want to use CONS to put together two elements into a new list, you must make the second one into a list with curly brackets or the LIST command. You can also start with an empty list created by [] . The CONS operator is right associative: A CONS B CONS C is valid if C is a list; B need not be a list. The list produced is [A,B,C] . File: redhelp, Node: END, Next: EQUATION, Prev: CONS, Up: Syntax section END command The command END has two main uses: (i) as the ending of a [*note BEGIN::.] ...END [*note block::.] ; and (ii) to end input from a file. In a BEGIN ...END [*note block::.] , there need not be a delimiter (; or $ ) before the END , though there must be one after it, or a right bracket matching an earlier left bracket. Files to be read into REDUCE should end with END; , which must be preceded by a semicolon (usually the last character of the previous line). The additional semicolon avoids problems with mistakes in the files. If you have suspended file operation by answering N to a PAUSE command, you are still, technically speaking, "in" the file. Use END to exit the file. An END at the top level of a program is ignored. File: redhelp, Node: EQUATION, Next: FIRST, Prev: END, Up: Syntax section EQUATION type An EQUATION is an expression where two algebraic expressions are connected by the (infix) operator [*note EQUAL::.] or by = . For access to the components of an EQUATION the operators [*note LHS::.] , [*note RHS::.] or [*note PART::.] can be used. The evaluation of the left-hand side of an EQUATION is controlled by the switch [*note EVALLHSEQP::.] , while the right-hand side is evaluated unconditionally. When an EQUATION is part of a logical expression, e.g. in a [*note IF::.] or [*note WHILE::.] statement, the equation is evaluated by subtracting both sides can comparing the result with zero. Equations occur in many contexts, e.g. as arguments of the [*note SUB::.] operator and in the arguments and the results of the operator [*note SOLVE::.] . An equation can be member of a [*note LIST::.] and you may assign an equation to a variable. Elementary arithmetic is supported for equations: if [*note EVALLHSEQP::.] is on, you may add and subtract equations, and you can combine an equation with a scalar expression by addition, subtraction, multiplication, division and raise an equation to a power. examples: ____________________________________________________________ on evallhseqp; u:=x+y=1$ v:=2x-y=0$ 2*u-v; - 3*y=-2 ws/3; 2 y=-- 3 ____________________________________________________________ Important: the equation must occur in the leftmost term of such an expression. For other operations, e.g. taking function values of both sides, use the [*note MAP::.] operator. File: redhelp, Node: FIRST, Next: FOR, Prev: EQUATION, Up: Syntax section FIRST operator The FIRST operator returns the first element of a [*note LIST::.] . syntax: FIRST (<list>) or FIRST <list> <list> must be a non-empty list to avoid an error message. examples: ____________________________________________________________ alist := {a,b,c,d}; ALIST := {A,B,C,D} first alist; A blist := {x,y,{ww,aa,qq},z}; BLIST := {X,Y,{WW,AA,QQ},Z} first third blist; WW ____________________________________________________________ File: redhelp, Node: FOR, Next: FOREACH, Prev: FIRST, Up: Syntax section FOR command The FOR command is used for iterative loops. There are many possible forms it can take. ____________________________________________________________ / / |STEP <number> UNTIL| |<var>:=<number>| |<number>| FOR| | : | |<action> <exprn> | / | |EACH <var> IN <list> | / where <action> ::= DO|PRODUCT|SUM|COLLECT|JOIN. ____________________________________________________________ <var> can be any valid REDUCE identifier except T or NIL , <inc>, <start> and <stop> can be any expression that evaluates to a positive or negative integer. <list> must be a valid [*note LIST::.] structure. The action taken must be one of the actions shown above, each of which is followed by a single REDUCE expression, statement or a [*note group::.] (<< ...>> ) or [*note block::.] ([*note BEGIN::.] ...[*note END::.] ) statement. examples: ____________________________________________________________ for i := 1:10 sum i; 55 for a := -2 step 3 until 6 product a; -8 a := 3; A := 3 for iter := 4:a do write iter; m := 0; M := 0 for s := 10 step -1 until 3 do <<d := 10*s;m := m + d>>; m; 520 for each x in {q,r,s} sum x**2; 2 2 2 Q + R + S for i := 1:4 collect 1/i; 1 1 1 {1,-,-,-} 2 3 4 for i := 1:3 join list solve(x**2 + i*x + 1,x); SQRT(3)*I + 1 {{X= --------------, 2 SQRT(3)*I - 1 X= --------------} 2 {X=-1}, SQRT(5) + 3 SQRT(5) - 3 {X= - -----------,X=-----------}} 2 2 ____________________________________________________________ The behavior of each of the five action words follows: ____________________________________________________________ Action Word Behavior Keyword Argument Type Action do statement, command, group Evaluates its argument once or block for each iteration of the loop, not saving results collect expression, statement, Evaluates its argument once for command, group, block, list each iteration of the loop, storing the results in a list which is returned by the for statement when done join list or an operator which Evaluates its argument once for produces a list each iteration of the loop, appending the elements in each individual result list onto the overall result list product expression, statement, Evaluates its argument once for command, group or block each iteration of the loop, multiplying the results together and returning the overall product sum expression, statement, Evaluates its argument once for command, group or block each iteration of the loop, adding the results together and returning the overall sum ____________________________________________________________ For number-driven FOR statements, if the ending limit is smaller than the beginning limit (larger in the case of negative steps) the action statement is not executed at all. The iterative variable is local to the FOR statement, and does not affect the value of an identifier with the same name. For list-driven FOR statements, if the list is empty, the action statement is not executed, but no error occurs. You can use nested FOR statements, with the inner FOR statement after the action keyword. You must make sure that your inner statement returns an expression that the outer statement can handle. File: redhelp, Node: FOREACH, Next: GEQ, Prev: FOR, Up: Syntax section FOREACH command FOREACH is a synonym for the FOR EACH variant of the [*note FOR::.] construct. It is designed to iterate down a list, and an error will occur if a list is not used. The use of FOR EACH is preferred to FOREACH . syntax: FOREACH <variable> in <list> <action> <expression> where <action> ::= DO PRODUCT SUM COLLECT JOIN examples: ____________________________________________________________ foreach x in {q,r,s} sum x**2; 2 2 2 Q + R + S ____________________________________________________________ File: redhelp, Node: GEQ, Next: GOTO, Prev: FOREACH, Up: Syntax section GEQ operator The GEQ operator is a binary infix or prefix logical operator. It returns true if its first argument is greater than or equal to its second argument. As an infix operator it is identical with >= . syntax: GEQ (<expression>,<expression>) or <expression> GEQ <expression> <expression> can be any valid REDUCE expression that evaluates to a number. examples: ____________________________________________________________ a := 20; A := 20 if geq(a,25) then write "big" else write "small"; small if a geq 20 then write "big" else write "small"; big if (a geq 18) then write "big" else write "small"; big ____________________________________________________________ Logical operators can only be used in conditional statements such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...UNTIL . File: redhelp, Node: GOTO, Next: GREATERP, Prev: GEQ, Up: Syntax section GOTO command Inside a BEGIN ...END [*note block::.] , GOTO , or preferably, GO TO , transfers flow of control to a labeled statement. syntax: GO TO <labeled_statement> or GOTO <labeled_statement> <labeled_statement> is of the form <label> : <statement> examples: ____________________________________________________________ procedure dumb(a); begin scalar q; go to lab; q := df(a**2 - sin(a),a); write q; lab: return a end; DUMB dumb(17); 17 ____________________________________________________________ GO TO can only be used inside a BEGIN ...END [*note block::.] , and inside the block only statements at the top level can be labeled, not ones inside << ...>> , [*note WHILE::.] ...DO , etc. File: redhelp, Node: GREATERP, Next: IF, Prev: GOTO, Up: Syntax section GREATERP operator The GREATERP logical operator returns true if its first argument is strictly greater than its second argument. As an infix operator it is identical with > . syntax: GREATERP (<expression>,<expression>) or <expression> GREATERP <expression> <expression> can be any valid REDUCE expression that evaluates to a number. examples: ____________________________________________________________ a := 20; A := 20 if greaterp(a,25) then write "big" else write "small"; small if a greaterp 20 then write "big" else write "small"; small if (a greaterp 18) then write "big" else write "small"; big ____________________________________________________________ Logical operators can only be used in conditional statements such as [*note IF::.] ...THEN ...ELSE or [*note REPEAT::.] ...[*note WHILE::.] . File: redhelp, Node: IF, Next: LIST, Prev: GREATERP, Up: Syntax section IF command The IF command is a conditional statement that executes a statement if a condition is true, and optionally another statement if it is not. syntax: IF <condition> THEN <statement> option(ELSE <statement>) <condition> must be a logical or comparison operator that evaluates to a [*note boolean value::.] . <statement> must be a single REDUCE statement or a [*note group::.] (<< ...>> ) or [*note block::.] (BEGIN ...END ) statement. examples: ____________________________________________________________ if x = 5 then a := b+c else a := d+f; D + F x := 9; X := 9 if numberp x and x<20 then y := sqrt(x) else write "illegal"; 3 clear x; if numberp x and x<20 then y := sqrt(x) else write "illegal"; illegal x := 12; X := 12 a := if x < 5 then 100 else 150; A := 150 b := u**(if x < 10 then 2); B := 1 bb := u**(if x > 10 then 2); 2 BB := U ____________________________________________________________ An IF statement may be used inside an assignment statement and sets its value depending on the conditions, or used anywhere else an expression would be valid, as shown in the last example. If there is no ELSE clause, the value is 0 if a number is expected, and nothing otherwise. The ELSE clause may be left out if no action is to be taken if the condition is false. The condition may be a compound conditional statement using [*note AND::.] or [*note OR::.] . If a non-conditional statement, such as a constant, is used by accident, it is assumed to have value true. Be sure to use [*note group::.] or [*note block::.] statements after THEN or ELSE . The IF operator is right associative. The following constructions are examples: (1) syntax: IF <condition> THEN IF <condition> THEN <action> ELSE <action> which is equivalent to syntax: IF <condition> THEN (IF <condition> THEN <action> ELSE <action>); (2) syntax: IF <condition> THEN <action> ELSE IF <condition> THEN <action> ELSE <action> which is equivalent to syntax: IF <condition> THEN <action> ELSE (IF <condition> THEN <action> ELSE <action>). File: redhelp, Node: LIST, Next: OR, Prev: IF, Up: Syntax section LIST operator The LIST operator constructs a list from its arguments. syntax: LIST (<item> ,<item>*) or LIST () to construct an empty list. <item> can be any REDUCE scalar expression, including another list. Left and right curly brackets can also be used instead of the operator LIST to construct a list. examples: ____________________________________________________________ liss := list(c,b,c,{xx,yy},3x**2+7x+3,df(sin(2*x),x)); 2 LISS := {C,B,C,{XX,YY},3*X + 7*X + 3,2*COS(2*X)} length liss; 6 liss := {c,b,c,{xx,yy},3x**2+7x+3,df(sin(2*x),x)}; 2 LISS := {C,B,C,{XX,YY},3*X + 7*X + 3,2*COS(2*X)} emptylis := list(); EMPTYLIS := {} a . emptylis; {A} ____________________________________________________________ Lists are ordered, hierarchical structures. The elements stay where you put them, and only change position in the list if you specifically change them. Lists can have nested sublists to any (reasonable) level. The [*note PART::.] operator can be used to access elements anywhere within a list hierarchy. The [*note LENGTH::.] operator counts the number of top-level elements of its list argument; elements that are themselves lists still only count as one element. File: redhelp, Node: OR, Next: PROCEDURE, Prev: LIST, Up: Syntax section OR operator The OR binary logical operator returns true if either one or both of its arguments is true. syntax: <logical expression> OR <logical expression> <logical expression> must evaluate to true or nil. examples: ____________________________________________________________ a := 10; A := 10 if a<0 or a>140 then write "not a valid human age" else write "age = ",a; age = 10 a := 200; A := 200 if a < 0 or a > 140 then write "not a valid human age"; not a valid human age ____________________________________________________________ The OR operator is left associative: X OR Y OR Z is equivalent to (X OR Y) OR Z . Logical operators can only be used in conditional expressions, such as [*note IF::.] ...THEN ...ELSE and [*note WHILE::.] ...DO . OR evaluates its arguments in order and quits, returning true, on finding the first true statement. File: redhelp, Node: PROCEDURE, Next: REPEAT, Prev: OR, Up: Syntax section PROCEDURE command The PROCEDURE command allows you to define a mathematical operation as a function with arguments. syntax: <option> PROCEDURE <identifier> (<arg>,<arg>+); <body> The <option> may be [*note ALGEBRAIC::.] or [*note SYMBOLIC::.] , indicating the mode under which the procedure is executed, or [*note REAL::.] or [*note INTEGER::.] , indicating the type of answer expected. The default is algebraic. Real or integer procedures are subtypes of algebraic procedures; type-checking is done on the results of integer procedures, but not on real procedures (in the current REDUCE release). <identifier> may be any valid REDUCE identifier that is not already a procedure name, operator, [*note ARRAY::.] or [*note MATRIX::.] . <arg> is a formal parameter that may be any valid REDUCE identifier. <body> is a single statement (a [*note group::.] or [*note block::.] statement may be used) with the desired activities in it. examples: ____________________________________________________________ procedure fac(n); if not (fixp(n) and n>=0) then rederr "Choose nonneg. integer only" else for i := 0:n-1 product i+1; FAC fac(0); 1 fac(5); 120 fac(-5); ***** choose nonneg. integer only ____________________________________________________________ Procedures are automatically declared as operators upon definition. When REDUCE has parsed the procedure definition and successfully converted it to a form for its own use, it prints the name of the procedure. Procedure definitions cannot be nested. Procedures can call other procedures, or can recursively call themselves. Procedure identifiers can be cleared as you would clear an operator. Unlike [*note LET::.] statements, new definitions under the same procedure name replace the previous definitions completely. Be careful not to use the name of a system operator for your own procedure. REDUCE may or may not give you a warning message. If you redefine a system operator in your own procedure, the original function of the system operator is lost for the remainder of the REDUCE session. Procedures may have none, one, or more than one parameter. A REDUCE parameter is a formal parameter only; the use of x as a parameter in a PROCEDURE definition has no connection with a value of x in the REDUCE session, and the results of calling a procedure have no effect on the value of x. If a procedure is called with x as a parameter, the current value of x is used as specified in the computation, but is not changed outside the procedure. Making an assignment statement by := with a formal parameter on the left-hand side only changes the value of the calling parameter within the procedure. Using a [*note LET::.] statement inside a procedure always changes the value globally: a LET with a formal parameter makes the change to the calling parameter. LET statements cannot be made on local variables inside [*note BEGIN::.] ...END [*note block::.] S . When [*note CLEAR::.] statements are used on formal parameters, the calling variables associated with them are cleared globally too. The use of LET or CLEAR statements inside procedures should be done with extreme caution. Arrays and operators may be used as parameters to procedures. The body of the procedure can contain statements that appropriately manipulate these arguments. Changes are made to values of the calling arrays or operators. Simple expressions can also be used as arguments, in the place of scalar variables. Matrices may not be used as arguments to procedures. A procedure that has no parameters is called by the procedure name, immediately followed by empty parentheses. The empty parentheses may be left out when writing a procedure with no parameters, but must appear in a call of the procedure. If this is a nuisance to you, use a [*note LET::.] statement on the name of the procedure (i.e., LET NOARGS = NOARGS() ) after which you can call the procedure by just its name. Procedures that have a single argument can leave out the parentheses around it both in the definition and procedure call. (You can use the parentheses if you wish.) Procedures with more than one argument must use parentheses, with the arguments separated by commas. Procedures often have a BEGIN ...END block in them. Inside the block, local variables are declared using SCALAR , REAL or INTEGER declarations. The declarations must be made immediately after the word BEGIN , and if more than one type of declaration is made, they are separated by semicolons. REDUCE currently does no type checking on local variables; REAL and INTEGER are treated just like SCALAR . Actions take place as specified in the statements inside the block statement. Any identifiers that are not formal parameters or local variables are treated as global variables, and activities involving these identifiers are global in effect. If a return value is desired from a procedure call, a specific [*note RETURN::.] command must be the last statement executed before exiting from the procedure. If no RETURN is used, a procedure returns a zero or no value. Procedures are often written in a file using an editor, then the file is input using the command [*note IN::.] . This method allows easy changes in development, and also allows you to load the named procedures whenever you like, by loading the files that contain them. File: redhelp, Node: REPEAT, Next: REST, Prev: PROCEDURE, Up: Syntax section REPEAT command The [*note REPEAT::.] command causes repeated execution of a statement UNTIL the given condition is found to be true. The statement is always executed at least once. syntax: REPEAT <statement> UNTIL <condition> <statement> can be a single statement, [*note group::.] statement, or a BEGIN ...END [*note block::.] . <condition> must be a logical operator that evaluates to true or nil. examples: ____________________________________________________________ <<m := 4; repeat <<write 100*x*m;m := m-1>> until m = 0>>; 400*X 300*X 200*X 100*X <<m := -1; repeat <<write m; m := m-1>> until m <= 0>>; -1 ____________________________________________________________ REPEAT must always be followed by an UNTIL with a condition. Be careful not to generate an infinite loop with a condition that is never true. In the second example, if the condition had been M = 0 , it would never have been true since M already had value -2 when the condition was first evaluated. File: redhelp, Node: REST, Next: RETURN, Prev: REPEAT, Up: Syntax section REST operator The REST operator returns a [*note LIST::.] containing all but the first element of the list it is given. syntax: REST (<list>) or REST <list> <list> must be a non-empty list, but need not have more than one element. examples: ____________________________________________________________ alist := {a,b,c,d}; ALIST := {A,B,C,D}; rest alist; {B,C,D} blist := {x,y,{aa,bb,cc},z}; BLIST := {X,Y,{AA,BB,CC},Z} second rest blist; {AA,BB,CC} clist := {c}; CLIST := C rest clist; {} ____________________________________________________________ File: redhelp, Node: RETURN, Next: REVERSE, Prev: REST, Up: Syntax section RETURN command The RETURN command causes a value to be returned from inside a BEGIN ...END [*note block::.] . syntax: BEGIN <statements> RETURN <(expression)> END <statements> can be any valid REDUCE statements. The value of <expression> is returned. examples: ____________________________________________________________ begin write "yes"; return a end; yes A procedure dumb(a); begin if numberp(a) then return a else return 10 end; DUMB dumb(x); 10 dumb(-5); -5 procedure dumb2(a); begin c := a**2 + 2*a + 1; d := 17; c*d; return end; DUMB2 dumb2(4); c; 25 d; 17 ____________________________________________________________ Note in DUMB2 above that the assignments were made as requested, but the product C*D cannot be accessed. Changing the procedure to read RETURN C*D would remedy this problem. The RETURN statement is always the last statement executed before leaving the block. If RETURN has no argument, the block is exited but no value is returned. A block statement does not need a RETURN ; the statements inside terminate in their normal fashion without one. In that case no value is returned, although the specified actions inside the block take place. The RETURN command can be used inside << ...>> [*note group::.] statements and [*note IF::.] ...THEN ...ELSE commands that are inside BEGIN ...END [*note block::.] s. It is not valid in these constructions that are not inside a BEGIN ...END block. It is not valid inside [*note FOR::.] , [*note REPEAT::.] ...UNTIL or [*note WHILE::.] ...DO loops in any construction. To force early termination from loops, the GO TO ([*note GOTO::.] ) command must be used. When you use nested block statements, a RETURN from an inner block exits returning a value to the next-outermost block, rather than all the way to the outside. File: redhelp, Node: REVERSE, Next: RULE, Prev: RETURN, Up: Syntax section REVERSE operator The REVERSE operator returns a [*note LIST::.] that is the reverse of the list it is given. syntax: REVERSE (<list>) or REVERSE <list> <list> must be a [*note LIST::.] . examples: ____________________________________________________________ aa := {c,b,a,{x**2,z**3},y}; 2 3 AA := {C,B,A,{X ,Z },Y} reverse aa; 2 3 {Y,{X ,Z },A,B,C} reverse(q . reverse aa); 2 3 {C,B,A,{X ,Z },Y,Q} ____________________________________________________________ REVERSE and [*note CONS::.] can be used together to add a new element to the end of a list (. adds its new element to the beginning). The REVERSE operator uses a noticeable amount of system resources, especially if the list is long. If you are doing much heavy-duty list manipulation, you should probably design your algorithms to avoid much reversing of lists. A moderate amount of list reversing is no problem. File: redhelp, Node: RULE, Next: Free Variable, Prev: REVERSE, Up: Syntax section RULE type A RULE is an instruction to replace an algebraic expression or a part of an expression by another one. syntax: <lhs> => <rhs> or <lhs> => <rhs> WHEN <cond> <lhs> is an algebraic expression used as search pattern and <rhs> is an algebraic expression which replaces matches of <rhs>. => is the operator [*note replace::.] . <lhs> can contain [*note Free Variable::.] s which are symbols preceded by a tilde ^ in their leftmost position in <lhs>. A double tilde marks an [*note Optional Free Variable::.] . If a rule has a WHEN <cond> part it will fire only if the evaluation of <cond> has a result [*note TRUE::.] . <cond> may contain references to free variables of <lhs>. Rules can be collected in a [*note LIST::.] which then forms a RULE LIST . RULE LISTS can be used to collect algebraic knowledge for a specific evaluation context. RULES and RULE LISTS are globally activated and deactivated by [*note LET::.] , [*note FORALL::.] , [*note CLEARRULES::.] . For a single evaluation they can be locally activate by [*note WHERE::.] . The active rules for an operator can be visualized by [*note SHOWRULES::.] . examples: ____________________________________________________________ operator f,g,h; let f(x) => x^2; f(x); 2 x g_rules:={g(~n,~x)=>h(n/2,x) when evenp n, g(~n,~x)=>h((1-n)/2,x) when not evenp n}$ let g_rules; g(3,x); h(-1,x) ____________________________________________________________ File: redhelp, Node: Free Variable, Next: Optional Free Variable, Prev: RULE, Up: Syntax section FREE VARIABLE type A variable preceded by a tilde is considered as FREE VARIABLE and stands for an arbitrary part in an algebraic form during pattern matching. Free variables occur in the left-hand sides of [*note RULE::.] s, in the side relations for [*note COMPACT::.] and in the first arguments of [*note MAP::.] and [*note SELECT::.] calls. See [*note RULE::.] for examples. In rules also [*note Optional Free Variable::.] s may occur. File: redhelp, Node: Optional Free Variable, Next: SECOND, Prev: Free Variable, Up: Syntax section OPTIONAL FREE VARIABLE type A variable preceded by a double tilde is considered as OPTIONAL FREE VARIABLE and stands for an arbitrary part part in an algebraic form during pattern matching. In contrast to ordinary [*note Free Variable::.] s an operator pattern with an OPTIONAL FREE VARIABLE matches also if the operand for the variable is missing. In such a case the variable is bound to a neutral value. Optional free variables can be used as term in a sum: set to 0 if missing, factor in a product: set to 1 if missing, exponent: set to 1 if missing examples: ____________________________________________________________ ____________________________________________________________ Optional free variables are allowed only in the left-hand sides of [*note RULE::.] s. File: redhelp, Node: SECOND, Next: SET, Prev: Optional Free Variable, Up: Syntax section SECOND operator The SECOND operator returns the second element of a list. syntax: SECOND (<list>) or SECOND <list> <list> must be a list with at least two elements, to avoid an error message. examples: ____________________________________________________________ alist := {a,b,c,d}; ALIST := {A,B,C,D} second alist; B blist := {x,{aa,bb,cc},z}; BLIST := {X,{AA,BB,CC},Z} second second blist; BB ____________________________________________________________ File: redhelp, Node: SET, Next: SETQ, Prev: SECOND, Up: Syntax section SET operator The SET operator is used for assignments when you want both sides of the assignment statement to be evaluated. syntax: SET (<restricted_expression>,<expression>) <expression> can be any REDUCE expression; <restricted_expression> must be an identifier or an expression that evaluates to an identifier. examples: ____________________________________________________________ a := y; A := Y set(a,sin(x^2)); 2 SIN(X ) a; 2 SIN(X ) y; 2 SIN(X ) a := b + c; A := B + C set(a-c,z); Z b; Z ____________________________________________________________ Using an [*note ARRAY::.] or [*note MATRIX::.] reference as the first argument to SET has the result of setting the contents of the designated element to SET 's second argument. You should be careful to avoid unwanted side effects when you use this facility. File: redhelp, Node: SETQ, Next: THIRD, Prev: SET, Up: Syntax section SETQ operator The SETQ operator is an infix or prefix binary assignment operator. It is identical to := . syntax: SETQ (<restricted_expression>,<expression>) or <restricted_expression> SETQ <expression> <restricted expression> is ordinarily a single identifier, though simple expressions may be used (see Comments below). <expression> can be any valid REDUCE expression. If <expression> is a [*note MATRIX::.] identifier, then <restricted_expression> can be a matrix identifier (redimensioned if necessary), which has each element set to the corresponding elements of the identifier on the right-hand side. examples: ____________________________________________________________ setq(b,6); B := 6 c setq sin(x); C := SIN(X) w + setq(c,x+3) + z; W + X + Z + 3 c; X + 3 setq(a1 + a2,25); A1 + A2 := 25 a1; - (A2 - 25) ____________________________________________________________ Embedding a SETQ statement in an expression has the side effect of making the assignment, as shown in the third example above. Assignments are generally done for identifiers, but may be done for simple expressions as well, subject to the following remarks: (i) If the left-hand side is an identifier, an operator, or a power, the rule is added to the rule table. (ii) If the operators - + / appear on the left-hand side, all but the first term of the expression is moved to the right-hand side. (iii) If the operator * appears on the left-hand side, any constant terms are moved to the right-hand side, but the symbolic factors remain. Be careful not to make a recursive SETQ assignment that is not controlled inside a loop statement. The process of resubstitution continues until you get a stack overflow message. SETQ can be used to attach functionality to operators, as the := does. File: redhelp, Node: THIRD, Next: WHEN, Prev: SETQ, Up: Syntax section THIRD operator The THIRD operator returns the third item of a [*note LIST::.] . syntax: THIRD (<list>) or THIRD <list> <list> must be a list containing at least three items to avoid an error message. examples: ____________________________________________________________ alist := {a,b,c,d}; ALIST := {A,B,C,D} third alist; C blist := {x,{aa,bb,cc},y,z}; BLIST := {X,{AA,BB,CC},Y,Z}; third second blist; CC third blist; Y ____________________________________________________________ File: redhelp, Node: WHEN, Prev: THIRD, Up: Syntax section WHEN operator The WHEN operator is used inside a RULE to make the execution of the rule depend on a boolean condition which is evaluated at execution time. For the use see [*note RULE::.] . File: redhelp, Node: Syntax section, Next: Arithmetic Operations section, Prev: Variables section, Up: Top Syntax section * Menu: * semicolon:: ; command * dollar:: command * percent:: % command * dot:: . operator * assign:: := operator * equalsign:: = operator * replace:: => operator * plussign:: + operator * minussign:: - operator * asterisk:: * operator * slash:: / operator * power:: ** operator * caret:: ^ operator * geqsign:: >= operator * greater:: > operator * leqsign:: <= operator * less:: < operator * tilde:: ~ operator * group:: << command * AND:: operator * BEGIN:: command * block:: command * COMMENT:: command * CONS:: operator * END:: command * EQUATION:: type * FIRST:: operator * FOR:: command * FOREACH:: command * GEQ:: operator * GOTO:: command * GREATERP:: operator * IF:: command * LIST:: operator * OR:: operator * PROCEDURE:: command * REPEAT:: command * REST:: operator * RETURN:: command * REVERSE:: operator * RULE:: type * Free Variable:: type * Optional Free Variable:: type * SECOND:: operator * SET:: operator * SETQ:: operator * THIRD:: operator * WHEN:: operator File: redhelp, Node: ARITHMETIC_OPERATIONS, Next: ABS, Up: Arithmetic Operations section ARITHMETIC_OPERATIONS introduction This section considers operations defined in REDUCE that concern numbers, or operators that can operate on numbers in addition, in most cases, to more general expressions. File: redhelp, Node: ABS, Next: ADJPREC, Prev: ARITHMETIC_OPERATIONS, Up: Arithmetic Operations section ABS operator The ABS operator returns the absolute value of its argument. syntax: ABS (<expression>) <expression> can be any REDUCE scalar expression. examples: ____________________________________________________________ abs(-a); ABS(A) abs(-5); 5 a := -10; A := -10 abs(a); 10 abs(-a); 10 ____________________________________________________________ If the argument has had no numeric value assigned to it, such as an identifier or polynomial, ABS returns an expression involving ABS of its argument, doing as much simplification of the argument as it can, such as dropping any preceding minus sign. File: redhelp, Node: ADJPREC, Next: ARG, Prev: ABS, Up: Arithmetic Operations section ADJPREC switch When a real number is input, it is normally truncated to the [*note PRECISION::.] in effect at the time the number is read. If it is desired to keep the full precision of all numbers input, the switch ADJPREC (for <adjust precision>) can be turned on. While on, ADJPREC will automatically increase the precision, when necessary, to match that of any integer or real input, and a message printed to inform the user of the precision increase. examples: ____________________________________________________________ on rounded; 1.23456789012345; 1.23456789012 on adjprec; 1.23456789012345; *** precision increased to 15 ____________________________________________________________ File: redhelp, Node: ARG, Next: CEILING, Prev: ADJPREC, Up: Arithmetic Operations section ARG operator If [*note COMPLEX::.] and [*note ROUNDED::.] are on, and arg evaluates to a complex number, ARG returns the polar angle of arg, measured in radians. Otherwise an expression in arg is returned. examples: ____________________________________________________________ arg(3+4i) ARG(3 + 4*I) on rounded, complex; ws; 0.927295218002 arg a; ARG(A) ____________________________________________________________ File: redhelp, Node: CEILING, Next: CHOOSE, Prev: ARG, Up: Arithmetic Operations section CEILING operator syntax: CEILING (<expression>) This operator returns the ceiling (i.e., the least integer greater than or equal to its argument) if its argument has a numerical value. For negative numbers, this is equivalent to [*note FIX::.] . For non-numeric arguments, the value is an expression in the original operator. examples: ____________________________________________________________ ceiling 3.4; 4 fix 3.4; 3 ceiling(-5.2); -5 fix(-5.2); -5 ceiling a; CEILING(A) ____________________________________________________________ File: redhelp, Node: CHOOSE, Next: DEG2DMS, Prev: CEILING, Up: Arithmetic Operations section CHOOSE operator CHOOSE (<m>,<m>) returns the number of ways of choosing <m> objects from a collection of <n> distinct objects -- in other words the binomial coefficient. If <m> and <n> are not positive integers, or m > n, the expression is returned unchanged. than or equal to examples: ____________________________________________________________ choose(2,3); 3 choose(3,2); CHOOSE(3,2) choose(a,b); CHOOSE(A,B) ____________________________________________________________ File: redhelp, Node: DEG2DMS, Next: DEG2RAD, Prev: CHOOSE, Up: Arithmetic Operations section DEG2DMS operator syntax: DEG2DMS (<expression>) In [*note ROUNDED::.] mode, if <expression> is a real number, the operator DEG2DMS will interpret it as degrees, and convert it to a list containing the equivalent degrees, minutes and seconds. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ deg2dms 60; DEG2DMS(60) on rounded; ws; {60,0,0} deg2dms 42.4; {42,23,60.0} deg2dms a; DEG2DMS(A) ____________________________________________________________ File: redhelp, Node: DEG2RAD, Next: DIFFERENCE, Prev: DEG2DMS, Up: Arithmetic Operations section DEG2RAD operator syntax: DEG2RAD (<expression>) In [*note ROUNDED::.] mode, if <expression> is a real number, the operator DEG2RAD will interpret it as degrees, and convert it to the equivalent radians. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ deg2rad 60; DEG2RAD(60) on rounded; ws; 1.0471975512 deg2rad a; DEG2RAD(A) ____________________________________________________________ File: redhelp, Node: DIFFERENCE, Next: DILOG, Prev: DEG2RAD, Up: Arithmetic Operations section DIFFERENCE operator The DIFFERENCE operator may be used as either an infix or prefix binary subtraction operator. It is identical to - as a binary operator. syntax: DIFFERENCE (<expression>,<expression>) or <expression> DIFFERENCE <expression> DIFFERENCE <expression>* <expression> can be a number or any other valid REDUCE expression. Matrix expressions are allowed if they are of the same dimensions. examples: ____________________________________________________________ difference(10,4); 6 15 difference 5 difference 2; 8 a difference b; A - B ____________________________________________________________ The DIFFERENCE operator is left associative, as shown in the second example above. File: redhelp, Node: DILOG, Next: DMS2DEG, Prev: DIFFERENCE, Up: Arithmetic Operations section DILOG operator The DILOG operator is known to the differentiation and integration operators, but has numeric value attached only at DILOG(0) . Dilog is defined by dilog(x) = -int(log(x),x)/(x-1) examples: ____________________________________________________________ df(dilog(x**2),x); 2 2*LOG(X )*X - ------------ 2 X - 1 int(dilog(x),x); DILOG(X)*X - DILOG(X) + LOG(X)*X - X dilog(0); 2 PI ---- 6 ____________________________________________________________ File: redhelp, Node: DMS2DEG, Next: DMS2RAD, Prev: DILOG, Up: Arithmetic Operations section DMS2DEG operator syntax: DMS2DEG (<list>) In [*note ROUNDED::.] mode, if <list> is a list of three real numbers, the operator DMS2DEG will interpret the list as degrees, minutes and seconds and convert it to the equivalent degrees. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ dms2deg {42,3,7}; DMS2DEG({42,3,7}) on rounded; ws; 42.0519444444 dms2deg a; DMS2DEG(A) ____________________________________________________________ File: redhelp, Node: DMS2RAD, Next: FACTORIAL, Prev: DMS2DEG, Up: Arithmetic Operations section DMS2RAD operator syntax: DMS2RAD (<list>) In [*note ROUNDED::.] mode, if <list> is a list of three real numbers, the operator DMS2RAD will interpret the list as degrees, minutes and seconds and convert it to the equivalent radians. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ dms2rad {42,3,7}; DMS2RAD({42,3,7}) on rounded; ws; 0.733944887421 dms2rad a; DMS2RAD(A) ____________________________________________________________ File: redhelp, Node: FACTORIAL, Next: FIX, Prev: DMS2RAD, Up: Arithmetic Operations section FACTORIAL operator syntax: FACTORIAL (<expression>) If the argument of FACTORIAL is a positive integer or zero, its factorial is returned. Otherwise the result is expressed in terms of the original operator. For more general operations, the [*note GAMMA::.] operator is available in the [*note Special Function Package::.] . examples: ____________________________________________________________ factorial 4; 24 factorial 30 ; 265252859812191058636308480000000 ____________________________________________________________ File: redhelp, Node: FIX, Next: FIXP, Prev: FACTORIAL, Up: Arithmetic Operations section FIX operator syntax: FIX (<expression>) The operator FIX returns the integer part of its argument, if that argument has a numerical value. For positive numbers, this is equivalent to [*note FLOOR::.] , and, for negative numbers, [*note CEILING::.] . For non-numeric arguments, the value is an expression in the original operator. examples: ____________________________________________________________ fix 3.4; 3 floor 3.4; 3 ceiling 3.4; 4 fix(-5.2); -5 floor(-5.2); -6 ceiling(-5.2); -5 fix(a); FIX(A) ____________________________________________________________ File: redhelp, Node: FIXP, Next: FLOOR, Prev: FIX, Up: Arithmetic Operations section FIXP operator The FIXP logical operator returns true if its argument is an integer. syntax: FIXP (<expression>) or FIXP <simple_expression> <expression> can be any valid REDUCE expression, <simple_expression> must be a single identifier or begin with a prefix operator. examples: ____________________________________________________________ if fixp 1.5 then write "ok" else write "not"; not if fixp(a) then write "ok" else write "not"; not a := 15; A := 15 if fixp(a) then write "ok" else write "not"; ok ____________________________________________________________ Logical operators can only be used inside conditional expressions such as IF ...THEN or WHILE ...DO . File: redhelp, Node: FLOOR, Next: EXPT, Prev: FIXP, Up: Arithmetic Operations section FLOOR operator syntax: FLOOR (<expression>) This operator returns the floor (i.e., the greatest integer less than or equal to its argument) if its argument has a numerical value. For positive numbers, this is equivalent to [*note FIX::.] . For non-numeric arguments, the value is an expression in the original operator. examples: ____________________________________________________________ floor 3.4; 3 fix 3.4; 3 floor(-5.2); -6 fix(-5.2); -5 floor a; FLOOR(A) ____________________________________________________________ File: redhelp, Node: EXPT, Next: GCD, Prev: FLOOR, Up: Arithmetic Operations section EXPT operator The EXPT operator is both an infix and prefix binary exponentiation operator. It is identical to ^ or ** . syntax: EXPT (<expression>,<expression>) or <expression> EXPT <expression> examples: ____________________________________________________________ a expt b; B A expt(a,b); B A (x+y) expt 4; 4 3 2 2 3 4 X + 4*X *Y + 6*X *Y + 4*X*Y + Y ____________________________________________________________ Scalar expressions may be raised to fractional and floating-point powers. Square matrix expressions may be raised to positive powers, and also to negative powers if non-singular. EXPT is left associative. In other words, A EXPT B EXPT C is equivalent to A EXPT (B*C) , not A EXPT (B EXPT C) , which would be right associative. File: redhelp, Node: GCD, Next: LN, Prev: EXPT, Up: Arithmetic Operations section GCD operator The GCD operator returns the greatest common divisor of two polynomials. syntax: GCD (<expression>,<expression>) <expression> must be a polynomial (or integer), otherwise an error occurs. examples: ____________________________________________________________ gcd(2*x**2 - 2*y**2,4*x + 4*y); 2*(X + Y) gcd(sin(x),x**2 + 1); 1 gcd(765,68); 17 ____________________________________________________________ The operator GCD described here provides an explicit means to find the gcd of two expressions. The switch GCD described below simplifies expressions by finding and canceling gcd's at every opportunity. When the switch [*note EZGCD::.] is also on, gcd's are figured using the EZ GCD algorithm, which is usually faster. File: redhelp, Node: LN, Next: LOG, Prev: GCD, Up: Arithmetic Operations section LN operator syntax: LN (<expression>) <expression> can be any valid scalar REDUCE expression. The LN operator returns the natural logarithm of its argument. However, unlike [*note LOG::.] , there are no algebraic rules associated with it; it will only evaluate when [*note ROUNDED::.] is on, and the argument is a real number. examples: ____________________________________________________________ ln(x); LN(X) ln 4; LN(4) ln(e); LN(E) df(ln(x),x); DF(LN(X),X) on rounded; ln 4; 1.38629436112 ln e; 1 ____________________________________________________________ Because of the restricted algebraic properties of LN , users are advised to use [*note LOG::.] whenever possible. File: redhelp, Node: LOG, Next: LOGB, Prev: LN, Up: Arithmetic Operations section LOG operator The LOG operator returns the natural logarithm of its argument. syntax: LOG (<expression>) or LOG <expression> <expression> can be any valid scalar REDUCE expression. examples: ____________________________________________________________ log(x); LOG(X) log 4; LOG(4) log(e); 1 on rounded; log 4; 1.38629436112 ____________________________________________________________ LOG returns a numeric value only when [*note ROUNDED::.] is on. In that case, use of a negative argument for LOG results in an error message. No error is given on a negative argument when REDUCE is not in that mode. File: redhelp, Node: LOGB, Next: MAX, Prev: LOG, Up: Arithmetic Operations section LOGB operator syntax: LOGB (<expression>,<integer>) <expression> can be any valid scalar REDUCE expression. The LOGB operator returns the logarithm of its first argument using the second argument as base. However, unlike [*note LOG::.] , there are no algebraic rules associated with it; it will only evaluate when [*note ROUNDED::.] is on, and the first argument is a real number. examples: ____________________________________________________________ logb(x,2); LOGB(X,2) logb(4,3); LOGB(4,3) logb(2,2); LOGB(2,2) df(logb(x,3),x); DF(LOGB(X,3),X) on rounded; logb(4,3); 1.26185950714 logb(2,2); 1 ____________________________________________________________ File: redhelp, Node: MAX, Next: MIN, Prev: LOGB, Up: Arithmetic Operations section MAX operator The operator MAX is an n-ary prefix operator, which returns the largest value in its arguments. syntax: MAX (<expression>,<expression>*) <expression> must evaluate to a number. MAX of an empty list returns 0. examples: ____________________________________________________________ max(4,6,10,-1); 10 <<a := 23;b := 2*a;c := 4**2;max(a,b,c)>>; 46 max(-5,-10,-a); -5 ____________________________________________________________ File: redhelp, Node: MIN, Next: MINUS, Prev: MAX, Up: Arithmetic Operations section MIN operator The operator MIN is an n-ary prefix operator, which returns the smallest value in its arguments. syntax: MIN (<expression>,<expression>*) <expression> must evaluate to a number. MIN of an empty list returns 0. examples: ____________________________________________________________ min(-3,0,17,2); -3 <<a := 23;b := 2*a;c := 4**2;min(a,b,c)>>; 16 min(5,10,a); 5 ____________________________________________________________ File: redhelp, Node: MINUS, Next: NEXTPRIME, Prev: MIN, Up: Arithmetic Operations section MINUS operator The MINUS operator is a unary minus, returning the negative of its argument. It is equivalent to the unary - . syntax: MINUS (<expression>) <expression> may be any scalar REDUCE expression. examples: ____________________________________________________________ minus(a); - A minus(-1); 1 minus((x+1)**4); 4 3 2 - (X + 4*X + 6*X + 4*X + 1) ____________________________________________________________ File: redhelp, Node: NEXTPRIME, Next: NOCONVERT, Prev: MINUS, Up: Arithmetic Operations section NEXTPRIME operator syntax: NEXTPRIME (<expression>) If the argument of NEXTPRIME is an integer, the least prime greater than that argument is returned. Otherwise, a type error results. examples: ____________________________________________________________ nextprime 5001; 5003 nextprime(10^30); 1000000000000000000000000000057 nextprime a; ***** A invalid as integer ____________________________________________________________ File: redhelp, Node: NOCONVERT, Next: NORM, Prev: NEXTPRIME, Up: Arithmetic Operations section NOCONVERT switch Under normal circumstances when ROUNDED is on, REDUCE converts the number 1.0 to the integer 1. If this is not desired, the switch NOCONVERT can be turned on. examples: ____________________________________________________________ on rounded; 1.0000000000001; 1 on noconvert; 1.0000000000001; 1.0 ____________________________________________________________ File: redhelp, Node: NORM, Next: PERM, Prev: NOCONVERT, Up: Arithmetic Operations section NORM operator syntax: NORM (<expression>) If ROUNDED is on, and the argument is a real number, <norm> returns its absolute value. If COMPLEX is also on, <norm> returns the square root of the sum of squares of the real and imaginary parts of the argument. In all other cases, a result is returned in terms of the original operator. examples: ____________________________________________________________ norm (-2); NORM(-2) on rounded; ws; 2.0 norm(3+4i); NORM(4*I+3) on complex; ws; 5.0 ____________________________________________________________ File: redhelp, Node: PERM, Next: PLUS, Prev: NORM, Up: Arithmetic Operations section PERM operator syntax: perm(<expression1>,<expression2>) If <expression1> and <expression2> evaluate to positive integers, PERM returns the number of permutations possible in selecting <expression1> objects from <expression2> objects. In other cases, an expression in the original operator is returned. examples: ____________________________________________________________ perm(1,1); 1 perm(3,5); 60 perm(-3,5); PERM(-3,5) perm(a,b); PERM(A,B) ____________________________________________________________ File: redhelp, Node: PLUS, Next: QUOTIENT, Prev: PERM, Up: Arithmetic Operations section PLUS operator The PLUS operator is both an infix and prefix n-ary addition operator. It exists because of the way in which REDUCE handles such operators internally, and is not recommended for use in algebraic mode programming. [*note plussign::.] , which has the identical effect, should be used instead. syntax: PLUS (<expression>,<expression>,<expression> *) or <expression> PLUS <expression> PLUS <expression>* <expression> can be any valid REDUCE expression, including matrix expressions of the same dimensions. examples: ____________________________________________________________ a plus b plus c plus d; A + B + C + D 4.5 plus 10; 29 -- 2 plus(x**2,y**2); 2 2 X + Y ____________________________________________________________ File: redhelp, Node: QUOTIENT, Next: RAD2DEG, Prev: PLUS, Up: Arithmetic Operations section QUOTIENT operator The QUOTIENT operator is both an infix and prefix binary operator that returns the quotient of its first argument divided by its second. It is also a unary [*note RECIP::.] rocal operator. It is identical to / and [*note slash::.] . syntax: QUOTIENT (<expression>,<expression>) or <expression> QUOTIENT <expression> or QUOTIENT (<expression>) or QUOTIENT <expression> <expression> can be any valid REDUCE scalar expression. Matrix expressions can also be used if the second expression is invertible and the matrices are of the correct dimensions. examples: ____________________________________________________________ quotient(a,x+1); A ----- X + 1 7 quotient 17; 7 -- 17 on rounded; 4.5 quotient 2; 2.25 quotient(x**2 + 3*x + 2,x+1); X + 2 matrix m,inverse; m := mat((a,b),(c,d)); M(1,1) := A; M(1,2) := B; M(2,1) := C M(2,2) := D inverse := quotient m; D INVERSE(1,1) := ---------- A*D - B*C B INVERSE(1,2) := - ---------- A*D - B*C C INVERSE(2,1) := - ---------- A*D - B*C A INVERSE(2,2) := ---------- A*D - B*C ____________________________________________________________ The QUOTIENT operator is left associative: A QUOTIENT B QUOTIENT C is equivalent to (A QUOTIENT B) QUOTIENT C . If a matrix argument to the unary QUOTIENT is not invertible, or if the second matrix argument to the binary quotient is not invertible, an error message is given. File: redhelp, Node: RAD2DEG, Next: RAD2DMS, Prev: QUOTIENT, Up: Arithmetic Operations section RAD2DEG operator syntax: RAD2DEG (<expression>) In [*note ROUNDED::.] mode, if <expression> is a real number, the operator RAD2DEG will interpret it as radians, and convert it to the equivalent degrees. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ rad2deg 1; RAD2DEG(1) on rounded; ws; 57.2957795131 rad2deg a; RAD2DEG(A) ____________________________________________________________ File: redhelp, Node: RAD2DMS, Next: RECIP, Prev: RAD2DEG, Up: Arithmetic Operations section RAD2DMS operator syntax: RAD2DMS (<expression>) In [*note ROUNDED::.] mode, if <expression> is a real number, the operator RAD2DMS will interpret it as radians, and convert it to a list containing the equivalent degrees, minutes and seconds. In all other cases, an expression in terms of the original operator is returned. examples: ____________________________________________________________ rad2dms 1; RAD2DMS(1) on rounded; ws; {57,17,44.8062470964} rad2dms a; RAD2DMS(A) ____________________________________________________________ File: redhelp, Node: RECIP, Next: REMAINDER, Prev: RAD2DMS, Up: Arithmetic Operations section RECIP operator RECIP is the alphabetical name for the division operator / or [*note slash::.] used as a unary operator. The use of / is preferred. examples: ____________________________________________________________ recip a; 1 - A recip 2; 1 -- 2 ____________________________________________________________ File: redhelp, Node: REMAINDER, Next: ROUND, Prev: RECIP, Up: Arithmetic Operations section REMAINDER operator The REMAINDER operator returns the remainder after its first argument is divided by its second argument. syntax: REMAINDER (<expression>,<expression>) <expression> can be any valid REDUCE polynomial, and is not limited to numeric values. examples: ____________________________________________________________ remainder(13,6); 1 remainder(x**2 + 3*x + 2,x+1); 0 remainder(x**3 + 12*x + 4,x**2 + 1); 11*X + 4 remainder(sin(2*x),x*y); SIN(2*X) ____________________________________________________________ In the default case, remainders are calculated over the integers. If you need the remainder with respect to another domain, it must be declared explicitly. If the first argument to REMAINDER contains a denominator not equal to 1, an error occurs. File: redhelp, Node: ROUND, Next: SETMOD, Prev: REMAINDER, Up: Arithmetic Operations section ROUND operator syntax: ROUND (<expression>) If its argument has a numerical value, ROUND rounds it to the nearest integer. For non-numeric arguments, the value is an expression in the original operator. examples: ____________________________________________________________ round 3.4; 3 round 3.5; 4 round a; ROUND(A) ____________________________________________________________ File: redhelp, Node: SETMOD, Next: SIGN, Prev: ROUND, Up: Arithmetic Operations section SETMOD command The SETMOD command sets the modulus value for subsequent [*note MODULAR::.] arithmetic. syntax: SETMOD <integer> <integer> must be positive, and greater than 1. It need not be a prime number. examples: ____________________________________________________________ setmod 6; 1 on modular; 16; 4 x^2 + 5x + 7; 2 X + 5*X + 1 x/3; X - 3 setmod 2; 6 (x+1)^4; 4 X + 1 x/3; X ____________________________________________________________ SETMOD returns the previous modulus, or 1 if none has been set before. SETMOD only has effect when [*note MODULAR::.] is on. Modular operations are done only on numbers such as coefficients of polynomials, not on the exponents. The modulus need not be prime. Attempts to divide by a power of the modulus produces an error message, since the operation is equivalent to dividing by 0. However, dividing by a factor of a non-prime modulus does not produce an error message. File: redhelp, Node: SIGN, Next: SQRT, Prev: SETMOD, Up: Arithmetic Operations section SIGN operator syntax: SIGN <expression> SIGN tries to evaluate the sign of its argument. If this is possible SIGN returns one of 1, 0 or -1. Otherwise, the result is the original form or a simplified variant. examples: ____________________________________________________________ sign(-5) -1 sign(-a^2*b) -SIGN(B) ____________________________________________________________ Even powers of formal expressions are assumed to be positive only as long as the switch [*note COMPLEX::.] is off. File: redhelp, Node: SQRT, Next: TIMES, Prev: SIGN, Up: Arithmetic Operations section SQRT operator The SQRT operator returns the square root of its argument. syntax: SQRT (<expression>) <expression> can be any REDUCE scalar expression. examples: ____________________________________________________________ sqrt(16*a^3); 4*SQRT(A)*A sqrt(17); SQRT(17) on rounded; sqrt(17); 4.12310562562 off rounded; sqrt(a*b*c^5*d^3*27); 2 3*SQRT(D)*SQRT(C)*SQRT(B)*SQRT(A)*SQRT(3)*C *D ____________________________________________________________ SQRT checks its argument for squared factors and removes them. Numeric values for square roots that are not exact integers are given only when [*note ROUNDED::.] is on. Please note that SQRT(A**2) is given as A , which may be incorrect if A eventually has a negative value. If you are programming a calculation in which this is a concern, you can turn on the [*note PRECISE::.] switch, which causes the absolute value of the square root to be returned. File: redhelp, Node: TIMES, Prev: SQRT, Up: Arithmetic Operations section TIMES operator The TIMES operator is an infix or prefix n-ary multiplication operator. It is identical to * . syntax: <expression> TIMES <expression> TIMES <expression>* or TIMES (<expression>,<expression> ,<expression>*) <expression> can be any valid REDUCE scalar or matrix expression. Matrix expressions must be of the correct dimensions. Compatible scalar and matrix expressions can be mixed. examples: ____________________________________________________________ var1 times var2; VAR1*VAR2 times(6,5); 30 matrix aa,bb; aa := mat((1),(2),(x))$ bb := mat((0,3,1))$ aa times bb times 5; [0 15 5 ] [ ] [0 30 10 ] [ ] [0 15*X 5*X] ____________________________________________________________ File: redhelp, Node: Arithmetic Operations section, Next: Boolean Operators section, Prev: Syntax section, Up: Top Arithmetic Operations section * Menu: * ARITHMETIC_OPERATIONS:: introduction * ABS:: operator * ADJPREC:: switch * ARG:: operator * CEILING:: operator * CHOOSE:: operator * DEG2DMS:: operator * DEG2RAD:: operator * DIFFERENCE:: operator * DILOG:: operator * DMS2DEG:: operator * DMS2RAD:: operator * FACTORIAL:: operator * FIX:: operator * FIXP:: operator * FLOOR:: operator * EXPT:: operator * GCD:: operator * LN:: operator * LOG:: operator * LOGB:: operator * MAX:: operator * MIN:: operator * MINUS:: operator * NEXTPRIME:: operator * NOCONVERT:: switch * NORM:: operator * PERM:: operator * PLUS:: operator * QUOTIENT:: operator * RAD2DEG:: operator * RAD2DMS:: operator * RECIP:: operator * REMAINDER:: operator * ROUND:: operator * SETMOD:: command * SIGN:: operator * SQRT:: operator * TIMES:: operator File: redhelp, Node: boolean value, Next: EQUAL, Up: Boolean Operators section BOOLEAN VALUE There are no extra symbols for the truth values true and false. Instead, [*note NIL::.] and the number zero are interpreted as truth value false in algebraic programs (see [*note false::.] ), while any different value is considered as true (see [*note TRUE::.] ). File: redhelp, Node: EQUAL, Next: EVENP, Prev: boolean value, Up: Boolean Operators section EQUAL operator The operator EQUAL is an infix binary comparison operator. It is identical with = . It returns [*note TRUE::.] if its two arguments are equal. syntax: <expression> EQUAL <expression> Equality is given between floating point numbers and integers that have the same value. examples: ____________________________________________________________ on rounded; a := 4; A := 4 b := 4.0; B := 4.0 if a equal b then write "true" else write "false"; true if a equal 5 then write "true" else write "false"; false if a equal sqrt(16) then write "true" else write "false"; true ____________________________________________________________ Comparison operators can only be used as conditions in conditional commands such as IF ...THEN and REPEAT ...UNTIL . <equal> can also be used as a prefix operator. However, this use is not encouraged. File: redhelp, Node: EVENP, Next: false, Prev: EQUAL, Up: Boolean Operators section EVENP operator The EVENP logical operator returns [*note TRUE::.] if its argument is an even integer, and [*note NIL::.] if its argument is an odd integer. An error message is returned if its argument is not an integer. syntax: EVENP (<integer>) or EVENP <integer> <integer> must evaluate to an integer. examples: ____________________________________________________________ aa := 1782; AA := 1782 if evenp aa then yes else no; YES if evenp(-3) then yes else no; NO ____________________________________________________________ Although you would not ordinarily enter an expression such as the last example above, note that the negative term must be enclosed in parentheses to be correctly parsed. The EVENP operator can only be used in conditional statements such as IF ...THEN ...ELSE or WHILE ...DO . File: redhelp, Node: false, Next: FREEOF, Prev: EVENP, Up: Boolean Operators section FALSE The symbol [*note NIL::.] and the number zero are considered as [*note boolean value::.] false if used in a place where a boolean value is required. Most builtin operators return [*note NIL::.] as false value. Algebraic programs use better zero. Note that NIL is not printed when returned as result to a top level evaluation. File: redhelp, Node: FREEOF, Next: LEQ, Prev: false, Up: Boolean Operators section FREEOF operator The FREEOF logical operator returns [*note TRUE::.] if its first argument does not contain its second argument anywhere in its structure. syntax: FREEOF (<expression>,<kernel>) or <expression> FREEOF <kernel> <expression> can be any valid scalar REDUCE expression, <kernel> must be a kernel expression (see KERNEL ). examples: ____________________________________________________________ a := x + sin(y)**2 + log sin z; 2 A := LOG(SIN(Z)) + SIN(Y) + X if freeof(a,sin(y)) then write "free" else write "not free"; not free if freeof(a,sin(x)) then write "free" else write "not free"; free if a freeof sin z then write "free" else write "not free"; not free ____________________________________________________________ Logical operators can only be used in conditional expressions such as IF ...THEN or WHILE ...DO . File: redhelp, Node: LEQ, Next: LESSP, Prev: FREEOF, Up: Boolean Operators section LEQ operator The LEQ operator is a binary infix or prefix logical operator. It returns [*note TRUE::.] if its first argument is less than or equal to its second argument. As an infix operator it is identical with <= . syntax: LEQ (<expression>,<expression>) or <expression> LEQ <expression> <expression> can be any valid REDUCE expression that evaluates to a number. examples: ____________________________________________________________ a := 15; A := 15 if leq(a,25) then write "yes" else write "no"; yes if leq(a,15) then write "yes" else write "no"; yes if leq(a,5) then write "yes" else write "no"; no ____________________________________________________________ Logical operators can only be used in conditional statements such as IF ...THEN ...ELSE or WHILE ...DO . File: redhelp, Node: LESSP, Next: MEMBER, Prev: LEQ, Up: Boolean Operators section LESSP operator The LESSP operator is a binary infix or prefix logical operator. It returns [*note TRUE::.] if its first argument is strictly less than its second argument. As an infix operator it is identical with < . syntax: LESSP (<expression>,<expression>) or <expression> LESSP <expression> <expression> can be any valid REDUCE expression that evaluates to a number. examples: ____________________________________________________________ a := 15; A := 15 if lessp(a,25) then write "yes" else write "no"; yes if lessp(a,15) then write "yes" else write "no"; no if lessp(a,5) then write "yes" else write "no"; no ____________________________________________________________ Logical operators can only be used in conditional statements such as IF ...THEN ...ELSE or WHILE ...DO . File: redhelp, Node: MEMBER, Next: NEQ, Prev: LESSP, Up: Boolean Operators section MEMBER operator syntax: <expression> MEMBER <list> MEMBER is an infix binary comparison operator that evaluates to [*note TRUE::.] if <expression> is [*note EQUAL::.] to a member of the [*note LIST::.] <list>. examples: ____________________________________________________________ if a member {a,b} then 1 else 0; 1 if 1 member(1,2,3) then a else b; a if 1 member(1.0,2) then a else b; b ____________________________________________________________ Logical operators can only be used in conditional statements such as IF ...THEN ...ELSE or WHILE ...DO . <member> can also be used as a prefix operator. However, this use is not encouraged. Finally, [*note EQUAL::.] (= ) is used for the test within the list, so expressions must be of the same type to match. File: redhelp, Node: NEQ, Next: NOT, Prev: MEMBER, Up: Boolean Operators section NEQ operator The operator NEQ is an infix binary comparison operator. It returns [*note TRUE::.] if its two arguments are not [*note EQUAL::.] . syntax: <expression> NEQ <expression> An inequality is satisfied between floating point numbers and integers that have the same value. examples: ____________________________________________________________ on rounded; a := 4; A := 4 b := 4.0; B := 4.0 if a neq b then write "true" else write "false"; false if a neq 5 then write "true" else write "false"; true ____________________________________________________________ Comparison operators can only be used as conditions in conditional commands such as IF ...THEN and REPEAT ...UNTIL . <neq> can also be used as a prefix operator. However, this use is not encouraged. File: redhelp, Node: NOT, Next: NUMBERP, Prev: NEQ, Up: Boolean Operators section NOT operator The NOT operator returns [*note TRUE::.] if its argument evaluates to [*note NIL::.] , and NIL if its argument is TRUE . syntax: NOT (<logical expression>) examples: ____________________________________________________________ if not numberp(a) then write "indeterminate" else write a; indeterminate; a := 10; A := 10 if not numberp(a) then write "indeterminate" else write a; 10 if not(numberp(a) and a < 0) then write "positive number"; positive number ____________________________________________________________ Logical operators can only be used in conditional statements such as IF ...THEN ...ELSE or WHILE ...DO . File: redhelp, Node: NUMBERP, Next: ORDP, Prev: NOT, Up: Boolean Operators section NUMBERP operator The NUMBERP operator returns [*note TRUE::.] if its argument is a number, and [*note NIL::.] otherwise. syntax: NUMBERP (<expression>) or NUMBERP <expression> <expression> can be any REDUCE scalar expression. examples: ____________________________________________________________ cc := 15.3; CC := 15.3 if numberp(cc) then write "number" else write "nonnumber"; number if numberp(cb) then write "number" else write "nonnumber"; nonnumber ____________________________________________________________ Logical operators can only be used in conditional expressions, such as IF ...THEN ...ELSE and WHILE ...DO . File: redhelp, Node: ORDP, Next: PRIMEP, Prev: NUMBERP, Up: Boolean Operators section ORDP operator The ORDP logical operator returns [*note TRUE::.] if its first argument is ordered ahead of its second argument in canonical internal ordering, or is identical to it. syntax: ORDP (<expression1>,<expression2>) <expression1> and <expression2> can be any valid REDUCE scalar expression. examples: ____________________________________________________________ if ordp(x**2 + 1,x**3 + 3) then write "yes" else write "no"; no if ordp(101,100) then write "yes" else write "no"; yes if ordp(x,x) then write "yes" else write "no"; yes ____________________________________________________________ Logical operators can only be used in conditional expressions, such as IF ...THEN ...ELSE and WHILE ...DO . File: redhelp, Node: PRIMEP, Next: TRUE, Prev: ORDP, Up: Boolean Operators section PRIMEP operator syntax: PRIMEP (<expression>) or PRIMEP <simple_expression> If <expression> evaluates to a integer, PRIMEP returns [*note TRUE::.] if <expression> is a prime number and [*note NIL::.] otherwise. If <expression> does not have an integer value, a type error occurs. examples: ____________________________________________________________ if primep 3 then write "yes" else write "no"; YES if primep a then 1; ***** A invalid as integer ____________________________________________________________ File: redhelp, Node: TRUE, Prev: PRIMEP, Up: Boolean Operators section TRUE Any value of the boolean part of a logical expression which is neither [*note NIL::.] nor 0 is considered as TRUE . Most builtin test and compare functions return [*note T::.] for TRUE and [*note NIL::.] for FALSE . examples: ____________________________________________________________ if member(3,{1,2,3}) then 1 else -1; 1 if floor(1.7) then 1 else -1; 1 if floor(0.7) then 1 else -1; -1 ____________________________________________________________ File: redhelp, Node: Boolean Operators section, Next: General Commands section, Prev: Arithmetic Operations section, Up: Top Boolean Operators section * Menu: * boolean value:: concept * EQUAL:: operator * EVENP:: operator * false:: concept * FREEOF:: operator * LEQ:: operator * LESSP:: operator * MEMBER:: operator * NEQ:: operator * NOT:: operator * NUMBERP:: operator * ORDP:: operator * PRIMEP:: operator * TRUE:: concept File: redhelp, Node: BYE, Next: CONT, Up: General Commands section BYE command The BYE command ends the REDUCE session, returning control to the program (e.g., the operating system) that called REDUCE. When you are at the top level, the BYE command exits REDUCE. QUIT is a synonym for BYE . File: redhelp, Node: CONT, Next: DISPLAY, Prev: BYE, Up: General Commands section CONT command The command CONT returns control to an interactive file after a [*note PAUSE::.] command that has been answered with N . examples: ____________________________________________________________ ____________________________________________________________ Suppose you are in the middle of an interactive file. ____________________________________________________________ factorize(x**2 + 17*x + 60); {X + 5,X + 12} pause; Cont? (Y or N) n saveas results; factor1 := first results; FACTOR1 := X + 5 factor2 := second results; FACTOR2 := X + 12 cont; ____________________________________________________________ the file resumes ____________________________________________________________ ____________________________________________________________ A [*note PAUSE::.] allows you to enter your own REDUCE commands, change switch values, inquire about results, or other such activities. When you wish to resume operation of the interactive file, use CONT . File: redhelp, Node: DISPLAY, Next: LOAD_PACKAGE, Prev: CONT, Up: General Commands section DISPLAY command When given a numeric argument <n>, DISPLAY prints the <n> most recent input statements, identified by prompt numbers. If an empty pair of parentheses is given, or if <n> is greater than the current number of statements, all the input statements since the beginning of the session are printed. syntax: DISPLAY (<n>) or DISPLAY () <n> should be a positive integer. However, if it is a real number, the truncated integer value is used, and if a non-numeric argument is used, all the input statements are printed. The statements are displayed in upper case, with lines split at semicolons or dollar signs, as they are in editing. If long files have been input during the session, the DISPLAY command is slow to format these for printing. File: redhelp, Node: LOAD_PACKAGE, Next: PAUSE, Prev: DISPLAY, Up: General Commands section LOAD_PACKAGE command The LOAD_PACKAGE command is used to load REDUCE packages, such as GENTRAN that are not automatically loaded by the system. syntax: LOAD_PACKAGE " <package_name>" A package is only loaded once; subsequent calls of LOAD_PACKAGE for the same package name are ignored. File: redhelp, Node: PAUSE, Next: QUIT, Prev: LOAD_PACKAGE, Up: General Commands section PAUSE command The PAUSE command, given in an interactive file, stops operation and asks if you want to continue or not. examples: ____________________________________________________________ ____________________________________________________________ An interactive file is running, and at some point you see the question ____________________________________________________________ Cont? (Y or N) ____________________________________________________________ If you type ____________________________________________________________ y(Key){Return} ____________________________________________________________ the file continues to run until the next pause or the end. ____________________________________________________________ ____________________________________________________________ If you type ____________________________________________________________ n(Key){Return} ____________________________________________________________ you will get a numbered REDUCE prompt, and be allowed to enter and execute any REDUCE statements. If you later wish to continue with the file, type ____________________________________________________________ cont; ____________________________________________________________ and the file resumes. ____________________________________________________________ ____________________________________________________________ To use PAUSE in your own interactive files, type PAUSE; in the file wherever you want it. PAUSE does not allow you to continue without typing either Y or N . Its use is to slow down scrolling of interactive files, or to let you change parameters or switch settings for the calculations. If you have stopped an interactive file at a PAUSE, and do not wish to resume the file, type END; . This does not end the REDUCE session, but stops input from the file. A second END; ends the REDUCE session. However, if you have pauses from more than one file stacked up, an END; brings you back to the top level, not the file directly above. A PAUSE typed from the terminal has no effect. File: redhelp, Node: QUIT, Next: RECLAIM, Prev: PAUSE, Up: General Commands section QUIT command The QUIT command ends the REDUCE session, returning control to the program (e.g., the operating system) that called REDUCE. When you are at the top level, the QUIT command exits REDUCE. [*note BYE::.] is a synonym for QUIT . File: redhelp, Node: RECLAIM, Next: REDERR, Prev: QUIT, Up: General Commands section RECLAIM operator REDUCE's memory is in a storage structure called a heap. As REDUCE statements execute, chunks of memory are used up. When these chunks are no longer needed, they remain idle. When the memory is almost full, the system executes a garbage collection, reclaiming space that is no longer needed, and putting all the free space at one end. Depending on the size of the image REDUCE is using, garbage collection needs to be done more or less often. A larger image means fewer but longer garbage collections. Regardless of memory size, if you ask REDUCE to do something ridiculous, like FACTORIAL(2000) , it may garbage collect many times. File: redhelp, Node: REDERR, Next: RETRY, Prev: RECLAIM, Up: General Commands section REDERR command The REDERR command allows you to print an error message from inside a [*note PROCEDURE::.] or a [*note block::.] statement. The calculation is gracefully terminated. syntax: REDERR <message> <message> is an error message, usually inside double quotation marks (a [*note STRING::.] ). examples: ____________________________________________________________ procedure fac(n); if not (fixp(n) and n>=0) then rederr "Choose nonneg. integer only" else for i := 0:n-1 product i+1; fac fac a; ***** Choose nonneg. integer only fac 5; 120 ____________________________________________________________ The above procedure finds the factorial of its argument. If n is not a positive integer or 0, an error message is returned. If your procedure is executed in a file, the usual error message is printed, followed by CONT? (Y OR N) , just as any other error does from a file. Although the procedure is gracefully terminated, any switch settings or variable assignments you made before the error occurred are not undone. If you need to clean up such items before exiting, use a group statement, with the REDERR command as its last statement. File: redhelp, Node: RETRY, Next: SAVEAS, Prev: REDERR, Up: General Commands section RETRY command The RETRY command allows you to retry the latest statement that resulted in an error message. examples: ____________________________________________________________ matrix a; det a; ***** Matrix A not set a := mat((1,2),(3,4)); A(1,1) := 1 A(1,2) := 2 A(2,1) := 3 A(2,2) := 4 retry; -2 ____________________________________________________________ RETRY remembers only the most recent statement that resulted in an error message. It allows you to stop and fix something obvious, then continue on your way without retyping the original command. File: redhelp, Node: SAVEAS, Next: SHOWTIME, Prev: RETRY, Up: General Commands section SAVEAS command The SAVEAS command saves the current workspace under the name of its argument. syntax: SAVEAS <identifier> <identifier> can be any valid REDUCE identifier. examples: ____________________________________________________________ ____________________________________________________________ (The numbered prompts are shown below, unlike in most examples) ____________________________________________________________ 1: solve(x^2-3); {x=sqrt(3),x= - sqrt(3)} 2: saveas rts(0)$ 3: rts(0); {x=sqrt(3),x= - sqrt(3)} ____________________________________________________________ SAVEAS works only for the current workspace, the last algebraic expression produced by REDUCE. This allows you to save a result that you did not assign to an identifier when you originally typed the input. For access to previous output use [*note WS::.] . File: redhelp, Node: SHOWTIME, Next: WRITE, Prev: SAVEAS, Up: General Commands section SHOWTIME command The SHOWTIME command prints the elapsed system time since the last call of this command or since the beginning of the session, if it has not been called before. examples: ____________________________________________________________ showtime; Time: 1020 ms factorize(x^4 - 8x^4 + 8x^2 - 136x - 153); 2 {X - 9,X + 17,X + 1} showtime; Time: 920 ms ____________________________________________________________ The time printed is either the elapsed cpu time or the elapsed wall clock time, depending on your system. SHOWTIME allows you to see the system time resources REDUCE uses in its calculations. Your time readings will of course vary from this example according to the system you use. File: redhelp, Node: WRITE, Prev: SHOWTIME, Up: General Commands section WRITE command The WRITE command explicitly writes its arguments to the output device (terminal or file). syntax: WRITE <item>,<item>* <item> can be an expression, an assignment or a [*note STRING::.] enclosed in double quotation marks (" ). examples: ____________________________________________________________ write a, sin x, "this is a string"; ASIN(X)this is a string write a," ",sin x," this is a string"; A SIN(X) this is a string if not numberp(a) then write "the symbol ",a; the symbol A array m(10); for i := 1:5 do write m(i) := 2*i; M(1) := 2 M(2) := 4 M(3) := 6 M(4) := 8 M(5) := 10 m(4); 8 ____________________________________________________________ The items specified by a single WRITE statement print on a single line unless they are too long. A printed line is always ended with a carriage return, so the next item printed starts a new line. When an assignment statement is printed, the assignment is also made. This allows you to get feedback on filling slots in an array with a [*note FOR::.] statement, as shown in the last example above. File: redhelp, Node: General Commands section, Next: Algebraic Operators section, Prev: Boolean Operators section, Up: Top General Commands section * Menu: * BYE:: command * CONT:: command * DISPLAY:: command * LOAD_PACKAGE:: command * PAUSE:: command * QUIT:: command * RECLAIM:: operator * REDERR:: command * RETRY:: command * SAVEAS:: command * SHOWTIME:: command * WRITE:: command File: redhelp, Node: APPEND, Next: ARBINT, Up: Algebraic Operators section APPEND operator The APPEND operator constructs a new [*note LIST::.] from the elements of its two arguments (which must be lists). syntax: APPEND (<list>,<list>) <list> must be a list, though it may be the empty list ([] ). Any arguments beyond the first two are ignored. examples: ____________________________________________________________ alist := {1,2,{a,b}}; ALIST := {1,2,{A,B}} blist := {3,4,5,sin(y)}; BLIST := {3,4,5,SIN(Y)} append(alist,blist); {1,2,{A,B},3,4,5,SIN(Y)} append(alist,{}); {1,2,{A,B}} append(list z,blist); {Z,3,4,5,SIN(Y)} ____________________________________________________________ The new list consists of the elements of the second list appended to the elements of the first list. You can APPEND new elements to the beginning or end of an existing list by putting the new element in a list (use curly braces or the operator LIST ). This is particularly helpful in an iterative loop. File: redhelp, Node: ARBINT, Next: ARBCOMPLEX, Prev: APPEND, Up: Algebraic Operators section ARBINT operator The operator ARBINT is used to express arbitrary integer parts of an expression, e.g. in the result of [*note SOLVE::.] when [*note ALLBRANCH::.] is on. examples: ____________________________________________________________ solve(log(sin(x+3)),x); {X=2*ARBINT(1)*PI - ASIN(1) - 3, X=2*ARBINT(1)*PI + ASIN(1) + PI - 3} ____________________________________________________________ File: redhelp, Node: ARBCOMPLEX, Next: ARGLENGTH, Prev: ARBINT, Up: Algebraic Operators section ARBCOMPLEX operator The operator ARBCOMPLEX is used to express arbitrary scalar parts of an expression, e.g. in the result of [*note SOLVE::.] when the solution is parametric in one of the variable. examples: ____________________________________________________________ solve({x+3=y-2z,y-3x=0},{x,y,z}); 2*ARBCOMPLEX(1) + 3 {X=-------------------, 2 3*ARBCOMPLEX(1) + 3 Y=-------------------, 2 Z=ARBCOMPLEX(1)} ____________________________________________________________ File: redhelp, Node: ARGLENGTH, Next: COEFF, Prev: ARBCOMPLEX, Up: Algebraic Operators section ARGLENGTH operator The operator ARGLENGTH returns the number of arguments of the top-level operator in its argument. syntax: ARGLENGTH (<expression>) <expression> can be any valid REDUCE algebraic expression. examples: ____________________________________________________________ arglength(a + b + c + d); 4 arglength(a/b/c); 2 arglength(log(sin(df(r**3*x,x)))); 1 ____________________________________________________________ In the first example, + is an n-ary operator, so the number of terms is returned. In the second example, since / is a binary operator, the argument is actually (a/b)/c, so there are two terms at the top level. In the last example, no matter how deeply the operators are nested, there is still only one argument at the top level. File: redhelp, Node: COEFF, Next: COEFFN, Prev: ARGLENGTH, Up: Algebraic Operators section COEFF operator The COEFF operator returns the coefficients of the powers of the specified variable in the given expression, in a [*note LIST::.] . syntax: COEFF (<expression>, <variable>) <expression> is expected to be a polynomial expression, not a rational expression. Rational expressions are accepted when the switch [*note RATARG::.] is on. <variable> must be a kernel. The results are returned in a list. examples: ____________________________________________________________ coeff((x+y)**3,x); 3 2 {Y ,3*Y ,3*Y,1} coeff((x+2)**4 + sin(x),x); {SIN(X) + 16,32,24,8,1} high_pow; 4 low_pow; 0 ab := x**9 + sin(x)*x**7 + sqrt(y); 7 9 AB := SQRT(Y) + SIN(X)*X + X coeff(ab,x); {SQRT(Y),0,0,0,0,0,0,SIN(X),0,1} ____________________________________________________________ The variables [*note HIGH_POW::.] and [*note LOW_POW::.] are set to the highest and lowest powers of the variable, respectively, appearing in the expression. The coefficients are put into a list, with the coefficient of the lowest (constant) term first. You can use the usual list access methods (FIRST , SECOND , THIRD , REST , LENGTH , and PART ) to extract them. If a power does not appear in the expression, the corresponding element of the list is zero. Terms involving functions of the specified variable but not including powers of it (for example in the expression X**4 + 3*X**2 + TAN(X) ) are placed in the constant term. Since the COEFF command deals with the expanded form of the expression, you may get unexpected results when [*note EXP::.] is off, or when [*note FACTOR::.] or [*note IFACTOR::.] are on. If you want only a specific coefficient rather than all of them, use the [*note COEFFN::.] operator. File: redhelp, Node: COEFFN, Next: CONJ, Prev: COEFF, Up: Algebraic Operators section COEFFN operator The COEFFN operator takes three arguments: an expression, a kernel, and a non-negative integer. It returns the coefficient of the kernel to that integer power, appearing in the expression. syntax: COEFFN (<expression>,<kernel>,<integer>) <expression> must be a polynomial, unless [*note RATARG::.] is on which allows rational expressions. <kernel> must be a kernel, and <integer> must be a non-negative integer. examples: ____________________________________________________________ ff := x**7 + sin(y)*x**5 + y**4 + x + 7; 5 7 4 FF := SIN(Y)*X + X + X + Y + 7 coeffn(ff,x,5); SIN(Y) coeffn(ff,z,3); 0 coeffn(ff,y,0); 5 7 SIN(Y)*X + X + X + 7 rr := 1/y**2+y**3+sin(y); 2 5 SIN(Y)*Y + Y + 1 RR := -------------------- 2 Y on ratarg; coeffn(rr,y,-2); ***** -2 invalid as COEFFN index coeffn(rr,y,5); 1 --- 2 Y ____________________________________________________________ If the given power of the kernel does not appear in the expression, COEFFN returns 0. Negative powers are never detected, even if they appear in the expression and [*note RATARG::.] are on. COEFFN with an integer argument of 0 returns any terms in the expression that do not contain the given kernel. File: redhelp, Node: CONJ, Next: CONTINUED_FRACTION, Prev: COEFFN, Up: Algebraic Operators section CONJ operator syntax: CONJ (<expression>) or CONJ <simple_expression> This operator returns the complex conjugate of an expression, if that argument has an numerical value. A non-numerical argument is returned as an expression in the operators [*note REPART::.] and [*note IMPART::.] . examples: ____________________________________________________________ conj(1+i); 1-I conj(a+i*b); REPART(A) - REPART(B)*I - IMPART(A)*I - IMPART(B) ____________________________________________________________ File: redhelp, Node: CONTINUED_FRACTION, Next: DECOMPOSE, Prev: CONJ, Up: Algebraic Operators section CONTINUED_FRACTION operator syntax: CONTINUED_FRACTION (<num>) or CONTINUED_FRACTION ( <num>,<size>) This operator approximates the real number <num> ( [*note RATIONAL::.] number, [*note ROUNDED::.] number) into a continued fraction. The result is a list of two elements: the first one is the rational value of the approximation, the second one is the list of terms of the continued fraction which represents the same value according to the definition T0 +1/(T1 + 1/(T2 + ...)) . Precision: the second optional parameter <size> is an upper bound for the absolute value of the result denominator. If omitted, the approximation is performed up to the current system precision. examples: ____________________________________________________________ continued_fraction pi; 1146408 {-------,{3,7,15,1,292,1,1,1,2,1}} 364913 continued_fraction(pi,100); 22 {--,{3,7}} 7 ____________________________________________________________ File: redhelp, Node: DECOMPOSE, Next: DEG, Prev: CONTINUED_FRACTION, Up: Algebraic Operators section DECOMPOSE operator The DECOMPOSE operator takes a multivariate polynomial as argument, and returns an expression and a [*note LIST::.] of [*note EQUATION::.] s from which the original polynomial can be found by composition. syntax: DECOMPOSE (<expression>) or DECOMPOSE <simple_expression> examples: ____________________________________________________________ decompose(x^8-88*x^7+2924*x^6-43912*x^5+263431*x^4- 218900*x^3+65690*x^2-7700*x+234) 2 2 2 U + 35*U + 234, U=V + 10*V, V=X - 22*X decompose(u^2+v^2+2u*v+1) 2 W + 1, W=U + V ____________________________________________________________ Unlike factorization, this decomposition is not unique. Further details can be found in V.S. Alagar, M.Tanh, <Fast Polynomial Decomposition>, Proc. EUROCAL 1985, pp 150-153 (Springer) and J. von zur Gathen, <Functional> <Decomposition of Polynomials: the Tame Case>, J. Symbolic Computation (1990) 9, 281-299. File: redhelp, Node: DEG, Next: DEN, Prev: DECOMPOSE, Up: Algebraic Operators section DEG operator The operator DEG returns the highest degree of its variable argument found in its expression argument. syntax: DEG (<expression>,<kernel>) <expression> is expected to be a polynomial expression, not a rational expression. Rational expressions are accepted when the switch [*note RATARG::.] is on. <variable> must be a [*note KERNEL::.] . The results are returned in a list. examples: ____________________________________________________________ deg((x+y)**5,x); 5 deg((a+b)*(c+2*d)**2,d); 2 deg(x**2 + cos(y),sin(x)); deg((x**2 + sin(x))**5,sin(x)); 5 ____________________________________________________________ File: redhelp, Node: DEN, Next: DF, Prev: DEG, Up: Algebraic Operators section DEN operator The DEN operator returns the denominator of its argument. syntax: DEN (<expression>) <expression> is ordinarily a rational expression, but may be any valid scalar REDUCE expression. examples: ____________________________________________________________ a := x**3 + 3*x**2 + 12*x; 2 A := X*(X + 3*X + 12) b := 4*x*y + x*sin(x); B := X*(SIN(X) + 4*Y) den(a/b); SIN(X) + 4*Y den(aa/4 + bb/5); 20 den(100/6); 3 den(sin(x)); 1 ____________________________________________________________ DEN returns the denominator of the expression after it has been simplified by REDUCE. As seen in the examples, this includes putting sums of rational expressions over a common denominator, and reducing common factors where possible. If the expression does not have any other denominator, 1 is returned. Switch settings, such as [*note MCD::.] or [*note RATIONAL::.] , have an effect on the denominator of an expression. File: redhelp, Node: DF, Next: EXPAND_CASES, Prev: DEN, Up: Algebraic Operators section DF operator The DF operator finds partial derivatives with respect to one or more variables. syntax: DF (<expression>, <var> [, <number>] , <var> [ , <number>] ) <expression> can be any valid REDUCE algebraic expression. <var> must be a [*note KERNEL::.] , and is the differentiation variable. <number> must be a non-negative integer. examples: ____________________________________________________________ df(x**2,x); 2*X df(x**2*y + sin(y),y); 2 COS(Y) + X df((x+y)**10,z); 0 df(1/x**2,x,2); 6 --- 4 X df(x**4*y + sin(y),y,x,3); 24*X for all x let df(tan(x),x) = sec(x)**2; df(tan(3*x),x); 2 3*SEC(3*X) ____________________________________________________________ An error message results if a non-kernel is entered as a differentiation operator. If the optional number is omitted, it is assumed to be 1. See the declaration [*note DEPEND::.] to establish dependencies for implicit differentiation. You can define your own differentiation rules, expanding REDUCE's capabilities, using the [*note LET::.] command as shown in the last example above. Note that once you add your own rule for differentiating a function, it supersedes REDUCE's normal handling of that function for the duration of the REDUCE session. If you clear the rule ([*note CLEARRULES::.] ), you don't get back to the previous rule. File: redhelp, Node: EXPAND_CASES, Next: EXPREAD, Prev: DF, Up: Algebraic Operators section EXPAND_CASES operator When a [*note ROOT_OF::.] form in a result of [*note SOLVE::.] has been converted to a [*note ONE_OF::.] form, EXPAND_CASES can be used to convert this into form corresponding to the normal explicit results of [*note SOLVE::.] . See [*note ROOT_OF::.] . File: redhelp, Node: EXPREAD, Next: FACTORIZE, Prev: EXPAND_CASES, Up: Algebraic Operators section EXPREAD operator syntax: EXPREAD () EXPREAD reads one well-formed expression from the current input buffer and returns its value. examples: ____________________________________________________________ expread(); a+b; A + B ____________________________________________________________ File: redhelp, Node: FACTORIZE, Next: HYPOT, Prev: EXPREAD, Up: Algebraic Operators section FACTORIZE operator The FACTORIZE operator factors a given expression. syntax: FACTORIZE (<expression>) <expression> should be a polynomial, otherwise an error will result. examples: ____________________________________________________________ fff := factorize(x^3 - y^3); 2 2 {X - Y,X + X*Y + Y } fac1 := first fff; FAC1 := X - Y factorize(x^15 - 1); {X - 1, 2 X + X + 1, 4 3 2 X + X + X + X + 1, 8 7 6 5 4 X - X + X - X + X - X + 1} lastone := part(ws,length ws); 8 7 6 5 4 LASTONE := X - X + X - X + X - X + 1 setmod 2; 1 on modular; factorize(x^15 - 1); {X + 1, 2 X + X + 1, 4 X + X + 1, 4 3 X + X + 1, 4 3 2 X + X + X + X + 1} ____________________________________________________________ The FACTORIZE command returns the factors it finds as a [*note LIST::.] . You can therefore use the usual list access methods ([*note FIRST::.] , [*note SECOND::.] , [*note THIRD::.] , [*note REST::.] , [*note LENGTH::.] and [*note PART::.] ) to extract the factors. If the <expression> given to FACTORIZE is an integer, it will be factored into its prime components. To factor any integer factor of a non-numerical expression, the switch [*note IFACTOR::.] should be turned on. Its default is off. [*note IFACTOR::.] has effect only when factoring is explicitly done by FACTORIZE , not when factoring is automatically done with the [*note FACTOR::.] switch. If full factorization is not needed the switch [*note LIMITEDFACTORS::.] allows you to reduce the computing time of calls to FACTORIZE . Factoring can be done in a modular domain by calling FACTORIZE when [*note MODULAR::.] is on. You can set the modulus with the [*note SETMOD::.] command. The last example above shows factoring modulo 2. For general comments on factoring, see comments under the switch [*note FACTOR::.] . File: redhelp, Node: HYPOT, Next: IMPART, Prev: FACTORIZE, Up: Algebraic Operators section HYPOT operator syntax: hypot(<expression>,<expression>) If ROUNDED is on, and the two arguments evaluate to numbers, this operator returns the square root of the sums of the squares of the arguments in a manner that avoids intermediate overflow. In other cases, an expression in the original operator is returned. examples: ____________________________________________________________ hypot(3,4); HYPOT(3,4) on rounded; ws; 5.0 hypot(a,b); HYPOT(A,B) ____________________________________________________________ File: redhelp, Node: IMPART, Next: INT, Prev: HYPOT, Up: Algebraic Operators section IMPART operator syntax: IMPART (<expression>) or IMPART <simple_expression> This operator returns the imaginary part of an expression, if that argument has an numerical value. A non-numerical argument is returned as an expression in the operators [*note REPART::.] and IMPART . examples: ____________________________________________________________ impart(1+i); 1 impart(a+i*b); REPART(B) + IMPART(A) ____________________________________________________________ File: redhelp, Node: INT, Next: INTERPOL, Prev: IMPART, Up: Algebraic Operators section INT operator The INT operator performs analytic integration on a variety of functions. syntax: INT (<expression>,<kernel>) <expression> can be any scalar expression. involving polynomials, log functions, exponential functions, or tangent or arctangent expressions. INT attempts expressions involving error functions, dilogarithms and other trigonometric expressions. Integrals involving algebraic extensions (such as square roots) may not succeed. <kernel> must be a REDUCE [*note KERNEL::.] . examples: ____________________________________________________________ int(x**3 + 3,x); 3 X*(X + 12) ----------- 4 int(sin(x)*exp(2*x),x); 2*X E *(COS(X) - 2*SIN(X)) - ------------------------ 5 int(1/(x^2-2),x); SQRT(2)*(LOG( - SQRT(2) + X) - LOG(SQRT(2) + X)) ------------------------------------------------ 4 int(sin(x)/(4 + cos(x)**2),x); COS(X) ATAN(------) 2 - ------------ 2 int(1/sqrt(x^2-x),x); SQRT(X)*SQRT(X - 1) INT(-------------------,X) 2 X -X ____________________________________________________________ Note that REDUCE couldn't handle the last integral with its default integrator, since the integrand involves a square root. However, the integral can be found using the [*note ALGINT::.] package. Alternatively, you could add a rule using the [*note LET::.] statement to evaluate this integral. The arbitrary constant of integration is not shown. Definite integrals can be found by evaluating the result at the limits of integration (use [*note ROUNDED::.] ) and subtracting the lower from the higher. Evaluation can be easily done by the [*note SUB::.] operator. When INT cannot find an integral it returns an expression involving formal INT expressions unless the switch [*note FAILHARD::.] has been set. If not all of the expression can be integrated, the switch [*note NOLNR::.] controls whether a partially integrated result should be returned or not. File: redhelp, Node: INTERPOL, Next: LCOF, Prev: INT, Up: Algebraic Operators section INTERPOL operator INTERPOL generates an interpolation polynomial. syntax: interpol(<values>,<variable>,<points>) <values> and <points> are [*note LIST::.] s of equal length and <variable> is an algebraic expression (preferably a [*note KERNEL::.] ). The interpolation polynomial is generated in the given variable of degree length(<values>)-1. The unique polynomial F is defined by the property that for corresponding elements V of <values> and P of <points> the relation F(P)=V holds. examples: ____________________________________________________________ f := for i:=1:4 collect(i**3-1); F := 0,7,26,63 p := {1,2,3,4}; P := 1,2,3,4 interpol(f,x,p); 3 X - 1 ____________________________________________________________ The Aitken-Neville interpolation algorithm is used which guarantees a stable result even with rounded numbers and an ill-conditioned problem. File: redhelp, Node: LCOF, Next: LENGTH, Prev: INTERPOL, Up: Algebraic Operators section LCOF operator The LCOF operator returns the leading coefficient of a given expression with respect to a given variable. syntax: LCOF (<expression>,<kernel>) <expression> is ordinarily a polynomial. If [*note RATARG::.] is on, a rational expression may also be used, otherwise an error results. <kernel> must be a [*note KERNEL::.] . examples: ____________________________________________________________ lcof((x+2*y)**5,y); 32 lcof((x + y*sin(x))**2 + cos(x)*sin(x)**2,sin(x)); 2 COS(X) + Y lcof(x**2 + 3*x + 17,y); 2 X + 3*X + 17 ____________________________________________________________ If the kernel does not appear in the expression, LCOF returns the expression. File: redhelp, Node: LENGTH, Next: LHS, Prev: LCOF, Up: Algebraic Operators section LENGTH operator The LENGTH operator returns the number of items in a [*note LIST::.] , the number of terms in an expression, or the dimensions of an array or matrix. syntax: LENGTH (<expr>) or LENGTH <expr> <expr> can be a list structure, an array, a matrix, or a scalar expression. examples: ____________________________________________________________ alist := {a,b,{ww,xx,yy,zz}}; ALIST := {A,B,{WW,XX,YY,ZZ}} length alist; 3 length third alist; 4 dlist := {d}; DLIST := {D} length rest dlist; 0 matrix mmm(4,5); length mmm; {4,5} array aaa(5,3,2); length aaa; {6,4,3} eex := (x+3)**2/(x-y); 2 X + 6*X + 9 EEX := ------------ X - Y length eex; 5 ____________________________________________________________ An item in a list that is itself a list only counts as one item. An error message will be printed if LENGTH is called on a matrix which has not had its dimensions set. The LENGTH of an array includes the zeroth element of each dimension, showing the full number of elements allocated. (Declaring an array A with n elements allocates A(0),A(1),...,A(n).) The LENGTH of an expression is the total number of additive terms appearing in the numerator and denominator of the expression. Note that subtraction of a term is represented internally as addition of a negative term. File: redhelp, Node: LHS, Next: LIMIT, Prev: LENGTH, Up: Algebraic Operators section LHS operator The LHS operator returns the left-hand side of an [*note EQUATION::.] , such as those returned in a list by [*note SOLVE::.] . syntax: LHS (<equation>) or LHS <equation> <equation> must be an equation of the form LEFT-HAND SIDE = RIGHT-HAND SIDE . examples: ____________________________________________________________ polly := (x+3)*(x^4+2x+1); 5 4 2 POLLY := X + 3*X + 2*X + 7*X + 3 pollyroots := solve(polly,x); POLLYROOTS := {X=ROOT F(X3 - X2 + X + 1,X , O ) X=-1, X=-3} variable := lhs first pollyroots; VARIABLE := X ____________________________________________________________ File: redhelp, Node: LIMIT, Next: LPOWER, Prev: LHS, Up: Algebraic Operators section LIMIT operator LIMITS is a fast limit package for REDUCE for functions which are continuous except for computable poles and singularities, based on some earlier work by Ian Cohen and John P. Fitch. The Truncated Power Series package is used for non-critical points, at which the value of the function is the constant term in the expansion around that point. l'Hopital's rule is used in critical cases, with preprocessing of 1-1 forms and reformatting of product forms in order to apply l'Hopital's rule. A limited amount of bounded arithmetic is also employed where applicable. syntax: LIMIT (<expr>,<var>,<limpoint>) or LIMIT!+ (<expr>,<var>,<limpoint>) or LIMIT!- (<expr>,<var>,<limpoint>) where <expr> is an expression depending of the variable <var> (a [*note KERNEL::.] ) and <limpoint> is the limit point. If the limit depends upon the direction of approach to the <limpoint>, the operators LIMIT!+ and LIMIT!- may be used. examples: ____________________________________________________________ limit(x*cot(x),x,0); 0 limit((2x+5)/(3x-2),x,infinity); 2 -- 3 ____________________________________________________________ File: redhelp, Node: LPOWER, Next: LTERM, Prev: LIMIT, Up: Algebraic Operators section LPOWER operator The LPOWER operator returns the leading power of an expression with respect to a kernel. 1 is returned if the expression does not depend on the kernel. syntax: LPOWER (<expression>,<kernel>) <expression> is ordinarily a polynomial. If [*note RATARG::.] is on, a rational expression may also be used, otherwise an error results. <kernel> must be a [*note KERNEL::.] . examples: ____________________________________________________________ lpower((x+2*y)**6,y); 6 Y lpower((x + cos(x))**8 + df(x**2,x),cos(x)); 8 COS(X) lpower(x**3 + 3*x,y); 1 ____________________________________________________________ File: redhelp, Node: LTERM, Next: MAINVAR, Prev: LPOWER, Up: Algebraic Operators section LTERM operator The LTERM operator returns the leading term of an expression with respect to a kernel. The expression is returned if it does not depend on the kernel. syntax: LTERM (<expression>,<kernel>) <expression> is ordinarily a polynomial. If [*note RATARG::.] is on, a rational expression may also be used, otherwise an error results. <kernel> must be a [*note KERNEL::.] . examples: ____________________________________________________________ lterm((x+2*y)**6,y); 6 64*Y lterm((x + cos(x))**8 + df(x**2,x),cos(x)); 8 COS(X) lterm(x**3 + 3*x,y); 3 X + 3X ____________________________________________________________ File: redhelp, Node: MAINVAR, Next: MAP, Prev: LTERM, Up: Algebraic Operators section MAINVAR operator The MAINVAR operator returns the main variable (in the system's internal representation) of its argument. syntax: MAINVAR (<expression>) <expression> is usually a polynomial, but may be any valid REDUCE scalar expression. In the case of a rational function, the main variable of the numerator is returned. The main variable returned is a [*note KERNEL::.] . examples: ____________________________________________________________ test := (a + b + c)**2; 2 2 2 TEST := A + 2*A*B + 2*A*C + B + 2*B*C + C mainvar(test); A korder c,b,a; mainvar(test); C mainvar(2*cos(x)**2); COS(X) mainvar(17); 0 ____________________________________________________________ The main variable is the first variable in the canonical ordering of kernels. Generally, alphabetically ordered functions come first, then alphabetically ordered identifiers (variables). Numbers come last, and as far as MAINVAR is concerned belong in the family 0 . The canonical ordering can be changed by the declaration [*note KORDER::.] , as shown above. File: redhelp, Node: MAP, Next: MKID, Prev: MAINVAR, Up: Algebraic Operators section MAP operator The MAP operator applies a uniform evaluation pattern to all members of a composite structure: a [*note MATRIX::.] , a [*note LIST::.] or the arguments of an [*note OPERATOR::.] expression. The evaluation pattern can be a unary procedure, an operator, or an algebraic expression with one free variable. syntax: MAP (<function>,<object>) <object> is a list, a matrix or an operator expression. <function> is the name of an operator for a single argument: the operator is evaluated once with each element of <object> as its single argument, or an algebraic expression with exactly one [*note Free Variable::.] , that is a variable preceded by the tilde symbol: the expression is evaluated for each element of <object> where the element is substituted for the free variable, or a replacement [*note RULE::.] of the form syntax: VAR => REP where <var> is a variable (a <kernel> without subscript) and <rep> is an expression which contains <var>. Here REP is evaluated for each element of <object> where the element is substituted for VAR . VAR may be optionally preceded by a tilde. The rule form for <function> is needed when more than one free variable occurs. examples: ____________________________________________________________ map(abs,{1,-2,a,-a}); 1,2,abs(a),abs(a) map(int(~w,x), mat((x^2,x^5),(x^4,x^5))); [ 3 6 ] [ x x ] [---- ----] [ 3 6 ] [ ] [ 5 6 ] [ x x ] [---- ----] [ 5 6 ] map(~w*6, x^2/3 = y^3/2 -1); 2 3 2*x =3*(y -2) ____________________________________________________________ You can use MAP in nested expressions. It is not allowed to apply MAP for a non-composed object, e.g. an identifier or a number. File: redhelp, Node: MKID, Next: NPRIMITIVE, Prev: MAP, Up: Algebraic Operators section MKID command The MKID command constructs an identifier, given a stem and an identifier or an integer. syntax: MKID (<stem>,<leaf>) <stem> can be any valid REDUCE identifier that does not include escaped special characters. <leaf> may be an integer, including one given by a local variable in a [*note FOR::.] loop, or any other legal group of characters. examples: ____________________________________________________________ mkid(x,3); X3 factorize(x^15 - 1); {X - 1, 2 X + X + 1, 4 3 2 X + X + X + X + 1, 8 7 5 4 3 X - X + X - X + X - X + 1} for i := 1:length ws do write set(mkid(f,i),part(ws,i)); 8 7 5 4 3 X - X + X - X + X - X + 1 4 3 2 X + X + X + X + 1 2 X + X + 1 X - 1 ____________________________________________________________ You can use MKID to construct identifiers from inside procedures. This allows you to handle an unknown number of factors, or deal with variable amounts of data. It is particularly helpful to attach identifiers to the answers returned by FACTORIZE and SOLVE . File: redhelp, Node: NPRIMITIVE, Next: NUM, Prev: MKID, Up: Algebraic Operators section NPRIMITIVE operator syntax: NPRIMITIVE (<expression>) or NPRIMITIVE <simple_expression> This operator returns the numerically-primitive part of any scalar expression. In other words, any overall integer factors in the expression are removed. examples: ____________________________________________________________ nprimitive((2x+2y)^2); 2 2 X + 2*X*Y + Y nprimitive(3*a*b*c); 3*A*B*C ____________________________________________________________ File: redhelp, Node: NUM, Next: ODESOLVE, Prev: NPRIMITIVE, Up: Algebraic Operators section NUM operator The NUM operator returns the numerator of its argument. syntax: NUM (<expression>) or NUM <simple_expression> <expression> can be any valid REDUCE scalar expression. examples: ____________________________________________________________ num(100/6); 50 num(a/5 + b/6); 6*A + 5*B num(sin(x)); SIN(X) ____________________________________________________________ NUM returns the numerator of the expression after it has been simplified by REDUCE. As seen in the examples, this includes putting sums of rational expressions over a common denominator, and reducing common factors where possible. If the expression is not a rational expression, it is returned unchanged. File: redhelp, Node: ODESOLVE, Next: ONE_OF, Prev: NUM, Up: Algebraic Operators section ODESOLVE operator The ODESOLVE package is a solver for ordinary differential equations. At the present time it has still limited capabilities: 1. it can handle only a single scalar equation presented as an algebraic expression or equation, and 2. it can solve only first-order equations of simple types, linear equations with constant coefficients and Euler equations. These solvable types are exactly those for which Lie symmetry techniques give no useful information. syntax: ODESOLVE (<expr>,<var1>,<var2>) <expr> is a single scalar expression such that <expr>=0 is the ordinary differential equation (ODE for short) to be solved, or is an equivalent [*note EQUATION::.] . <var1> is the name of the dependent variable, <var2> is the name of the independent variable. A differential in <expr> is expressed using the [*note DF::.] operator. Note that in most cases you must declare explicitly <var1> to depend of <var2> using a [*note DEPEND::.] declaration - otherwise the derivative might be evaluated to zero on input to ODESOLVE . The returned value is a list containing the equation giving the general solution of the ODE (for simultaneous equations this will be a list of equations eventually). It will contain occurrences of the operator ARBCONST for the arbitrary constants in the general solution. The arguments of ARBCONST should be new. A counter !!ARBCONST is used to arrange this. examples: ____________________________________________________________ depend y,x; % A first-order linear equation, with an initial condition ode:=df(y,x) + y * sin x/cos x - 1/cos x$ odesolve(ode,y,x); {y=arbconst(1)*cos(x) + sin(x)} ____________________________________________________________ File: redhelp, Node: ONE_OF, Next: PART, Prev: ODESOLVE, Up: Algebraic Operators section ONE_OF type The operator ONE_OF is used to represent an indefinite choice of one element from a finite set of objects. examples: ____________________________________________________________ x=one_of{1,2,5} ____________________________________________________________ this equation encodes that x can take one of the values 1,2 or 5 ____________________________________________________________ ____________________________________________________________ REDUCE generates a ONE_OF form in cases when an implicit ROOT_OF expression could be converted to an explicit solution set. A ONE_OF form can be converted to a SOLVE solution using [*note EXPAND_CASES::.] . See [*note ROOT_OF::.] . File: redhelp, Node: PART, Next: PF, Prev: ONE_OF, Up: Algebraic Operators section PART operator The operator PART permits the extraction of various parts or operators of expressions and [*note LIST::.] S . syntax: PART (<expression,integer>,<integer>*) <expression> can be any valid REDUCE expression or a list, integer may be an expression that evaluates to a positive or negative integer or 0. A positive integer <n> picks up the n th term, counting from the first term toward the end. A negative integer n picks up the n th term, counting from the back toward the front. The integer 0 picks up the operator (which is LIST when the expression is a [*note LIST::.] ). examples: ____________________________________________________________ part((x + y)**5,4); 2 3 10*X *Y part((x + y)**5,4,2); 2 X part((x + y)**5,4,2,1); X part((x + y)**5,0); PLUS part((x + y)**5,-5); 4 5*X *Y part((x + y)**5,4) := sin(x); 5 4 3 2 4 5 X + 5*X *Y + 10*X *Y + SIN(X) + 5*X*Y + Y alist := {x,y,{aa,bb,cc},x**2*sqrt(y)}; 2 ALIST := {X,Y,{AA,BB,CC},SQRT(Y)*X } part(alist,3,2); BB part(alist,4,0); TIMES ____________________________________________________________ Additional integer arguments after the first one examine the terms recursively, as shown above. In the third line, the fourth term is picked from the original polynomial, 10x^2y^3, then the second term from that, x^2, and finally the first component, x. If an integer's absolute value is too large for the appropriate expression, a message is given. PART works on the form of the expression as printed, or as it would have been printed at that point of the calculation, bearing in mind the current switch settings. It is important to realize that the switch settings change the operation of PART . [*note PRI::.] must be on when PART is used. When PART is used on a polynomial expression that has minus signs, the + is always returned as the top-level operator. The minus is found as a unary operator attached to the negative term. PART can also be used to change the relevant part of the expression or list as shown in the sixth example line. The PART operator returns the changed expression, though original expression is not changed. You can also use PART to change the operator. File: redhelp, Node: PF, Next: PROD, Prev: PART, Up: Algebraic Operators section PF operator syntax: pf(<expression>,<variable>) PF transforms <expression> into a [*note LIST::.] of partial fraction s with respect to the main variable, <variable>. PF does a complete partial fraction decomposition, and as the algorithms used are fairly unsophisticated (factorization and the extended Euclidean algorithm), the code may be unacceptably slow in complicated cases. examples: ____________________________________________________________ pf(2/((x+1)^2*(x+2)),x); 2 -2 2 {-----,-----,------------} X + 2 X + 1 2 X + 2*X + 1 off exp; pf(2/((x+1)^2*(x+2)),x); 2 - 2 2 {-----,-----,--------} X + 2 X + 1 2 (X + 1) for each j in ws sum j; 2 ---------------- 2 ( + 2)*(X + 1) ____________________________________________________________ If you want the denominators in factored form, turn [*note EXP::.] off, as shown in the second example above. As shown in the final example, the [*note FOR::.] EACH construct can be used to recombine the terms. Alternatively, one can use the operations on lists to extract any desired term. File: redhelp, Node: PROD, Next: REDUCT, Prev: PF, Up: Algebraic Operators section PROD operator The operator PROD returns the indefinite or definite product of a given expression. syntax: PROD (<expr>,<k>[,<lolim> [,<uplim> ]]) where <expr> is the expression to be multiplied, <k> is the control variable (a [*note KERNEL::.] ), and <lolim> and <uplim> uplim are the optional lower and upper limits. If <uplim> is not supplied the upper limit is taken as <k>. The Gosper algorithm is used. If there is no closed form solution, the operator returns the input unchanged. examples: ____________________________________________________________ prod(k/(k-2),k); k*( - k + 1) ____________________________________________________________ File: redhelp, Node: REDUCT, Next: REPART, Prev: PROD, Up: Algebraic Operators section REDUCT operator The REDUCT operator returns the remainder of its expression after the leading term with respect to the kernel in the second argument is removed. syntax: REDUCT (<expression>,<kernel>) <expression> is ordinarily a polynomial. If [*note RATARG::.] is on, a rational expression may also be used, otherwise an error results. <kernel> must be a [*note KERNEL::.] . examples: ____________________________________________________________ reduct((x+y)**3,x); 2 2 Y*(3*X + 3*X*Y + Y ) reduct(x + sin(x)**3,sin(x)); X reduct(x + sin(x)**3,y); 0 ____________________________________________________________ If the expression does not contain the kernel, REDUCT returns 0. File: redhelp, Node: REPART, Next: RESULTANT, Prev: REDUCT, Up: Algebraic Operators section REPART operator syntax: REPART (<expression>) or REPART <simple_expression> This operator returns the real part of an expression, if that argument has an numerical value. A non-numerical argument is returned as an expression in the operators REPART and [*note IMPART::.] . examples: ____________________________________________________________ repart(1+i); 1 repart(a+i*b); REPART(A) - IMPART(B) ____________________________________________________________ File: redhelp, Node: RESULTANT, Next: RHS, Prev: REPART, Up: Algebraic Operators section RESULTANT operator The RESULTANT operator computes the resultant of two polynomials with respect to a given variable. If the resultant is 0, the polynomials have a root in common. syntax: RESULTANT (<expression>,<expression>,<kernel>) <expression> must be a polynomial containing <kernel> ; <kernel> must be a [*note KERNEL::.] . examples: ____________________________________________________________ resultant(x**2 + 2*x + 1,x+1,x); 0 resultant(x**2 + 2*x + 1,x-3,x); 16 resultant(z**3 + z**2 + 5*z + 5, z**4 - 6*z**3 + 16*z**2 - 30*z + 55, z); 0 resultant(x**3*y + 4*x*y + 10,y**2 + 6*y + 4,y); 6 5 4 3 2 Y + 18*Y + 120*Y + 360*Y + 480*Y + 288*Y + 64 ____________________________________________________________ The resultant is the determinant of the Sylvester matrix, formed from the coefficients of the two polynomials in the following way: Given two polynomials: ____________________________________________________________ n n-1 a x + a1 x + ... + an ____________________________________________________________ and ____________________________________________________________ m m-1 b x + b1 x + ... + bm ____________________________________________________________ form the (m+n)x(m+n-1) Sylvester matrix by the following means: ____________________________________________________________ 0.......0 a a1 .......... an 0....0 a a1 .......... an 0 . . . . a0 a1 .......... an 0.......0 0.......0 b b1 .......... bm 0....0 b b1 .......... bm 0 . . . . b b1 .......... bm 0.......0 ____________________________________________________________ If the determinant of this matrix is 0, the two polynomials have a common root. Finding the resultant of large expressions is time-consuming, due to the time needed to find a large determinant. The sign conventions RESULTANT uses are those given in the article, "Computing in Algebraic Extensions," by R. Loos, appearing in <Computer Algebra-Symbolic and Algebraic Computation>, 2nd ed., edited by B. Buchberger, G.E. Collins and R. Loos, and published by Springer-Verlag, 1983. These are: ____________________________________________________________ resultant(p(x),q(x),x) = (-1)^{deg p(x)*deg q(x)} * resultant(q(x),p(x),x), resultant(a,p(x),x) = a^{deg p(x)}, resultant(a,b,x) = 1 ____________________________________________________________ where p(x) and q(x) are polynomials which have x as a variable, and a and b are free of x. Error messages are given if RESULTANT is given a non-polynomial expression, or a non-kernel variable. File: redhelp, Node: RHS, Next: ROOT_OF, Prev: RESULTANT, Up: Algebraic Operators section RHS operator The RHS operator returns the right-hand side of an [*note EQUATION::.] , such as those returned in a [*note LIST::.] by [*note SOLVE::.] . syntax: RHS (<equation>) or RHS <equation> <equation> must be an equation of the form left-hand side = right-hand side. examples: ____________________________________________________________ roots := solve(x**2 + 6*x*y + 5x + 3y**2,x); 2 SQRT(24*Y + 60*Y + 25) + 6*Y + 5 ROOTS := {X= - ---------------------------------, 2 2 SQRT(24*Y + 60*Y + 25) - 6*Y - 5 X= ---------------------------------} 2 root1 := rhs first roots; 2 SQRT(24*Y + 60*Y + 25) + 6*Y + 5 ROOT1 := - --------------------------------- 2 root2 := rhs second roots; 2 SQRT(24*Y + 60*Y + 25) - 6*Y - 5 ROOT2 := ---------------------------------- 2 ____________________________________________________________ An error message is given if RHS is applied to something other than an equation. File: redhelp, Node: ROOT_OF, Next: SELECT, Prev: RHS, Up: Algebraic Operators section ROOT_OF operator When the operator [*note SOLVE::.] is unable to find an explicit solution or if that solution would be too complicated, the result is presented as formal root expression using the internal operator ROOT_OF and a new local variable. An expression with a top level ROOT_OF is implicitly a list with an unknown number of elements since we can't always know how many solutions an equation has. If a substitution is made into such an expression, closed form solutions can emerge. If this occurs, the ROOT_OF construct is replaced by an operator [*note ONE_OF::.] . At this point it is of course possible to transform the result if the original SOLVE operator expression into a standard SOLVE solution. To effect this, the operator [*note EXPAND_CASES::.] can be used. examples: ____________________________________________________________ solve(a*x^7-x^2+1,x); 7 2 {x=root_of(a*x_ - x_ + 1,x_)} sub(a=0,ws); {x=one_of(1,-1)} expand_cases ws; x=1,x=-1 ____________________________________________________________ The components of ROOT_OF and ONE_OF expressions can be processed as usual with operators [*note ARGLENGTH::.] and [*note PART::.] . A higher power of a ROOT_OF expression with a polynomial as first argument is simplified by using the polynomial as a side relation. File: redhelp, Node: SELECT, Next: SHOWRULES, Prev: ROOT_OF, Up: Algebraic Operators section SELECT operator The SELECT operator extracts from a list or from the arguments of an n-ary operator elements corresponding to a boolean predicate. The predicate pattern can be a unary procedure, an operator or an algebraic expression with one [*note Free Variable::.] . syntax: SELECT (<function>,<object>) <object> is a [*note LIST::.] . <function> is the name of an operator for a single argument: the operator is evaluated once with each element of <object> as its single argument, or an algebraic expression with exactly one [*note Free Variable::.] , that is a variable preceded by the tilde symbol: the expression is evaluated for each element of <object> where the element is substituted for the free variable, or a replacement [*note RULE::.] of the form syntax: VAR => REP where <var> is a variable (a <kernel> without subscript) and <rep> is an expression which contains <var>. Here REP is evaluated for each element of <object> where the element is substituted for VAR . VAR may be optionally preceded by a tilde. The rule form for <function> is needed when more than one free variable occurs. The evaluation result of <function> is interpreted as [*note boolean value::.] corresponding to the conventions of REDUCE. The result value is built with the leading operator of the input expression. examples: ____________________________________________________________ select( ~w>0 , {1,-1,2,-3,3}) {1,2,3} q:=(part((x+y)^5,0):=list) select(evenp deg(~w,y),q); 5 3 2 4 {x ,10*x *y ,5*x*y } select(evenp deg(~w,x),2x^2+3x^3+4x^4); 2 4 2x +4x ____________________________________________________________ File: redhelp, Node: SHOWRULES, Next: SOLVE, Prev: SELECT, Up: Algebraic Operators section SHOWRULES operator syntax: SHOWRULES (<expression>) or SHOWRULES <simple_expression> SHOWRULES returns in [*note RULE::.] -LIST form any [*note OPERATOR::.] rules associated with its argument. examples: ____________________________________________________________ showrules log; {LOG(E) => 1, LOG(1) => 0, ~X LOG(E ) => ~X, 1 DF(LOG(~X),~X) => --} ~X ____________________________________________________________ Such rules can then be manipulated further as with any [*note LIST::.] . For example RHS FIRST WS; has the value 1. An operator may have properties that cannot be displayed in such a form, such as the fact it is an [*note ODD::.] function, or has a definition defined as a procedure. File: redhelp, Node: SOLVE, Next: SORT, Prev: SHOWRULES, Up: Algebraic Operators section SOLVE operator The SOLVE operator solves a single algebraic [*note EQUATION::.] or a system of simultaneous equations. syntax: SOLVE (<expression> [ , <kernel>]) or SOLVE (<expression>,... [ , <kernel> ,...] ) If the number of equations equals the number of distinct kernels, the optional kernel argument(s) may be omitted. <expression> is either a scalar expression or an [*note EQUATION::.] . When more than one expression is given, the [*note LIST::.] of expressions is surrounded by curly braces. The optional list of [*note KERNEL::.] s follows, also in curly braces. examples: ____________________________________________________________ sss := solve(x^2 + 7); Unknown: X SSS := {X= - SQRT(7)*I, X=SQRT(7)*I} rhs first sss; - SQRT(7)*I solve(sin(x^2*y),y); 2*ARBINT(1)*PI {Y=--------------- 2 X PI*(2*ARBINT(1) + 1) Y=--------------------} 2 X off allbranch; solve(sin(x**2*y),y); {Y=0} solve({3x + 5y = -4,2*x + y = -10},{x,y}); 22 46 {{X= - --,Y=--}} 7 7 solve({x + a*y + z,2x + 5},{x,y}); 5 2*Z - 5 {{X= - -,Y= - -------}} 2 2*A ab := (x+2)^2*(x^6 + 17x + 1); 8 7 6 3 2 AB := X + 4*X + 4*X + 17*X + 69*X + 72*X + 4 www := solve(ab,x); {X=ROOT F(X6 + 17*X + 1),X=-2} O root_multiplicities; {1,2} ____________________________________________________________ Results of the SOLVE operator are returned as [*note EQUATION::.] S in a [*note LIST::.] . You can use the usual list access methods ([*note FIRST::.] , [*note SECOND::.] , [*note THIRD::.] , [*note REST::.] and [*note PART::.] ) to extract the desired equation, and then use the operators [*note RHS::.] and [*note LHS::.] to access the right-hand or left-hand expression of the equation. When SOLVE is unable to solve an equation, it returns the unsolved part as the argument of ROOT_OF , with the variable renamed to avoid confusion, as shown in the last example above. For one equation, SOLVE uses square-free factorization, roots of unity, and the known inverses of the [*note LOG::.] , [*note SIN::.] , [*note COS::.] , [*note ACOS::.] , [*note ASIN::.] , and exponentiation operators. The quadratic, cubic and quartic formulas are used if necessary, but these are applied only when the switch [*note FULLROOTS::.] is set on; otherwise or when no closed form is available the result is returned as [*note ROOT_OF::.] expression. The switch [*note TRIGFORM::.] determines which type of cubic and quartic formula is used. The multiplicity of each solution is given in a list as the system variable [*note ROOT_MULTIPLICITIES::.] . For systems of simultaneous linear equations, matrix inversion is used. For nonlinear systems, the Groebner basis method is used. Linear equation system solving is influenced by the switch [*note CRAMER::.] . Singular systems can be solved when the switch [*note SOLVESINGULAR::.] is on, which is the default setting. An empty list is returned the system of equations is inconsistent. For a linear inconsistent system with parameters the variable [*note requirements::.] constraints conditions for the system to become consistent. For a solvable linear and polynomial system with parameters the variable [*note assumptions::.] contains a list side relations for the parameters: the solution is valid only as long as none of these expressions is zero. If the switch [*note VAROPT::.] is on (default), the system rearranges the variable sequence for minimal computation time. Without VAROPT the user supplied variable sequence is maintained. If the solution has free variables (dimension of the solution is greater than zero), these are represented by [*note ARBCOMPLEX::.] expressions as long as the switch [*note ARBVARS::.] is on (default). Without ARBVARS no explicit equations are generated for free variables. related: [*note ALLBRANCH::.] switch [*note ARBVARS::.] switch [*note assumptions::.] variable [*note FULLROOTS::.] switch [*note requirements::.] variable [*note ROOTS::.] operator [*note ROOT_OF::.] operator [*note TRIGFORM::.] switch [*note VAROPT::.] switch File: redhelp, Node: SORT, Next: STRUCTR, Prev: SOLVE, Up: Algebraic Operators section SORT operator The SORT operator sorts the elements of a list according to an arbitrary comparison operator. syntax: SORT (<lst>,<comp>) <lst> is a [*note LIST::.] of algebraic expressions. <comp> is a comparison operator which defines a partial ordering among the members of <lst>. <comp> may be one of the builtin comparison operators like < ([*note LESSP::.] ), <= ([*note LEQ::.] ) etc., or <comp> may be the name of a comparison procedure. Such a procedure has two arguments, and it returns [*note TRUE::.] if the first argument ranges before the second one, and 0 or [*note NIL::.] otherwise. The result of SORT is a new list which contains the elements of <lst> in a sequence corresponding to <comp>. examples: ____________________________________________________________ procedure ce(a,b); if evenp a and not evenp b then 1 else 0; for i:=1:10 collect random(50)$ sort(ws,>=); {41,38,33,30,28,25,20,17,8,5} sort(ws,<); {5,8,17,20,25,28,30,33,38,41} sort(ws,ce); {8,20,28,30,38,5,17,25,33,41} procedure cd(a,b); if deg(a,x)>deg(b,x) then 1 else if deg(a,x)<deg(b,x) then 0 else if deg(a,y)>deg(b,y) then 1 else 0; sort({x^2,y^2,x*y},cd); 2 2 {x ,x*y,y } ____________________________________________________________ File: redhelp, Node: STRUCTR, Next: SUB, Prev: SORT, Up: Algebraic Operators section STRUCTR operator The STRUCTR operator breaks its argument expression into named subexpressions. syntax: STRUCTR (<expression> [,<identifier>[,<identifier> ...]]) <expression> may be any valid REDUCE scalar expression. <identifier> may be any valid REDUCE IDENTIFIER . The first identifier is the stem for subexpression names, the second is the name to be assigned to the structured expression. examples: ____________________________________________________________ structr(sqrt(x**2 + 2*x) + sin(x**2*z)); ANS1 + ANS2 where 2 ANS2 := SIN(X *Z) 1/2 ANS1 := ((X + 2)*X) ans3; ANS3 on fort; structr((x+1)**5 + tan(x*y*z),var,aa); VAR1=TAN(X*Y*Z) AA=VAR1+X**5+5.*X**4+10.*X**3+10.X**2+5.*X+1 ____________________________________________________________ The second argument to STRUCTR is optional. If it is not given, the default stem ANS is used by REDUCE to construct names for the subexpression. The names are only for display purposes: REDUCE does not store the names and their values unless the switch [*note SAVESTRUCTR::.] is on. If a third argument is given, the structured expression as a whole is named by this argument, when [*note FORT::.] is on. The expression is not stored under this name. You can send these structured Fortran expressions to a file with the OUT command. File: redhelp, Node: SUB, Next: SUM, Prev: STRUCTR, Up: Algebraic Operators section SUB operator The SUB operator substitutes a new expression for a kernel in an expression. syntax: SUB (<kernel>= <expression> ,<kernel>= <expression>*, <expression>) or SUB (<kernel>= <expression>*, <kernel>= EXPRESSION ,<expression>) <kernel> must be a [*note KERNEL::.] , <expression> can be any REDUCE scalar expression. examples: ____________________________________________________________ sub(x=3,y=4,(x+y)**3); 343 x; X sub({cos=sin,sin=cos},cos a+sin b} COS(B) + SIN(A) ____________________________________________________________ Note in the second example that operators can be replaced using the SUB operator. File: redhelp, Node: SUM, Next: WS, Prev: SUB, Up: Algebraic Operators section SUM operator The operator SUM returns the indefinite or definite summation of a given expression. syntax: SUM (<expr>,<k>[,<lolim> [,<uplim> ]]) where <expr> is the expression to be added, <k> is the control variable (a [*note KERNEL::.] ), and <lolim> and <uplim> are the optional lower and upper limits. If <uplim> is not supplied the upper limit is taken as <k>. The Gosper algorithm is used. If there is no closed form solution, the operator returns the input unchanged. examples: ____________________________________________________________ sum(4n**3,n); 2 2 n *(n + 2*n + 1) sum(2a+2k*r,k,0,n-1); n*(2*a + n*r - r) ____________________________________________________________ File: redhelp, Node: WS, Prev: SUM, Up: Algebraic Operators section WS operator The WS operator alone returns the last result; WS with a number argument returns the results of the REDUCE statement executed after that numbered prompt. syntax: WS or WS (<number>) <number> must be an integer between 1 and the current REDUCE prompt number. examples: ____________________________________________________________ ____________________________________________________________ (In the following examples, unlike most others, the numbered prompt is shown.) ____________________________________________________________ 1: df(sin y,y); COS(Y) 2: ws^2; 2 COS(Y) 3: df(ws 1,y); -SIN(Y) ____________________________________________________________ WS and WS ( <number>) can be used anywhere the expression they stand for can be used. Calling a number for which no result was produced, such as a switch setting, will give an error message. The current workspace always contains the results of the last REDUCE command that produced an expression, even if several input statements that do not produce expressions have intervened. For example, if you do a differentiation, producing a result expression, then change several switches, the operator WS; returns the results of the differentiation. The current workspace (WS ) can also be used inside files, though the numbered workspace contains only the IN command that input the file. There are three history lists kept in your REDUCE session. The first stores raw input, suitable for the statement editor. The second stores parsed input, ready to execute and accessible by [*note INPUT::.] . The third stores results, when they are produced by statements, which are accessible by the WS < n> operator. If your session is very long, storage space begins to fill up with these expressions, so it is a good idea to end the session once in a while, saving needed expressions to files with the [*note SAVEAS::.] and [*note OUT::.] commands. An error message is given if a reference number has not yet been used. File: redhelp, Node: Algebraic Operators section, Next: Declarations section, Prev: General Commands section, Up: Top Algebraic Operators section * Menu: * APPEND:: operator * ARBINT:: operator * ARBCOMPLEX:: operator * ARGLENGTH:: operator * COEFF:: operator * COEFFN:: operator * CONJ:: operator * CONTINUED_FRACTION:: operator * DECOMPOSE:: operator * DEG:: operator * DEN:: operator * DF:: operator * EXPAND_CASES:: operator * EXPREAD:: operator * FACTORIZE:: operator * HYPOT:: operator * IMPART:: operator * INT:: operator * INTERPOL:: operator * LCOF:: operator * LENGTH:: operator * LHS:: operator * LIMIT:: operator * LPOWER:: operator * LTERM:: operator * MAINVAR:: operator * MAP:: operator * MKID:: command * NPRIMITIVE:: operator * NUM:: operator * ODESOLVE:: operator * ONE_OF:: type * PART:: operator * PF:: operator * PROD:: operator * REDUCT:: operator * REPART:: operator * RESULTANT:: operator * RHS:: operator * ROOT_OF:: operator * SELECT:: operator * SHOWRULES:: operator * SOLVE:: operator * SORT:: operator * STRUCTR:: operator * SUB:: operator * SUM:: operator * WS:: operator File: redhelp, Node: ALGEBRAIC, Next: ANTISYMMETRIC, Up: Declarations section ALGEBRAIC command The ALGEBRAIC command changes REDUCE's mode of operation to algebraic. When ALGEBRAIC is used as an operator (with an argument inside parentheses) that argument is evaluated in algebraic mode, but REDUCE's mode is not changed. examples: ____________________________________________________________ algebraic; symbolic; NIL algebraic(x**2); 2 X x**2; ***** The symbol X has no value. ____________________________________________________________ REDUCE's symbolic mode does not know about most algebraic commands. Error messages in this mode may also depend on the particular Lisp used for the REDUCE implementation. File: redhelp, Node: ANTISYMMETRIC, Next: ARRAY, Prev: ALGEBRAIC, Up: Declarations section ANTISYMMETRIC declaration When an operator is declared ANTISYMMETRIC , its arguments are reordered to conform to the internal ordering of the system. If an odd number of argument interchanges are required to do this ordering, the sign of the expression is changed. syntax: ANTISYMMETRIC <identifier>, <identifier>* <identifier> is an identifier that has been declared as an operator. examples: ____________________________________________________________ operator m,n; antisymmetric m,n; m(x,n(1,2)); - M( - N(2,1),X) operator p; antisymmetric p; p(a,b,c); P(A,B,C) p(b,a,c); - P(A,B,C) ____________________________________________________________ If <identifier> has not been declared an operator, the flag ANTISYMMETRIC is still attached to it. When <identifier> is subsequently used as an operator, the message DECLARE <identifier> OPERATOR? (Y OR N) is printed. If the user replies Y , the antisymmetric property of the operator is used. Note in the first example, identifiers are customarily ordered alphabetically, while numbers are ordered from largest to smallest. The operators may have any desired number of arguments (less than 128). File: redhelp, Node: ARRAY, Next: CLEAR, Prev: ANTISYMMETRIC, Up: Declarations section ARRAY declaration The ARRAY declaration declares a list of identifiers to be of type ARRAY , and sets all their entries to 0. syntax: ARRAY <identifier>(<dimensions>) , <identifier>(<dimensions>)* <identifier> may be any valid REDUCE identifier. If the identifier was already an array, a warning message is given that the array has been redefined. <dimensions> are of form <integer>,<integer>*. examples: ____________________________________________________________ array a(2,5),b(3,3,3),c(200); array a(3,5); *** ARRAY A REDEFINED a(3,4); 0 length a; 4,6 ____________________________________________________________ Arrays are always global, even if defined inside a procedure or block statement. Their status as an array remains until the variable is reset by [*note CLEAR::.] . Arrays may not have the same names as operators, procedures or scalar variables. Array elements are referred to by the usual notation: A(I,J) returns the jth element of the ith row. The [*note assign::.] ment operator := is used to put values into the array. Arrays as a whole cannot be subject to assignment by [*note LET::.] or := ; the assignment operator := is only valid for individual elements. When you use [*note LET::.] on an array element, the contents of that element become the argument to LET . Thus, if the element contains a number or some other expression that is not a valid argument for this command, you get an error message. If the element contains an identifier, the identifier has the substitution rule attached to it globally. The same behavior occurs with [*note CLEAR::.] . If the array element contains an identifier or simple_expression, it is cleared. Do <not> use CLEAR to try to set an array element to 0. Because of the side effects of either LET or CLEAR , it is unwise to apply either of these to array elements. Array indices always start with 0, so that the declaration ARRAY A(5) sets aside 6 units of space, indexed from 0 through 5, and initializes them to 0. The [*note LENGTH::.] command returns a list of the true number of elements in each dimension. File: redhelp, Node: CLEAR, Next: CLEARRULES, Prev: ARRAY, Up: Declarations section CLEAR command The CLEAR command is used to remove assignments or remove substitution rules from any expression. syntax: CLEAR <identifier>,<identifier>+ or <let-type statement> CLEAR <identifier> <identifier> can be any SCALAR , [*note MATRIX::.] , or [*note ARRAY::.] variable or [*note PROCEDURE::.] name. <let-type statement> can be any general or specific [*note LET::.] statement (see below in Comments). examples: ____________________________________________________________ array a(2,3); a(2,2) := 15; A(2,2) := 15 clear a; a(2,2); Declare A operator? (Y or N) let x = y + z; sin(x); SIN(Y + Z) clear x; sin(x); SIN(X) let x**5 = 7; clear x; x**5; 7 clear x**5; x**5; 5 X ____________________________________________________________ Although it is not a good idea, operators of the same name but taking different numbers of arguments can be defined. Using a CLEAR statement on any of these operators clears every one with the same name, even if the number of arguments is different. The CLEAR command is used to "forget" matrices, arrays, operators and scalar variables, returning their identifiers to the pristine state to be used for other purposes. When CLEAR is applied to array elements, the contents of the array element becomes the argument for CLEAR . Thus, you get an error message if the element contains a number, or some other expression that is not a legal argument to CLEAR . If the element contains an identifier, it is cleared. When clear is applied to matrix elements, an error message is returned if the element evaluates to a number, otherwise there is no effect. Do not try to use CLEAR to set array or matrix elements to 0. You will not be pleased with the results. If you are trying to clear power or product substitution rules made with either [*note LET::.] or [*note FORALL::.] ...LET , you must reproduce the rule, exactly as you typed it with the same arguments, up to but not including the equal sign, using the word CLEAR instead of the word LET . This is shown in the last example. Any other type of LET or FORALL ...LET substitution can be cleared with just the variable or operator name. [*note MATCH::.] behaves the same as [*note LET::.] in this situation. There is a more complicated example under [*note FORALL::.] . File: redhelp, Node: CLEARRULES, Next: DEFINE, Prev: CLEAR, Up: Declarations section CLEARRULES command syntax: CLEARRULES <list>,<list>+ The operator CLEARRULES is used to remove previously defined [*note RULE::.] lists from the system. <list> can be an explicit rule list, or evaluate to a rule list. examples: ____________________________________________________________ trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2, cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2, sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2, cos(~x)^2 => (1+cos(2*x))/2, sin(~x)^2 => (1-cos(2*x))/2}$ let trig1; cos(a)*cos(b); COS(A - B) + COS(A + B) ----------------------- 2 clearrules trig1; cos(a)*cos(b); COS(A)*COS(B) ____________________________________________________________ File: redhelp, Node: DEFINE, Next: DEPEND, Prev: CLEARRULES, Up: Declarations section DEFINE command The command DEFINE allows you to supply a new name for an identifier or replace it by any valid REDUCE expression. syntax: DEFINE <identifier>= <substitution> , <identifier>= <substitution>* <identifier> is any valid REDUCE identifier, <substitution> can be a number, an identifier, an operator, a reserved word, or an expression. examples: ____________________________________________________________ define is= :=, xx=y+z; a is 10; A := 10 xx**2; 2 2 Y + 2*Y*Z + Z xx := 10; Y + Z := 10 ____________________________________________________________ The renaming is done at the input level, and therefore takes precedence over any other replacement or substitution declared for the same identifier. It remains in effect until the end of the REDUCE session. Be careful with it, since you cannot easily undo it without ending the session. File: redhelp, Node: DEPEND, Next: EVEN, Prev: DEFINE, Up: Declarations section DEPEND declaration DEPEND declares that its first argument depends on the rest of its arguments. syntax: DEPEND <kernel>, <kernel>+ <kernel> must be a legal variable name or a prefix operator (see [*note KERNEL::.] ). examples: ____________________________________________________________ depend y,x; df(y**2,x); 2*DF(Y,X)*Y depend z,cos(x),y; df(sin(z),cos(x)); COS(Z)*DF(Z,COS(X)) df(z**2,x); 2*DF(Z,X)*Z nodepend z,y; df(z**2,x); 2*DF(Z,X)*Z cc := df(y**2,x); CC := 2*DF(Y,X)*Y y := tan x; Y := TAN(X); cc; 2 2*TAN(X)*(TAN(X) + 1) ____________________________________________________________ Dependencies can be removed by using the declaration [*note NODEPEND::.] . The differentiation operator uses this information, as shown in the examples above. Linear operators also use knowledge of dependencies (see [*note LINEAR::.] ). Note that dependencies can be nested: Having declared y to depend on x, and z to depend on y, we see that the chain rule was applied to the derivative of a function of z with respect to x. If the explicit function of the dependency is later entered into the system, terms with DF(Y,X) , for example, are expanded when they are displayed again, as shown in the last example. The boolean operator [*note FREEOF::.] allows you to check the dependency between two algebraic objects. File: redhelp, Node: EVEN, Next: FACTOR declaration, Prev: DEPEND, Up: Declarations section EVEN declaration syntax: EVEN <identifier>,<identifier>* This declaration is used to declare an operator even in its first argument. Expressions involving an operator declared in this manner are transformed if the first argument contains a minus sign. Any other arguments are not affected. examples: ____________________________________________________________ even f; f(-a) F(A) f(-a,-b) F(A,-B) ____________________________________________________________ File: redhelp, Node: FACTOR declaration, Next: FORALL, Prev: EVEN, Up: Declarations section FACTOR declaration When a kernel is declared by FACTOR , all terms involving fixed powers of that kernel are printed as a product of the fixed powers and the rest of the terms. syntax: FACTOR <kernel> , <kernel>* <kernel> must be a [*note KERNEL::.] or a [*note LIST::.] of KERNEL s. examples: ____________________________________________________________ a := (x + y + z)**2; 2 2 2 A := X + 2*X*Y + 2*X*Z + Y + 2*Y*Z + Z factor y; a; 2 2 2 Y + 2*Y*(X + Z) + X + 2*X*Z + Z factor sin(x); c := df(sin(x)**4*x**2*z,x); 4 3 2 C := 2*SIN(X) *X*Z + 4*SIN(X) *COS(X)*X *Z remfac sin(x); c; 3 2*SIN(X) *X*Z*(2*COS(X)*X + SIN(X)) ____________________________________________________________ Use the FACTOR declaration to display variables of interest so that you can see their powers more clearly, as shown in the example. Remove this special treatment with the declaration [*note REMFAC::.] . The FACTOR declaration is only effective when the switch [*note PRI::.] is on. The FACTOR declaration is not a factoring command; to factor expressions use the [*note FACTOR::.] switch or the [*note FACTORIZE::.] command. The FACTOR declaration is helpful in such cases as Taylor polynomials where the explicit powers of the variable are expected at the top level, not buried in various factored forms. File: redhelp, Node: FORALL, Next: INFIX, Prev: FACTOR declaration, Up: Declarations section FORALL command The FORALL or (preferably) FOR ALL command is used as a modifier for [*note LET::.] statements, indicating the universal applicability of the rule, with possible qualifications. syntax: FOR ALL <identifier>,<identifier>* LET <let statement> or FOR ALL <identifier>,<identifier>* SUCH THAT <condition> LET <let statement> <identifier> may be any valid REDUCE identifier, <let statement> can be an operator, a product or power, or a group or block statement. <condition> must be a logical or comparison operator returning true or false. examples: ____________________________________________________________ for all x let f(x) = sin(x**2); Declare F operator ? (Y or N) y f(a); 2 SIN(A ) operator pos; for all x such that x>=0 let pos(x) = sqrt(x + 1); pos(5); SQRT(6) pos(-5); POS(-5) clear pos; pos(5); Declare POS operator ? (Y or N) for all a such that numberp a let x**a = 1; x**4; 1 clear x**a; *** X**A not found for all a clear x**a; x**4; 1 for all a such that numberp a clear x**a; x**4; 4 X ____________________________________________________________ Substitution rules defined by FOR ALL or FOR ALL ...SUCH THAT commands that involve products or powers are cleared by reproducing the command, with exactly the same variable names used, up to but not including the equal sign, with [*note CLEAR::.] replacing LET , as shown in the last example. Other substitutions involving variables or operator names can be cleared with just the name, like any other variable. The [*note MATCH::.] command can also be used in product and power substitutions. The syntax of its use and clearing is exactly like LET . A MATCH substitution only replaces the term if it is exactly like the pattern, for example MATCH X**5 = 1 replaces only terms of X**5 and not terms of higher powers. It is easier to declare your potential operator before defining the FOR ALL rule, since the system will ask you to declare it an operator anyway. Names of declared arrays or matrices or scalar variables are invalid as operator names, to avoid ambiguity. Either FOR ALL ...LET statements or procedures are often used to define operators. One difference is that procedures implement "call by value" meaning that assignments involving their formal parameters do not change the calling variables that replace them. If you use assignment statements on the formal parameters in a FOR ALL ...LET statement, the effects are seen in the calling variables. Be careful not to redefine a system operator unless you mean it: the statement FOR ALL X LET SIN(X)=0; has exactly that effect, and the usual definition for sin(x) has been lost for the remainder of the REDUCE session. File: redhelp, Node: INFIX, Next: INTEGER, Prev: FORALL, Up: Declarations section INFIX declaration INFIX declares identifiers to be infix operators. syntax: INFIX <identifier>,<identifier>* <identifier> can be any valid REDUCE identifier, which has not already been declared an operator, array or matrix, and is not reserved by the system. examples: ____________________________________________________________ infix aa; for all x,y let aa(x,y) = cos(x)*cos(y) - sin(x)*sin(y); x aa y; COS(X)*COS(Y) - SIN(X)*SIN(Y) pi/3 aa pi/2; SQRT(3) - ------- 2 aa(pi,pi); 1 ____________________________________________________________ A [*note LET::.] statement must be used to attach functionality to the operator. Note that the operator is defined in prefix form in the LET statement. After its definition, the operator may be used in either prefix or infix mode. The above operator aa finds the cosine of the sum of two angles by the formula cos(x+y) = cos(x)*cos(y) - sin(x)*sin(y). Precedence may be attached to infix operators with the [*note PRECEDENCE::.] declaration. User-defined infix operators may be used in prefix form. If they are used in infix form, a space must be left on each side of the operator to avoid ambiguity. Infix operators are always binary. File: redhelp, Node: INTEGER, Next: KORDER, Prev: INFIX, Up: Declarations section INTEGER declaration The INTEGER declaration must be made immediately after a [*note BEGIN::.] (or other variable declaration such as [*note REAL::.] and [*note SCALAR::.] ) and declares local integer variables. They are initialized to 0. syntax: INTEGER <identifier>,<identifier>* <identifier> may be any valid REDUCE identifier, except T or NIL . Integer variables remain local, and do not share values with variables of the same name outside the [*note BEGIN::.] ...END block. When the block is finished, the variables are removed. You may use the words [*note REAL::.] or [*note SCALAR::.] in the place of INTEGER . INTEGER does not indicate typechecking by the current REDUCE; it is only for your own information. Declaration statements must immediately follow the BEGIN , without a semicolon between BEGIN and the first variable declaration. Any variables used inside BEGIN ...END blocks that were not declared SCALAR , REAL or INTEGER are global, and any change made to them inside the block affects their global value. Any [*note ARRAY::.] or [*note MATRIX::.] declared inside a block is always global. File: redhelp, Node: KORDER, Next: LET, Prev: INTEGER, Up: Declarations section KORDER declaration The KORDER declaration changes the internal canonical ordering of kernels. syntax: KORDER <kernel>, <kernel>* <kernel> must be a REDUCE [*note KERNEL::.] or a [*note LIST::.] of KERNEL s. The declaration KORDER changes the internal ordering, but not the print ordering, so the effects cannot be seen on output. However, in some calculations, the order of the variables can have significant effects on the time and space demands of a calculation. If you are doing a demanding calculation with several kernels, you can experiment with changing the canonical ordering to improve behavior. The first kernel in the argument list is given the highest priority, the second gets the next highest, and so on. Kernels not named in a KORDER ordering otherwise. A new KORDER declaration replaces the previous one. To return to canonical ordering, use the command KORDER NIL . To change the print ordering, use the declaration [*note ORDER::.] . File: redhelp, Node: LET, Next: LINEAR, Prev: KORDER, Up: Declarations section LET command The LET command defines general or specific substitution rules. syntax: LET <identifier> = <expression>,<identifier> = <expression>* <identifier> can be any valid REDUCE identifier except an array, and in some cases can be an expression; <expression> can be any valid REDUCE expression. examples: ____________________________________________________________ let a = sin(x); b := a; B := SIN X; let c = a; exp(a); SIN(X) E a := x**2; 2 A := X exp(a); 2 X E exp(b); SIN(X) E exp(c); 2 X E let m + n = p; (m + n)**5; 5 P operator h; let h(u,v) = u - v; h(u,v); U - V h(x,y); H(X,Y) array q(10); let q(1) = 15; ***** Substitution for 0 not allowed ____________________________________________________________ The LET command is also used to activate a RULE SETS . syntax: LET <list>,<list>+ <list> can be an explicit [*note RULE::.] LIST , or evaluate to a rule list. examples: ____________________________________________________________ trig1 := {cos(~x)*cos(~y) => (cos(x+y)+cos(x-y))/2, cos(~x)*sin(~y) => (sin(x+y)-sin(x-y))/2, sin(~x)*sin(~y) => (cos(x-y)-cos(x+y))/2, cos(~x)^2 => (1+cos(2*x))/2, sin(~x)^2 => (1-cos(2*x))/2}$ let trig1; cos(a)*cos(b); COS(A - B) + COS(A + B) ------------------------ 2 ____________________________________________________________ A LET command returns no value, though the substitution rule is entered. Assignment rules made by [*note assign::.] and LET rules are at the same level, and cancel each other. There is a difference in their operation, however, as shown in the first example: a LET assignment tracks the changes in what it is assigned to, while a := assignment is fixed at the value it originally had. The use of expressions as left-hand sides of LET statements is a little complicated. The rules of operation are: (i) Expressions of the form A*B = C do not change A, B or C, but set A*B to C. (ii) Expressions of the form A+B = C substitute C - B for A, but do not change B or C. (iii) Expressions of the form A-B = C substitute B + C for A, but do not change B or C. (iv) Expressions of the form A/B = C substitute B*C for A, but do not change B or C. (v) Expressions of the form A**N = C substitute C for A**N in every expression of a power of A to N or greater. An asymptotic command such as A**N = 0 sets all terms involving A to powers greater than or equal to N to 0. Finite fields may be generated by requiring modular arithmetic (the [*note MODULAR::.] switch) and defining the primitive polynomial via a LET statement. LET substitutions involving expressions are cleared by using the [*note CLEAR::.] command with exactly the same expression. Note when a simple LET statement is used to assign functionality to an operator, it is valid only for the exact identifiers used. For the use of the LET command to attach more general functionality to an operator, see [*note FORALL::.] . Arrays as a whole cannot be arguments to LET statements, but matrices as a whole can be legal arguments, provided both arguments are matrices. However, it is important to note that the two matrices are then linked. Any change to an element of one matrix changes the corresponding value in the other. Unless you want this behavior, you should not use LET for matrices. The assignment operator [*note assign::.] can be used for non-tracking assignments, avoiding the side effects. Matrices are redimensioned as needed in LET statements. When array or matrix elements are used as the left-hand side of LET statements, the contents of that element is used as the argument. When the contents is a number or some other expression that is not a valid left-hand side for LET , you get an error message. If the contents is an identifier or simple expression, the LET rule is globally attached to that identifier, and is in effect not only inside the array or matrix, but everywhere. Because of such unwanted side effects, you should not use LET with array or matrix elements. The assignment operator := can be used to put values into array or matrix elements without the side effects. Local variables declared inside BEGIN ...END blocks cannot be used as the left-hand side of LET statements. However, [*note BEGIN::.] ...END blocks themselves can be used as the right-hand side of LET statements. The construction: syntax: FOR ALL <vars> LET <operator>(<vars>)= <block> is an alternative to the syntax: PROCEDURE <name>(<vars>); <block> construction. One important difference between the two constructions is that the <vars> as formal parameters to a procedure have their global values protected against change by the procedure, while the <vars> of a LET statement are changed globally by its actions. Be careful in using a construction such as LET X = X + 1 except inside a controlled loop statement. The process of resubstitution continues until a stack overflow message is given. The LET statement may be used to make global changes to variables from inside procedures. If X is a formal parameter to a procedure, the command LET X = ... makes the change to the calling variable. For example, if a procedure was defined by ____________________________________________________________ procedure f(x,y); let x = 15; ____________________________________________________________ and the procedure was called as ____________________________________________________________ f(a,b); ____________________________________________________________ A would have its value changed to 15. Be careful when using LET statements inside procedures to avoid unwanted side effects. It is also important to be careful when replacing LET statements with other LET statements. The overlapping of these substitutions can be unpredictable. Ordinarily the latest-entered rule is the first to be applied. Sometimes the previous rule is superseded completely; other times it stays around as a special case. The order of entering a set of related LET expressions is very important to their eventual behavior. The best approach is to assume that the rules will be applied in an arbitrary order. File: redhelp, Node: LINEAR, Next: LINELENGTH, Prev: LET, Up: Declarations section LINEAR declaration An operator can be declared linear in its first argument over powers of its second argument by the declaration LINEAR. syntax: LINEAR <operator>, <operator>* <operator> must have been declared to be an operator. Be careful not to use a system operator name, because this command may change its definition. The operator being declared must have at least two arguments, and the second one must be a [*note KERNEL::.] . examples: ____________________________________________________________ operator f; linear f; f(0,x); 0 f(-y,x); - F(1,X)*Y f(y+z,x); F(1,X)*(Y + Z) f(y*z,x); F(1,X)*Y*Z depend z,x; f(y*z,x); F(Z,X)*Y f(y/z,x); 1 F(-,X)*Y Z depend y,x; f(y/z,x); Y F(-,X) Z nodepend z,x; f(y/z,x); F(Y,X) ------ Z f(2*e**sin(x),x); SIN(X) 2*F(E ,X) ____________________________________________________________ Even when the operator has not had its functionality attached, it exhibits linear properties as shown in the examples. Notice the difference when dependencies are added. Dependencies are also in effect when the operator's first argument contains its second, as in the last line above. For a fully-developed example of the use of linear operators, refer to the article in the <Journal of Computational Physics>, Vol. 14 (1974), pp. 301-317, "Analytic Computation of Some Integrals in Fourth Order Quantum Electrodynamics," by J.A. Fox and A.C. Hearn. The article includes the complete listing of REDUCE procedures used for this work. File: redhelp, Node: LINELENGTH, Next: LISP, Prev: LINEAR, Up: Declarations section LINELENGTH declaration The LINELENGTH declaration sets the length of the output line. Default is 80. syntax: LINELENGTH <expression> To change the linelength, <expression> must evaluate to a positive integer less than 128 (although this varies from system to system), and should not be less than 20 or so for proper operation. LINELENGTH returns the previous linelength. If you want the current linelength value, but not change it, say LINELENGTH NIL . File: redhelp, Node: LISP, Next: LISTARGP, Prev: LINELENGTH, Up: Declarations section LISP command The LISP command changes REDUCE's mode of operation to symbolic. When LISP is followed by an expression, that expression is evaluated in symbolic mode, but REDUCE's mode is not changed. This command is equivalent to [*note SYMBOLIC::.] . examples: ____________________________________________________________ lisp; NIL car '(a b c d e); A algebraic; c := (lisp car '(first second))**2; 2 C := FIRST ____________________________________________________________ File: redhelp, Node: LISTARGP, Next: NODEPEND, Prev: LISP, Up: Declarations section LISTARGP declaration syntax: LISTARGP <operator>, <operator>* If an operator other than those specifically defined for lists is given a single argument that is a [*note LIST::.] , then the result of this operation will be a list in which that operator is applied to each element of the list. This process can be inhibited for a specific operator, or list of operators, by using the declaration LISTARGP . examples: ____________________________________________________________ log {a,b,c}; LOG(A),LOG(B),LOG(C) listargp log; log {a,b,c}; LOG(A,B,C) ____________________________________________________________ It is possible to inhibit such distribution globally by turning on the switch [*note LISTARGS::.] . In addition, if an operator has more than one argument, no such distribution occurs, so LISTARGP has no effect. File: redhelp, Node: NODEPEND, Next: MATCH, Prev: LISTARGP, Up: Declarations section NODEPEND declaration The NODEPEND declaration removes the dependency declared with [*note DEPEND::.] . syntax: NODEPEND <dep-kernel>,<kernel>+ <dep-kernel> must be a kernel that has had a dependency declared upon the one or more other kernels that are its other arguments. examples: ____________________________________________________________ depend y,x,z; df(sin y,x); COS(Y)*DF(Y,X) df(sin y,x,z); COS(Y)*DF(Y,X,Z) - DF(Y,X)*DF(Y,Z)*SIN(Y) nodepend y,z; df(sin y,x); COS(Y)*DF(Y,X) df(sin y,x,z); 0 ____________________________________________________________ A warning message is printed if the dependency had not been declared by DEPEND . File: redhelp, Node: MATCH, Next: NONCOM, Prev: NODEPEND, Up: Declarations section MATCH command The MATCH command is similar to the [*note LET::.] command, except that it matches only explicit powers in substitution. syntax: MATCH <expr> = <expression>,<expr> = <expression>* <expr> is generally a term involving powers, and is limited by the rules for the [*note LET::.] command. <expression> may be any valid REDUCE scalar expression. examples: ____________________________________________________________ match c**2*a**2 = d; (a+c)**4; 4 3 3 4 A + 4*A *C + 4*A*C + C + 6*D match a+b = c; a + 2*b; B + C (a + b + c)**2; 2 2 2 A - B + 2*B*C + 3*C clear a+b; (a + b + c)**2; 2 2 2 A + 2*A*B + 2*A*C + B + 2*B*C + C let p*r = s; match p*q = ss; (a + p*r)**2; 2 2 A + 2*A*S + S (a + p*q)**2; 2 2 2 A + 2*A*SS + P *Q ____________________________________________________________ Note in the last example that A + B has been explicitly matched after the squaring was done, replacing each single power of A by C - B . This kind of substitution, although following the rules, is confusing and could lead to unrecognizable results. It is better to use MATCH with explicit powers or products only. MATCH should not be used inside procedures for the same reasons that LET should not be. Unlike [*note LET::.] substitutions, MATCH substitutions are executed after all other operations are complete. The last example shows the difference. MATCH commands can be cleared by using [*note CLEAR::.] , with exactly the expression that the original MATCH took. MATCH commands can also be done more generally with FOR ALL or [*note FORALL::.] ...SUCH THAT commands. File: redhelp, Node: NONCOM, Next: NONZERO, Prev: MATCH, Up: Declarations section NONCOM declaration NONCOM declares that already-declared operators are noncommutative under multiplication. syntax: NONCOM <operator>,<operator>* <operator> must have been declared an [*note OPERATOR::.] , or a warning message is given. examples: ____________________________________________________________ operator f,h; noncom f; f(a)*f(b) - f(b)*f(a); F(A)*F(B) - F(B)*F(A) h(a)*h(b) - h(b)*h(a); 0 operator comm; for all x,y such that x neq y and ordp(x,y) let f(x)*f(y) = f(y)*f(x) + comm(x,y); f(1)*f(2); F(1)*F(2) f(2)*f(1); COMM(2,1) + F(1)*F(2) ____________________________________________________________ The last example introduces the commutator of f(x) and f(y) for all x and y. The equality check is to prevent an infinite loop. The operator f can have other functionality attached to it if desired, or it can remain an indeterminate operator. File: redhelp, Node: NONZERO, Next: ODD, Prev: NONCOM, Up: Declarations section NONZERO declaration syntax: NONZERO <identifier>,<identifier>* If an [*note OPERATOR::.] F is declared [*note ODD::.] , then F(0) is replaced by zero unless F is also declared non zero by the declaration NONZERO . examples: ____________________________________________________________ odd f; f(0) 0 nonzero f; f(0) F(0) ____________________________________________________________ File: redhelp, Node: ODD, Next: OFF, Prev: NONZERO, Up: Declarations section ODD declaration syntax: ODD <identifier>,<identifier>* This declaration is used to declare an operator odd in its first argument. Expressions involving an operator declared in this manner are transformed if the first argument contains a minus sign. Any other arguments are not affected. examples: ____________________________________________________________ odd f; f(-a) -F(A) f(-a,-b) -F(A,-B) f(a,-b) F(A,-B) ____________________________________________________________ If say F is declared odd, then F(0) is replaced by zero unless F is also declared non zero by the declaration [*note NONZERO::.] . File: redhelp, Node: OFF, Next: ON, Prev: ODD, Up: Declarations section OFF command The OFF command is used to turn switches off. syntax: OFF <switch>,<switch>* <switch> can be any SWITCH name. There is no problem if the switch is already off. If the switch name is mistyped, an error message is given. File: redhelp, Node: ON, Next: OPERATOR, Prev: OFF, Up: Declarations section ON command The ON command is used to turn switches on. syntax: ON <switch>,<switch>* <switch> can be any SWITCH name. There is no problem if the switch is already on. If the switch name is mistyped, an error message is given. File: redhelp, Node: OPERATOR, Next: ORDER, Prev: ON, Up: Declarations section OPERATOR declaration Use the OPERATOR declaration to declare your own operators. syntax: OPERATOR <identifier>,<identifier>* <identifier> can be any valid REDUCE identifier, which is not the name of a [*note MATRIX::.] , [*note ARRAY::.] , scalar variable or previously-defined operator. examples: ____________________________________________________________ operator dis,fac; let dis(~x,~y) = sqrt(x^2 + y^2); dis(1,2); SQRT(5) dis(a,10); 2 SQRT(A + 100) on rounded; dis(1.5,7.2); 7.35459040329 let fac(~n) = if n=0 then 1 else if not(fixp n and n>0) then rederr "choose non-negative integer" else for i := 1:n product i; fac(5); 120 fac(-2); ***** choose non-negative integer ____________________________________________________________ The first operator is the Euclidean distance metric, the distance of point (x,y) from the origin. The second operator is the factorial. Operators can have various properties assigned to them; they can be declared [*note INFIX::.] , [*note LINEAR::.] , [*note SYMMETRIC::.] , [*note ANTISYMMETRIC::.] , or [*note NONCOM::.] MUTATIVE . The default operator is prefix, nonlinear, and commutative. Precedence can also be assigned to operators using the declaration [*note PRECEDENCE::.] . Functionality is assigned to an operator by a [*note LET::.] statement or a [*note FORALL::.] ...LET statement, (or possibly by a procedure with the name of the operator). Be careful not to redefine a system operator by accident. REDUCE permits you to redefine system operators, giving you a warning message that the operator was already defined. This flexibility allows you to add mathematical rules that do what you want them to do, but can produce odd or erroneous behavior if you are not careful. You can declare operators from inside [*note PROCEDURE::.] s, as long as they are not local variables. Operators defined inside procedures are global. A formal parameter may be declared as an operator, and has the effect of declaring the calling variable as the operator. File: redhelp, Node: ORDER, Next: PRECEDENCE, Prev: OPERATOR, Up: Declarations section ORDER declaration The ORDER declaration changes the order of precedence of kernels for display purposes only. syntax: ORDER <identifier>,<identifier>* <kernel> must be a valid [*note KERNEL::.] or [*note OPERATOR::.] name complete with argument or a [*note LIST::.] of such objects. examples: ____________________________________________________________ x + y + z + cos(a); COS(A) + X + Y + Z order z,y,x,cos(a); x + y + z + cos(a); Z + Y + X + COS(A) (x + y)**2; 2 2 Y + 2*Y*X + X order nil; (z + cos(z))**2; 2 2 COS(Z) + 2*COS(Z)*Z + Z ____________________________________________________________ ORDER affects the printing order of the identifiers only; internal order is unchanged. Change internal order of evaluation with the declaration [*note KORDER::.] . You can use ORDER to feature variables or functions you are particularly interested in. Declarations made with ORDER are cumulative: kernels in new order declarations are ordered behind those in previous declarations, and previous declarations retain their relative order. Of course, specific kernels named in new declarations are removed from previous ones and given the new priority. Return to the standard canonical printing order with the statement ORDER NIL . The print order specified by ORDER commands is not in effect if the switch [*note PRI::.] is off. File: redhelp, Node: PRECEDENCE, Next: PRECISION, Prev: ORDER, Up: Declarations section PRECEDENCE declaration The PRECEDENCE declaration attaches a precedence to an infix operator. syntax: PRECEDENCE <operator>,<known_operator> <operator> should have been declared an operator but may be a REDUCE identifier that is not already an operator, array, or matrix. <known_operator> must be a system infix operator or have had its precedence already declared. examples: ____________________________________________________________ operator f,h; precedence f,+; precedence h,*; a + f(1,2)*c; (1 F 2)*C + A a + h(1,2)*c; 1 H 2*C + A a*1 f 2*c; A F 2*C a*1 h 2*c; 1 H 2*A*C ____________________________________________________________ The operator whose precedence is being declared is inserted into the infix operator precedence list at the next higher place than <known_operator>. Attaching a precedence to an operator has the side effect of declaring the operator to be infix. If the identifier argument for PRECEDENCE has not been declared to be an operator, an attempt to use it causes an error message. After declaring it to be an operator, it becomes an infix operator with the precedence previously given. Infix operators may be used in prefix form; if they are used in infix form, a space must be left on each side of the operator to avoid ambiguity. Declared infix operators are always binary. To see the infix operator precedence list, enter symbolic mode and type PRECLIS!*; . The lowest precedence operator is listed first. All prefix operators have precedence higher than infix operators. File: redhelp, Node: PRECISION, Next: PRINT_PRECISION, Prev: PRECEDENCE, Up: Declarations section PRECISION declaration The PRECISION declaration sets the number of decimal places used when [*note ROUNDED::.] is on. Default is system dependent, and normally about 12. syntax: PRECISION (<integer>) or PRECISION <integer> <integer> must be a positive integer. When <integer> is 0, the current precision is displayed, but not changed. There is no upper limit, but precision of greater than several hundred causes unpleasantly slow operation on numeric calculations. examples: ____________________________________________________________ on rounded; 7/9; 0.777777777778 precision 20; 20 7/9; 0.77777777777777777778 sin(pi/4); 0.7071067811865475244 ____________________________________________________________ Trailing zeroes are dropped, so sometimes fewer than 20 decimal places are printed as in the last example. Turn on the switch [*note FULLPREC::.] if you want to print all significant digits. The [*note ROUNDED::.] mode carries calculations to two more places than given by PRECISION , and rounds off. File: redhelp, Node: PRINT_PRECISION, Next: REAL, Prev: PRECISION, Up: Declarations section PRINT_PRECISION declaration syntax: PRINT_PRECISION (<integer>) or PRINT_PRECISION <integer> In [*note ROUNDED::.] mode, numbers are normally printed to the specified precision. If the user wishes to print such numbers with less precision, the printing precision can be set by the declaration PRINT_PRECISION . examples: ____________________________________________________________ on rounded; 1/3; 0.333333333333 print_precision 5; 1/3 0.33333 ____________________________________________________________ File: redhelp, Node: REAL, Next: REMFAC, Prev: PRINT_PRECISION, Up: Declarations section REAL declaration The REAL declaration must be made immediately after a [*note BEGIN::.] (or other variable declaration such as [*note INTEGER::.] and [*note SCALAR::.] ) and declares local integer variables. They are initialized to zero. syntax: REAL <identifier>,<identifier>* <identifier> may be any valid REDUCE identifier, except T or NIL . Real variables remain local, and do not share values with variables of the same name outside the [*note BEGIN::.] ...END block. When the block is finished, the variables are removed. You may use the words [*note INTEGER::.] or [*note SCALAR::.] in the place of REAL . REAL does not indicate typechecking by the current REDUCE; it is only for your own information. Declaration statements must immediately follow the BEGIN , without a semicolon between BEGIN and the first variable declaration. Any variables used inside a BEGIN ...END [*note block::.] that were not declared SCALAR , REAL or INTEGER are global, and any change made to them inside the block affects their global value. Any [*note ARRAY::.] or [*note MATRIX::.] declared inside a block is always global. File: redhelp, Node: REMFAC, Next: SCALAR, Prev: REAL, Up: Declarations section REMFAC declaration The REMFAC declaration removes the special factoring treatment of its arguments that was declared with [*note FACTOR::.] . syntax: REMFAC <kernel>,<kernel>+ <kernel> must be a [*note KERNEL::.] or [*note OPERATOR::.] name that was declared as special with the [*note FACTOR::.] declaration. File: redhelp, Node: SCALAR, Next: SCIENTIFIC_NOTATION, Prev: REMFAC, Up: Declarations section SCALAR declaration The SCALAR declaration must be made immediately after a [*note BEGIN::.] (or other variable declaration such as [*note INTEGER::.] and [*note REAL::.] ) and declares local scalar variables. They are initialized to 0. syntax: SCALAR <identifier>,<identifier>* <identifier> may be any valid REDUCE identifier, except T or NIL . Scalar variables remain local, and do not share values with variables of the same name outside the [*note BEGIN::.] ...END [*note block::.] . When the block is finished, the variables are removed. You may use the words [*note REAL::.] or [*note INTEGER::.] in the place of SCALAR . REAL and INTEGER do not indicate typechecking by the current REDUCE; they are only for your own information. Declaration statements must immediately follow the BEGIN , without a semicolon between BEGIN and the first variable declaration. Any variables used inside BEGIN ...END blocks that were not declared SCALAR , REAL or INTEGER are global, and any change made to them inside the block affects their global value. Arrays declared inside a block are always global. File: redhelp, Node: SCIENTIFIC_NOTATION, Next: SHARE, Prev: SCALAR, Up: Declarations section SCIENTIFIC_NOTATION declaration syntax: SCIENTIFIC_NOTATION (<m>) or SCIENTIFIC_NOTATION (<m>,<n>) <m> and <n> are positive integers. SCIENTIFIC_NOTATION controls the output format of floating point numbers. At the default settings, any number with five or less digits before the decimal point is printed in a fixed-point notation, e.g., 12345.6. Numbers with more than five digits are printed in scientific notation, e.g., 1.234567E+5. Similarly, by default, any number with eleven or more zeros after the decimal point is printed in scientific notation. When SCIENTIFIC_NOTATION is called with the numerical argument m a number with more than m digits before the decimal point, or m or more zeros after the decimal point, is printed in scientific notation. When SCIENTIFIC_NOTATION is called with a list <m>,<n>, a number with more than m digits before the decimal point, or n or more zeros after the decimal point is printed in scientific notation. examples: ____________________________________________________________ on rounded; 12345.6; 12345.6 123456.5; 1.234565e+5 0.00000000000000012; 1.2e-16 scientific_notation 20; 5,11 5: 123456.7; 123456.7 0.00000000000000012; 0.00000000000000012 ____________________________________________________________ File: redhelp, Node: SHARE, Next: SYMBOLIC, Prev: SCIENTIFIC_NOTATION, Up: Declarations section SHARE declaration The SHARE declaration allows access to its arguments by both algebraic and symbolic modes. syntax: SHARE <identifier>,<identifier>* <identifier> can be any valid REDUCE identifier. Programming in [*note SYMBOLIC::.] as well as algebraic mode allows you a wider range of techniques than just algebraic mode alone. Expressions do not cross the boundary since they have different representations, unless the SHARE declaration is used. For more information on using symbolic mode, see the <REDUCE User's Manual>, and the <Standard Lisp Report>. You should be aware that a previously-declared array is destroyed by the SHARE declaration. Scalar variables retain their values. You can share a declared [*note MATRIX::.] that has not yet been dimensioned so that it can be used by both modes. Values that are later put into the matrix are accessible from symbolic mode too, but not by the usual matrix reference mechanism. In symbolic mode, a matrix is stored as a list whose first element is [*note MAT::.] , and whose next elements are the rows of the matrix stored as lists of the individual elements. Access in symbolic mode is by the operators [*note FIRST::.] , [*note SECOND::.] , [*note THIRD::.] and [*note REST::.] . File: redhelp, Node: SYMBOLIC, Next: SYMMETRIC, Prev: SHARE, Up: Declarations section SYMBOLIC command The SYMBOLIC command changes REDUCE's mode of operation to symbolic. When SYMBOLIC is followed by an expression, that expression is evaluated in symbolic mode, but REDUCE's mode is not changed. It is equivalent to the [*note LISP::.] command. examples: ____________________________________________________________ symbolic; NIL cdr '(a b c); (B C) algebraic; x + symbolic car '(y z); X + Y ____________________________________________________________ File: redhelp, Node: SYMMETRIC, Next: TR, Prev: SYMBOLIC, Up: Declarations section SYMMETRIC declaration When an operator is declared SYMMETRIC , its arguments are reordered to conform to the internal ordering of the system. syntax: SYMMETRIC <identifier>,<identifier>* <identifier> is an identifier that has been declared an operator. examples: ____________________________________________________________ operator m,n; symmetric m,n; m(y,a,sin(x)); M(SIN(X),A,Y) n(z,m(b,a,q)); N(M(A,B,Q),Z) ____________________________________________________________ If <identifier> has not been declared to be an operator, the flag SYMMETRIC is still attached to it. When <identifier> is subsequently used as an operator, the message DECLARE <identifier> OPERATOR ? (Y OR N) is printed. If the user replies Y , the symmetric property of the operator is used. File: redhelp, Node: TR, Next: UNTR, Prev: SYMMETRIC, Up: Declarations section TR declaration The TR declaration is used to trace system or user-written procedures. It is only useful to those with a good knowledge of both Lisp and the internal formats used by REDUCE. syntax: TR <name>,<name>* <name> is the name of a REDUCE system procedure or one of your own procedures. examples: ____________________________________________________________ ____________________________________________________________ The system procedure PREPSQ is traced, which prepares REDUCE standard forms for printing by converting them to a Lisp prefix form. ____________________________________________________________ tr prepsq; (PREPSQ) x**2 + y; PREPSQ entry: Arg 1: (((((X . 2) . 1) ((Y . 1) . 1)) . 1) PREPSQ return value = (PLUS (EXPT X 2) Y) PREPSQ entry: Arg 1: (1 . 1) PREPSQ return value = 1 2 X + Y untr prepsq; (PREPSQ) ____________________________________________________________ This example is for a PSL-based system; the above format will vary if other Lisp systems are used. When a procedure is traced, the first lines show entry to the procedure and the arguments it is given. The value returned by the procedure is printed upon exit. If you are tracing several procedures, with a call to one of them inside the other, the inner trace will be indented showing procedure nesting. There are no trace options. However, the format of the trace depends on the underlying Lisp system used. The trace can be removed with the command [*note UNTR::.] . Note that TRACE , below, is a matrix operator, while TR does procedure tracing. File: redhelp, Node: UNTR, Next: VARNAME, Prev: TR, Up: Declarations section UNTR declaration The UNTR declaration is used to remove a trace from system or user-written procedures declared with [*note TR::.] . It is only useful to those with a good knowledge of both Lisp and the internal formats used by REDUCE. syntax: UNTR <name>,<name>* <name> is the name of a REDUCE system procedure or one of your own procedures that has previously been the argument of a TR declaration. File: redhelp, Node: VARNAME, Next: WEIGHT, Prev: UNTR, Up: Declarations section VARNAME declaration The declaration VARNAME instructs REDUCE to use its argument as the default Fortran (when [*note FORT::.] is on) or [*note STRUCTR::.] identifier and identifier stem, rather than using ANS . syntax: VARNAME <identifier> <identifier> can be any combination of one or more alphanumeric characters. Try to avoid REDUCE reserved words. examples: ____________________________________________________________ varname ident; IDENT on fort; x**2 + 1; IDENT=X**2+1. off fort,exp; structr(((x+y)**2 + z)**3); 3 IDENT2 where 2 IDENT2 := IDENT1 + Z IDENT1 := X + Y ____________________________________________________________ [*note EXP::.] was turned off so that [*note STRUCTR::.] could show the structure. If EXP had been on, the expression would have been expanded into a polynomial. File: redhelp, Node: WEIGHT, Next: WHERE, Prev: VARNAME, Up: Declarations section WEIGHT command The WEIGHT command is used to attach weights to kernels for asymptotic constraints. syntax: WEIGHT <kernel> = <number> <kernel> must be a REDUCE [*note KERNEL::.] , <number> must be a positive integer, not 0. examples: ____________________________________________________________ a := (x+y)**4; 4 3 2 2 3 4 A := X + 4*X *Y + 6*X *Y + 4*X*Y + Y weight x=2,y=3; wtlevel 8; a; 4 X wtlevel 10; a; 2 2 2 X *(6*Y + 4*X*Y + X ) int(x**2,x); ***** X invalid as KERNEL ____________________________________________________________ Weights and [*note WTLEVEL::.] are used for asymptotic constraints, where higher-order terms are considered insignificant. Weights are originally equivalent to 0 until set by a WEIGHT command. To remove a weight from a kernel, use the [*note CLEAR::.] command. Weights once assigned cannot be changed without clearing the identifier. Once a weight is assigned to a kernel, it is no longer a kernel and cannot be used in any REDUCE commands or operators that require kernels, until the weight is cleared. Note that terms are ordered by greatest weight. The weight level of the system is set by [*note WTLEVEL::.] , initially at 2. Since no kernels have weights, no effect from WTLEVEL can be seen. Once you assign weights to kernels, you must set WTLEVEL correctly for the desired operation. When weighted variables appear in a term, their weights are summed for the total weight of the term (powers of variables multiply their weights). When a term exceeds the weight level of the system, it is discarded from the result expression. File: redhelp, Node: WHERE, Next: WHILE, Prev: WEIGHT, Up: Declarations section WHERE operator The WHERE operator provides an infix notation for one-time substitutions for kernels in expressions. syntax: <expression> WHERE <kernel> = <expression> ,<kernel> = <expression>* <expression> can be any REDUCE scalar expression, <kernel> must be a [*note KERNEL::.] . Alternatively a [*note RULE::.] or a RULE LIST can be a member of the right-hand part of a WHERE expression. examples: ____________________________________________________________ x**2 + 17*x*y + 4*y**2 where x=1,y=2; 51 for i := 1:5 collect x**i*q where q= for j := 1:i product j; 2 3 4 5 {X,2*X ,6*X ,24*X ,120*X } x**2 + y + z where z=y**3,y=3; 2 3 X + Y + 3 ____________________________________________________________ Substitution inside a WHERE expression has no effect upon the values of the kernels outside the expression. The WHERE operator has the lowest precedence of all the infix operators, which are lower than prefix operators, so that the substitutions apply to the entire expression preceding the WHERE operator. However, WHERE is applied before command keywords such as THEN , REPEAT , or DO . A [*note RULE::.] or a RULE SET in the right-hand part of the WHERE expression act as if the rules were activated by [*note LET::.] immediately before the evaluation of the expression and deactivated by [*note CLEARRULES::.] immediately afterwards. WHERE gives you a natural notation for auxiliary variables in expressions. As the second example shows, the substitute expression can be a command to be evaluated. The substitute assignments are made in parallel, rather than sequentially, as the last example shows. The expression resulting from the first round of substitutions is not reexamined to see if any further such substitutions can be made. WHERE can also be used to define auxiliary variables in [*note PROCEDURE::.] definitions. File: redhelp, Node: WHILE, Next: WTLEVEL, Prev: WHERE, Up: Declarations section WHILE command The WHILE command causes a statement to be repeatedly executed until a given condition is true. If the condition is initially false, the statement is not executed at all. syntax: WHILE <condition> DO <statement> <condition> is given by a logical operator, <statement> must be a single REDUCE statement, or a [*note group::.] (<< ...>> ) or [*note BEGIN::.] ...END [*note block::.] . examples: ____________________________________________________________ a := 10; A := 10 while a <= 12 do <<write a; a := a + 1>>; 10 11 12 while a < 5 do <<write a; a := a + 1>>; nothing is printed ____________________________________________________________ File: redhelp, Node: WTLEVEL, Prev: WHILE, Up: Declarations section WTLEVEL command In conjunction with [*note WEIGHT::.] , WTLEVEL is used to implement asymptotic constraints. Its default value is 2. syntax: WTLEVEL <expression> To change the weight level, <expression> must evaluate to a positive integer that is the greatest weight term to be retained in expressions involving kernels with weight assignments. WTLEVEL returns the new weight level. If you want the current weight level, but not change it, say WTLEVEL NIL . examples: ____________________________________________________________ (x+y)**4; 4 3 2 2 3 4 X + 4*X *Y + 6*X *Y + 4*X*Y + Y weight x=2,y=3; wtlevel 8; (x+y)**4; 4 X wtlevel 10; (x+y)**4; 2 2 2 X *(6*Y + 4*X*Y + X ) int(x**2,x); ***** X invalid as KERNEL ____________________________________________________________ WTLEVEL is used in conjunction with the command [*note WEIGHT::.] to enable asymptotic constraints. Weight of a term is computed by multiplying the weights of each variable in it by the power to which it has been raised, and adding the resulting weights for each variable. If the weight of the term is greater than WTLEVEL , the term is dropped from the expression, and not used in any further computation involving the expression. Once a weight has been attached to a [*note KERNEL::.] , it is no longer recognized by the system as a kernel, though still a variable. It cannot be used in REDUCE commands and operators that need kernels. The weight attachment can be undone with a [*note CLEAR::.] command. WTLEVEL can be changed as desired. File: redhelp, Node: Declarations section, Next: Input and Output section, Prev: Algebraic Operators section, Up: Top Declarations section * Menu: * ALGEBRAIC:: command * ANTISYMMETRIC:: declaration * ARRAY:: declaration * CLEAR:: command * CLEARRULES:: command * DEFINE:: command * DEPEND:: declaration * EVEN:: declaration * FACTOR declaration:: declaration * FORALL:: command * INFIX:: declaration * INTEGER:: declaration * KORDER:: declaration * LET:: command * LINEAR:: declaration * LINELENGTH:: declaration * LISP:: command * LISTARGP:: declaration * NODEPEND:: declaration * MATCH:: command * NONCOM:: declaration * NONZERO:: declaration * ODD:: declaration * OFF:: command * ON:: command * OPERATOR:: declaration * ORDER:: declaration * PRECEDENCE:: declaration * PRECISION:: declaration * PRINT_PRECISION:: declaration * REAL:: declaration * REMFAC:: declaration * SCALAR:: declaration * SCIENTIFIC_NOTATION:: declaration * SHARE:: declaration * SYMBOLIC:: command * SYMMETRIC:: declaration * TR:: declaration * UNTR:: declaration * VARNAME:: declaration * WEIGHT:: command * WHERE:: operator * WHILE:: command * WTLEVEL:: command File: redhelp, Node: IN, Next: INPUT, Up: Input and Output section IN command The IN command takes a list of file names and inputs each file into the system. syntax: IN <filename>,<filename>* <filename> must be in the current directory, or be a valid pathname. If the file name is not an identifier, double quote marks (" ) are needed around the file name. A message is given if the file cannot be found, or has a mistake in it. Ending the command with a semicolon causes the file to be echoed to the screen; ending it with a dollar sign does not echo the file. If you want some but not all of a file echoed, turn the switch [*note ECHO::.] on or off in the file. An efficient way to develop procedures in REDUCE is to write them into a file using a system editor of your choice, and then input the files into an active REDUCE session. REDUCE reparses the procedure as it takes information from the file, overwriting the previous procedure definition. When it accepts the procedure, it echoes its name to the screen. Data can also be input to the system from files. Files to be read in should always end in [*note END::.] ; to avoid end-of-file problems. Note that this is an additional END; to any ending procedures in the file. File: redhelp, Node: INPUT, Next: OUT, Prev: IN, Up: Input and Output section INPUT command The INPUT command returns the input expression to the REDUCE numbered prompt that is its argument. syntax: INPUT (<number>) or INPUT <number> <number> must be between 1 and the current REDUCE prompt number. An expression brought back by INPUT can be reexecuted with new values or switch settings, or used as an argument in another expression. The command [*note WS::.] brings back the results of a numbered REDUCE statement. Two lists contain every input and every output statement since the beginning of the session. If your session is very long, storage space begins to fill up with these expressions, so it is a good idea to end the session once in a while, saving needed expressions to files with the [*note SAVEAS::.] and [*note OUT::.] commands. Switch settings and [*note LET::.] statements can also be reexecuted by using INPUT . An error message is given if a number is called for that has not yet been used. File: redhelp, Node: OUT, Next: SHUT, Prev: INPUT, Up: Input and Output section OUT command The OUT command directs output to the filename that is its argument, until another OUT changes the output file, or [*note SHUT::.] closes it. syntax: OUT <filename> or OUT " <pathname> " or OUT T <filename> must be in the current directory, or be a valid complete file description for your system. If the file name is not in the current directory, quote marks are needed around the file name. If the file already exists, a message is printed allowing you to decide whether to supersede the contents of the file with new material. To restore output to the terminal, type OUT T , or [*note SHUT::.] the file. When you use OUT T , the file remains available, and if you open it again (with another OUT ), new material is appended rather than overwriting. To write a file using OUT that can be input at a later time, the switch [*note NAT::.] must be turned off, so that the standard linear form is saved that can be read in by [*note IN::.] . If NAT is on, exponents are printed on the line above the expression, which causes trouble when REDUCE tries to read the file. There is a slight complication if you are using the OUT command from inside a file to create another file. The [*note ECHO::.] switch is normally off at the top-level and on while reading files (so you can see what is being read in). If you create a file using OUT at the top-level, the result lines are printed into the file as you want them. But if you create such a file from inside a file, the ECHO switch is on, and every line is echoed, first as you typed it, then as REDUCE parsed it, and then once more for the file. Therefore, when you create a file from a file, you need to turn ECHO off explicitly before the OUT command, and turn it back on when you SHUT the created file, so your executing file echoes as it should. This behavior also means that as you watch the file execute, you cannot see the lines that are being put into the OUT file. As soon as you turn ECHO on, you can see output again. File: redhelp, Node: SHUT, Prev: OUT, Up: Input and Output section SHUT command The SHUT command closes output files. syntax: SHUT <filename>,<filename>* <filename> must have been a file opened by [*note OUT::.] . A file that has been opened by [*note OUT::.] must be SHUT before it is brought in by [*note IN::.] . Files that have been opened by OUT should always be SHUT before the end of the REDUCE session, to avoid either loss of information or the printing of extraneous information into the file. In most systems, terminating a session by [*note BYE::.] closes all open output files. File: redhelp, Node: Input and Output section, Next: Elementary Functions section, Prev: Declarations section, Up: Top Input and Output section * Menu: * IN:: command * INPUT:: command * OUT:: command * SHUT:: command File: redhelp, Node: ACOS, Next: ACOSH, Up: Elementary Functions section ACOS operator The ACOS operator returns the arccosine of its argument. syntax: ACOS (<expression>) or ACOS <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ acos(ab); ACOS(AB) acos 15; ACOS(15) df(acos(x*y),x); 2 2 SQRT( - X *Y + 1)*Y -------------------- 2 2 X *Y - 1 on rounded; res := acos(sqrt(2)/2); RES := 0.785398163397 res-pi/4; 0 ____________________________________________________________ An explicit numeric value is not given unless the switch [*note ROUNDED::.] is on and the argument has an absolute numeric value less than or equal to 1. File: redhelp, Node: ACOSH, Next: ACOT, Prev: ACOS, Up: Elementary Functions section ACOSH operator ACOSH represents the hyperbolic arccosine of its argument. It takes an arbitrary scalar expression as its argument. The derivative of ACOSH is known to the system. Numerical values may also be found by turning on the switch [*note ROUNDED::.] . syntax: ACOSH (<expression>) or ACOSH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ acosh a; ACOSH(A) acosh(0); ACOSH(0) df(acosh(a**2),a); 4 2*SQRT(A - 1)*A ---------------- 4 A - 1 int(acosh(x),x); INT(ACOSH(X),X) ____________________________________________________________ You may attach functionality by defining ACOSH to be the inverse of COSH . This is done by the commands ____________________________________________________________ put('cosh,'inverse,'acosh); put('acosh,'inverse,'cosh); ____________________________________________________________ You can write a procedure to attach integrals or other functions to ACOSH . You may wish to add a check to see that its argument is properly restricted. File: redhelp, Node: ACOT, Next: ACOTH, Prev: ACOSH, Up: Elementary Functions section ACOT operator ACOT represents the arccotangent of its argument. It takes an arbitrary scalar expression as its argument. The derivative of ACOT is known to the system. Numerical values may also be found by turning on the switch [*note ROUNDED::.] . syntax: ACOT (<expression>) or ACOT <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. You can add functionality yourself with LET and procedures. File: redhelp, Node: ACOTH, Next: ACSC, Prev: ACOT, Up: Elementary Functions section ACOTH operator ACOTH represents the inverse hyperbolic cotangent of its argument. It takes an arbitrary scalar expression as its argument. The derivative of ACOTH is known to the system. Numerical values may also be found by turning on the switch [*note ROUNDED::.] . syntax: ACOTH (<expression>) or ACOTH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. You can add functionality yourself with LET and procedures. File: redhelp, Node: ACSC, Next: ACSCH, Prev: ACOTH, Up: Elementary Functions section ACSC operator The ACSC operator returns the arccosecant of its argument. syntax: ACSC (<expression>) or ACSC <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ acsc(ab); ACSC(AB) acsc 15; ACSC(15) df(acsc(x*y),x); 2 2 -SQRT(X *Y - 1) ---------------- 2 2 X*(X *Y - 1) on rounded; res := acsc(2/sqrt(3)); RES := 1.0471975512 res-pi/3; 0 ____________________________________________________________ An explicit numeric value is not given unless the switch ROUNDED is on and the argument has an absolute numeric value less than or equal to 1. File: redhelp, Node: ACSCH, Next: ASEC, Prev: ACSC, Up: Elementary Functions section ACSCH operator The ACSCH operator returns the hyperbolic arccosecant of its argument. syntax: ACSCH (<expression>) or ACSCH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ acsch(ab); ACSCH(AB) acsch 15; ACSCH(15) df(acsch(x*y),x); 2 2 -SQRT(X *Y + 1) ---------------- 2 2 X*(X *Y + 1) on rounded; res := acsch(3); RES := 0.327450150237 ____________________________________________________________ An explicit numeric value is not given unless the switch ROUNDED is on and the argument has an absolute numeric value less than or equal to 1. File: redhelp, Node: ASEC, Next: ASECH, Prev: ACSCH, Up: Elementary Functions section ASEC operator The ASEC operator returns the arccosecant of its argument. syntax: ASEC (<expression>) or ASEC <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ asec(ab); ASEC(AB) asec 15; ASEC(15) df(asec(x*y),x); 2 2 SQRT(X *Y - 1) --------------- 2 2 X*(X *Y - 1) on rounded; res := asec sqrt(2); RES := 0.785398163397 res-pi/4; 0 ____________________________________________________________ An explicit numeric value is not given unless the switch ROUNDED is on and the argument has an absolute numeric value greater or equal to 1. File: redhelp, Node: ASECH, Next: ASIN, Prev: ASEC, Up: Elementary Functions section ASECH operator ASECH represents the hyperbolic arccosecant of its argument. It takes an arbitrary scalar expression as its argument. The derivative of ASECH is known to the system. Numerical values may also be found by turning on the switch [*note ROUNDED::.] . syntax: ASECH (<expression>) or ASECH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ asech a; ASECH(A) asech(1); 0 df(acosh(a**2),a); 4 2*SQRT(- A + 1) ---------------- 4 A*(A - 1) int(asech(x),x); INT(ASECH(X),X) ____________________________________________________________ You may attach functionality by defining ASECH to be the inverse of SECH . This is done by the commands ____________________________________________________________ put('sech,'inverse,'asech); put('asech,'inverse,'sech); ____________________________________________________________ You can write a procedure to attach integrals or other functions to ASECH . You may wish to add a check to see that its argument is properly restricted. File: redhelp, Node: ASIN, Next: ASINH, Prev: ASECH, Up: Elementary Functions section ASIN operator The ASIN operator returns the arcsine of its argument. syntax: ASIN (<expression>) or ASIN <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ asin(givenangle); ASIN(GIVENANGLE) asin(5); ASIN(5) df(asin(2*x),x); 2 2*SQRT( - 4*X + 1)) - -------------------- 2 4*X - 1 on rounded; asin .5; 0.523598775598 asin(sqrt(3)); ASIN(1.73205080757) asin(sqrt(3)/2); 1.04719755120 ____________________________________________________________ A numeric value is not returned by ASIN unless the switch ROUNDED is on and its argument has an absolute value less than or equal to 1. File: redhelp, Node: ASINH, Next: ATAN, Prev: ASIN, Up: Elementary Functions section ASINH operator The ASINH operator returns the hyperbolic arcsine of its argument. The derivative of ASINH and some simple transformations are known to the system. syntax: ASINH (<expression>) or ASINH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ asinh d; ASINH(D) asinh(1); ASINH(1) df(asinh(2*x),x); 2 2*SQRT(4*X + 1)) ----------------- 2 4*X + 1 ____________________________________________________________ You may attach further functionality by defining ASINH to be the inverse of SINH . This is done by the commands ____________________________________________________________ put('sinh,'inverse,'asinh); put('asinh,'inverse,'sinh); ____________________________________________________________ A numeric value is not returned by ASINH unless the switch ROUNDED is on and its argument evaluates to a number. File: redhelp, Node: ATAN, Next: ATANH, Prev: ASINH, Up: Elementary Functions section ATAN operator The ATAN operator returns the arctangent of its argument. syntax: ATAN (<expression>) or ATAN <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ atan(middle); ATAN(MIDDLE) on rounded; atan 45; 1.54857776147 off rounded; int(atan(x),x); 2 2*ATAN(X)*X - LOG(X + 1) ------------------------- 2 df(atan(y**2),y); 2*Y ------- 4 Y + 1 ____________________________________________________________ A numeric value is not returned by ATAN unless the switch [*note ROUNDED::.] is on and its argument evaluates to a number. File: redhelp, Node: ATANH, Next: ATAN2, Prev: ATAN, Up: Elementary Functions section ATANH operator The ATANH operator returns the hyperbolic arctangent of its argument. The derivative of ASINH and some simple transformations are known to the system. syntax: ATANH (<expression>) or ATANH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ atanh aa; ATANH(AA) atanh(1); ATANH(1) df(atanh(x*y),y); - X ---------- 2 2 X *Y - 1 ____________________________________________________________ A numeric value is not returned by ASINH unless the switch ROUNDED is on and its argument evaluates to a number. You may attach additional functionality by defining ATANH to be the inverse of TANH . This is done by the commands ____________________________________________________________ put('tanh,'inverse,'atanh); put('atanh,'inverse,'tanh); ____________________________________________________________ File: redhelp, Node: ATAN2, Next: COS, Prev: ATANH, Up: Elementary Functions section ATAN2 operator syntax: ATAN2 (<expression>,<expression>) <expression> is any valid scalar REDUCE expression. In [*note ROUNDED::.] mode, if a numerical value exists, ATAN2 returns the principal value of the arc tangent of the second argument divided by the first in the range [-pi,+pi] radians, using the signs of both arguments to determine the quadrant of the return value. An expression in terms of ATAN2 is returned in other cases. examples: ____________________________________________________________ atan2(3,2); ATAN2(3,2); on rounded; atan2(3,2); 0.982793723247 atan2(a,b); ATAN2(A,B); atan2(1,0); 1.57079632679 ____________________________________________________________ ATAN2 returns a numeric value only if [*note ROUNDED::.] is on. Then ATAN2 is calculated to the current degree of floating point precision. File: redhelp, Node: COS, Next: COSH, Prev: ATAN2, Up: Elementary Functions section COS operator The COS operator returns the cosine of its argument. syntax: COS (<expression>) or COS <simple_expression> <expression> is any valid scalar REDUCE expression, <simple_expression> is a single identifier or begins with a prefix operator name. examples: ____________________________________________________________ cos abc; COS(ABC) cos(pi); -1 cos 4; COS(4) on rounded; cos(4); - 0.653643620864 cos log 5; - 0.0386319699339 ____________________________________________________________ COS returns a numeric value only if [*note ROUNDED::.] is on. Then the cosine is calculated to the current degree of floating point precision. File: redhelp, Node: COSH, Next: COT, Prev: COS, Up: Elementary Functions section COSH operator The COSH operator returns the hyperbolic cosine of its argument. The derivative of COSH and some simple transformations are known to the system. syntax: COSH (<expression>) or COSH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ cosh b; COSH(B) cosh(0); 1 df(cosh(x*y),x); SINH(X*Y)*Y int(cosh(x),x); SINH(X) ____________________________________________________________ You may attach further functionality by defining its inverse (see [*note ACOSH::.] ). A numeric value is not returned by COSH unless the switch [*note ROUNDED::.] is on and its argument evaluates to a number. File: redhelp, Node: COT, Next: COTH, Prev: COSH, Up: Elementary Functions section COT operator COT represents the cotangent of its argument. It takes an arbitrary scalar expression as its argument. The derivative of ACOT and some simple properties are known to the system. syntax: COT (<expression>) or COT <simple_expression> <expression> may be any scalar REDUCE expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ cot(a)*tan(a); COT(A)*TAN(A)) cot(1); COT(1) df(cot(2*x),x); 2 - 2*(COT(2*X) + 1) ____________________________________________________________ Numerical values of expressions involving COT may be found by turning on the switch [*note ROUNDED::.] . File: redhelp, Node: COTH, Next: CSC, Prev: COT, Up: Elementary Functions section COTH operator The COTH operator returns the hyperbolic cotangent of its argument. The derivative of COTH and some simple transformations are known to the system. syntax: COTH (<expression>) or COTH <simple_expression> <expression> may be any scalar REDUCE expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ df(coth(x*y),x); 2 - Y*(COTH(X*Y) - 1) coth acoth z; Z ____________________________________________________________ You can write [*note LET::.] statements and procedures to add further functionality to COTH if you wish. Numerical values of expressions involving COTH may also be found by turning on the switch [*note ROUNDED::.] . File: redhelp, Node: CSC, Next: CSCH, Prev: COTH, Up: Elementary Functions section CSC operator The CSC operator returns the cosecant of its argument. The derivative of CSC and some simple transformations are known to the system. syntax: CSC (<expression>) or CSC <simple_expression> <expression> may be any scalar REDUCE expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ csc(q)*sin(q); CSC(Q)*SIN(Q) df(csc(x*y),x); -COT(X*Y)*CSC(X*Y)*Y ____________________________________________________________ You can write [*note LET::.] statements and procedures to add further functionality to CSC if you wish. Numerical values of expressions involving CSC may also be found by turning on the switch [*note ROUNDED::.] . File: redhelp, Node: CSCH, Next: ERF, Prev: CSC, Up: Elementary Functions section CSCH operator The COSH operator returns the hyperbolic cosecant of its argument. The derivative of CSCH and some simple transformations are known to the system. syntax: CSCH (<expression>) or CSCH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ csch b; CSCH(B) csch(0); 0 df(csch(x*y),x); - COTH(X*Y)*CSCH(X*Y)*Y int(csch(x),x); INT(CSCH(X),X) ____________________________________________________________ A numeric value is not returned by CSCH unless the switch [*note ROUNDED::.] is on and its argument evaluates to a number. File: redhelp, Node: ERF, Next: EXP, Prev: CSCH, Up: Elementary Functions section ERF operator The ERF operator represents the error function, defined by erf(x) = (2/sqrt(pi))*int(e^(-x^2),x) A limited number of its properties are known to the system, including the fact that it is an odd function. Its derivative is known, and from this, some integrals may be computed. However, a complete integration procedure for this operator is not currently included. examples: ____________________________________________________________ erf(0); 0 erf(-a); - ERF(A) df(erf(x**2),x); 4*SQRT(PI)*X ------------ 4 X E *PI int(erf(x),x); 2 X E *ERF(X)*PI*X + SQRT(PI) --------------------------- 2 X E *PI ____________________________________________________________ File: redhelp, Node: EXP, Next: SEC, Prev: ERF, Up: Elementary Functions section EXP operator The EXP operator returns E raised to the power of its argument. syntax: EXP (<expression>) or EXP <simple_expression> <expression> can be any valid REDUCE scalar expression. <simple_expression> must be a single identifier or begin with a prefix operator. examples: ____________________________________________________________ exp(sin(x)); SIN X E exp(11); 11 E on rounded; exp sin(pi/3); 2.37744267524 ____________________________________________________________ Numeric values are returned only when ROUNDED is on. The single letter E with the exponential operator ^ or ** may be substituted for EXP without change of function. File: redhelp, Node: SEC, Next: SECH, Prev: EXP, Up: Elementary Functions section SEC operator The SEC operator returns the secant of its argument. syntax: SEC (<expression>) or SEC <simple_expression> <expression> is any valid scalar REDUCE expression, <simple_expression> is a single identifier or begins with a prefix operator name. examples: ____________________________________________________________ sec abc; SEC(ABC) sec(pi); -1 sec 4; SEC(4) on rounded; sec(4); - 1.52988565647 sec log 5; - 25.8852966005 ____________________________________________________________ SEC returns a numeric value only if [*note ROUNDED::.] is on. Then the secant is calculated to the current degree of floating point precision. File: redhelp, Node: SECH, Next: SIN, Prev: SEC, Up: Elementary Functions section SECH operator The SECH operator returns the hyperbolic secant of its argument. syntax: SECH (<expression>) or SECH <simple_expression> <expression> is any valid scalar REDUCE expression, <simple_expression> is a single identifier or begins with a prefix operator name. examples: ____________________________________________________________ sech abc; SECH(ABC) sech(0); 1 sech 4; SECH(4) on rounded; sech(4); 0.0366189934737 sech log 5; 0.384615384615 ____________________________________________________________ SECH returns a numeric value only if [*note ROUNDED::.] is on. Then the expression is calculated to the current degree of floating point precision. File: redhelp, Node: SIN, Next: SINH, Prev: SECH, Up: Elementary Functions section SIN operator The SIN operator returns the sine of its argument. syntax: SIN (<expression>) or SIN <simple_expression> <expression> is any valid scalar REDUCE expression, <simple_expression> is a single identifier or begins with a prefix operator name. examples: ____________________________________________________________ sin aa; SIN(AA) sin(pi/2); 1 on rounded; sin 3; 0.14112000806 sin(pi/2); 1.0 ____________________________________________________________ SIN returns a numeric value only if ROUNDED is on. Then the sine is calculated to the current degree of floating point precision. The argument in this case is assumed to be in radians. File: redhelp, Node: SINH, Next: TAN, Prev: SIN, Up: Elementary Functions section SINH operator The SINH operator returns the hyperbolic sine of its argument. The derivative of SINH and some simple transformations are known to the system. syntax: SINH (<expression>) or SINH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ sinh b; SINH(B) sinh(0); 0 df(sinh(x**2),x); 2 2*COSH(X )*X int(sinh(4*x),x); COSH(4*X) --------- 4 on rounded; sinh 4; 27.2899171971 ____________________________________________________________ You may attach further functionality by defining its inverse (see [*note ASINH::.] ). A numeric value is not returned by SINH unless the switch [*note ROUNDED::.] is on and its argument evaluates to a number. File: redhelp, Node: TAN, Next: TANH, Prev: SINH, Up: Elementary Functions section TAN operator The TAN operator returns the tangent of its argument. syntax: TAN (<expression>) or TAN <simple_expression> <expression> is any valid scalar REDUCE expression, <simple_expression> is a single identifier or begins with a prefix operator name. examples: ____________________________________________________________ tan a; TAN(A) tan(pi/5); PI TAN(--) 5 on rounded; tan(pi/5); 0.726542528005 ____________________________________________________________ TAN returns a numeric value only if ROUNDED is on. Then the tangent is calculated to the current degree of floating point accuracy. When [*note ROUNDED::.] is on, no check is made to see if the argument of TAN is a multiple of pi/2, for which the tangent goes to positive or negative infinity. (Of course, since REDUCE uses a fixed-point representation of pi/2, it produces a large but not infinite number.) You need to make a check for multiples of pi/2 in any program you use that might possibly ask for the tangent of such a quantity. File: redhelp, Node: TANH, Prev: TAN, Up: Elementary Functions section TANH operator The TANH operator returns the hyperbolic tangent of its argument. The derivative of TANH and some simple transformations are known to the system. syntax: TANH (<expression>) or TANH <simple_expression> <expression> may be any scalar REDUCE expression, not an array, matrix or vector expression. <simple_expression> must be a single identifier or begin with a prefix operator name. examples: ____________________________________________________________ tanh b; TANH(B) tanh(0); 0 df(tanh(x*y),x); 2 Y*( - TANH(X*Y) + 1) int(tanh(x),x); 2*X LOG(E + 1) - X on rounded; tanh 2; 0.964027580076 ____________________________________________________________ You may attach further functionality by defining its inverse (see [*note ATANH::.] ). A numeric value is not returned by TANH unless the switch [*note ROUNDED::.] is on and its argument evaluates to a number. File: redhelp, Node: Elementary Functions section, Next: General Switches section, Prev: Input and Output section, Up: Top Elementary Functions section * Menu: * ACOS:: operator * ACOSH:: operator * ACOT:: operator * ACOTH:: operator * ACSC:: operator * ACSCH:: operator * ASEC:: operator * ASECH:: operator * ASIN:: operator * ASINH:: operator * ATAN:: operator * ATANH:: operator * ATAN2:: operator * COS:: operator * COSH:: operator * COT:: operator * COTH:: operator * CSC:: operator * CSCH:: operator * ERF:: operator * EXP:: operator * SEC:: operator * SECH:: operator * SIN:: operator * SINH:: operator * TAN:: operator * TANH:: operator File: redhelp, Node: SWITCHES, Next: ALGINT, Up: General Switches section SWITCHES introduction Switches are set on or off using the commands [*note ON::.] or [*note OFF::.] , respectively. The default setting of the switches described in this section is [*note OFF::.] unless stated otherwise. File: redhelp, Node: ALGINT, Next: ALLBRANCH, Prev: SWITCHES, Up: General Switches section ALGINT switch When the ALGINT switch is on, the algebraic integration module (which must be loaded from the REDUCE library) is used for integration. Loading ALGINT from the library automatically turns on the ALGINT switch. An error message will be given if ALGINT is turned on when the ALGINT has not been loaded from the library. File: redhelp, Node: ALLBRANCH, Next: ALLFAC, Prev: ALGINT, Up: General Switches section ALLBRANCH switch When ALLBRANCH is on, the operator [*note SOLVE::.] selects all branches of solutions. When ALLBRANCH is off, it selects only the principal branches. Default is ON . examples: ____________________________________________________________ solve(log(sin(x+3)),x); {X=2*ARBINT(1)*PI - ASIN(1) - 3, X=2*ARBINT(1)*PI + ASIN(1) + PI - 3} off allbranch; solve(log(sin(x+3)),x); X=ASIN(1) - 3 ____________________________________________________________ [*note ARBINT::.] (1) indicates an arbitrary integer, which is given a unique identifier by REDUCE, showing that there are infinitely many solutions of this type. When ALLBRANCH is off, the single canonical solution is given. File: redhelp, Node: ALLFAC, Next: ARBVARS, Prev: ALLBRANCH, Up: General Switches section ALLFAC switch The ALLFAC switch, when on, causes REDUCE to factor out automatically common products in the output of expressions. Default is ON . examples: ____________________________________________________________ x + x*y**3 + x**2*cos(z); 3 X*(COS(Z)*X + Y + 1) off allfac; x + x*y**3 + x**2*cos(z); 2 3 COS(Z)*X + X*Y + X ____________________________________________________________ The ALLFAC switch has no effect when PRI is off. Although the switch setting stays as it was, printing behavior is as if it were off. File: redhelp, Node: ARBVARS, Next: BALANCED_MOD, Prev: ALLFAC, Up: General Switches section ARBVARS switch When ARBVARS is on, the solutions of singular or underdetermined systems of equations are presented in terms of arbitrary complex variables (see [*note ARBCOMPLEX::.] ). Otherwise, the solution is parametrized in terms of some of the input variables. Default is ON . examples: ____________________________________________________________ solve({2x + y,4x + 2y},{x,y}); arbcomplex(1) {{x= - -------------,y=arbcomplex(1)}} 2 solve({sqrt(x)+ y**3-1},{x,y}); 6 3 {{y=arbcomplex(2),x=y - 2*y + 1}} off arbvars; solve({2x + y,4x + 2y},{x,y}); y {{x= - -}} 2 solve({sqrt(x)+ y**3-1},{x,y}); 6 3 {{x=y - 2*y + 1}} ____________________________________________________________ With ARBVARS off, the return value [[]] means that the equations given to [*note SOLVE::.] imply no relation among the input variables. File: redhelp, Node: BALANCED_MOD, Next: BFSPACE, Prev: ARBVARS, Up: General Switches section BALANCED_MOD switch [*note MODULAR::.] numbers are normally produced in the range [0,...<n>), where <n> is the current modulus. With BALANCED_MOD on, the range [-<n>/2,<n>/2] is used instead. examples: ____________________________________________________________ setmod 7; 1 on modular; 4; 4 on balanced_mod; 4; -3 ____________________________________________________________ File: redhelp, Node: BFSPACE, Next: COMBINEEXPT, Prev: BALANCED_MOD, Up: General Switches section BFSPACE switch Floating point numbers are normally printed in a compact notation (either fixed point or in scientific notation if [*note SCIENTIFIC_NOTATION::.] has been used). In some (but not all) cases, it helps comprehensibility if spaces are inserted in the number at regular intervals. The switch BFSPACE , if on, will cause a blank to be inserted in the number after every five characters. examples: ____________________________________________________________ on rounded; 1.2345678; 1.2345678 on bfspace; 1.2345678; 1.234 5678 ____________________________________________________________ BFSPACE is normally off. File: redhelp, Node: COMBINEEXPT, Next: COMBINELOGS, Prev: BFSPACE, Up: General Switches section COMBINEEXPT switch REDUCE is in general poor at surd simplification. However, when the switch COMBINEEXPT is on, the system attempts to combine exponentials whenever possible. examples: ____________________________________________________________ 3^(1/2)*3^(1/3)*3^(1/6); 1/3 1/6 SQRT(3)*3 *3 on combineexpt; ws; 1 ____________________________________________________________ File: redhelp, Node: COMBINELOGS, Next: COMP, Prev: COMBINEEXPT, Up: General Switches section COMBINELOGS switch In many cases it is desirable to expand product arguments of logarithms, or collect a sum of logarithms into a single logarithm. Since these are inverse operations, it is not possible to provide rules for doing both at the same time and preserve the REDUCE concept of idempotent evaluation. As an alternative, REDUCE provides two switches [*note EXPANDLOGS::.] and COMBINELOGS to carry out these operations. examples: ____________________________________________________________ on expandlogs; log(x*y); LOG(X) + LOG(Y) on combinelogs; ws; LOG(X*Y) ____________________________________________________________ At the present time, it is possible to have both switches on at once, which could lead to infinite recursion. However, an expression is switched from one form to the other in this case. Users should not rely on this behavior, since it may change in the next release. File: redhelp, Node: COMP, Next: COMPLEX, Prev: COMBINELOGS, Up: General Switches section COMP switch When COMP is on, any succeeding function definitions are compiled into a faster-running form. Default is OFF . examples: ____________________________________________________________ ____________________________________________________________ The following procedure finds Fibonacci numbers recursively. Create a new file "refib" in your current directory with the following lines in it: ____________________________________________________________ procedure refib(n); if fixp n and n >= 0 then if n <= 1 then 1 else refib(n-1) + refib(n-2) else rederr "nonnegative integer only"; end; ____________________________________________________________ Now load REDUCE and run the following: ____________________________________________________________ on time; Time: 100 ms in "refib"$ Time: 0 ms REFIB Time: 260 ms Time: 20 ms refib(80); 37889062373143906 Time: 14840 ms on comp; Time: 80 ms in "refib"$ Time: 20 ms REFIB Time: 640 ms refib(80); 37889062373143906 Time: 10940 ms ____________________________________________________________ Note that the compiled procedure runs faster. Your time messages will differ depending upon which system you have. Compiled functions remain so for the duration of the REDUCE session, and are then lost. They must be recompiled if wanted in another session. With the switch [*note TIME::.] on as shown above, the CPU time used in executing the command is returned in milliseconds. Be careful not to leave COMP on unless you want it, as it makes the processing of procedures much slower. File: redhelp, Node: COMPLEX, Next: CREF, Prev: COMP, Up: General Switches section COMPLEX switch When the COMPLEX switch is on, full complex arithmetic is used in simplification, function evaluation, and factorization. Default is OFF . examples: ____________________________________________________________ factorize(a**2 + b**2); 2 2 {A + B } on complex; factorize(a**2 + b**2); {A - I*B,A + I*B} (x**2 + y**2)/(x + i*y); X - I*Y on rounded; *** Domain mode COMPLEX changed to COMPLEX_FLOAT sqrt(-17); 4.12310562562*I log(7*i); 1.94591014906 + 1.57079632679*I ____________________________________________________________ Complex floating-point can be done by turning on [*note ROUNDED::.] in addition to COMPLEX . With COMPLEX off however, REDUCE knows that i is the square root of -1 but will not carry out more complicated complex operations. If you want complex denominators cleared by multiplication by their conjugates, turn on the switch [*note RATIONALIZE::.] . File: redhelp, Node: CREF, Next: CRAMER, Prev: COMPLEX, Up: General Switches section CREF switch The switch CREF invokes the CREF cross-reference program that processes a set of procedure definitions to produce a summary of their entry points, undefined procedures, non-local variables and so on. The program will also check that procedures are called with a consistent number of arguments, and print a diagnostic message otherwise. The output is alphabetized on the first seven characters of each function name. To invoke the cross-reference program, CREF is first turned on. This causes the program to load and the cross-referencing process to begin. After all the required definitions are loaded, turning CREF off will cause a cross-reference listing to be produced. Algebraic procedures in REDUCE are treated as if they were symbolic, so that algebraic constructs will actually appear as calls to symbolic functions, such as AEVAL . File: redhelp, Node: CRAMER, Next: DEFN, Prev: CREF, Up: General Switches section CRAMER switch When the CRAMER switch is on, [*note MATRIX::.] inversion and linear equation solving (operator [*note SOLVE::.] ) is done by Cramer's rule, through exterior multiplication. Default is OFF . examples: ____________________________________________________________ on time; Time: 80 ms off output; Time: 100 ms mm := mat((a,b,c,d,f),(a,a,c,f,b),(b,c,a,c,d), (c,c,a,b,f), (d,a,d,e,f)); Time: 300 ms inverse := 1/mm; Time: 18460 ms on cramer; Time: 80 ms cramersinv := 1/mm; Time: 9260 ms ____________________________________________________________ Your time readings will vary depending on the REDUCE version you use. After you invert the matrix, turn on [*note OUTPUT::.] and ask for one of the elements of the inverse matrix, such as CRAMERSINV(3,2) , so that you can see the size of the expressions produced. Inversion of matrices and the solution of linear equations with dense symbolic entries in many variables is generally considerably faster with CRAMER on. However, inversion of numeric-valued matrices is slower. Consider the matrices you're inverting before deciding whether to turn CRAMER on or off. A substantial portion of the time in matrix inversion is given to formatting the results for printing. To save this time, turn OUTPUT off, as shown in this example or terminate the expression with a dollar sign instead of a semicolon. The results are still available to you in the workspace associated with your prompt number, or you can assign them to an identifier for further use. File: redhelp, Node: DEFN, Next: DEMO, Prev: CRAMER, Up: General Switches section DEFN switch When the switch DEFN is on, the Standard Lisp equivalent of the input statement or procedure is printed, but not evaluated. Default is OFF . examples: ____________________________________________________________ on defn; 17/3; (AEVAL (LIST 'QUOTIENT 17 3)) df(sin(x),x,2); (AEVAL (LIST 'DF (LIST 'SIN 'X) 'X 2)) procedure coshval(a); begin scalar g; g := (exp(a) + exp(-a))/2; return g end; (AEVAL (PROGN (FLAG '(COSHVAL) 'OPFN) (DE COSHVAL (A) (PROG (G) (SETQ G (AEVAL (LIST 'QUOTIENT (LIST 'PLUS (LIST 'EXP A) (LIST 'EXP (LIST 'MINUS A))) 2))) (RETURN G)))) ) coshval(1); (AEVAL (LIST 'COSHVAL 1)) off defn; coshval(1); Declare COSHVAL operator? (Y or N) n procedure coshval(a); begin scalar g; g := (exp(a) + exp(-a))/2; return g end; COSHVAL on rounded; coshval(1); 1.54308063482 ____________________________________________________________ The above function COSHVAL finds the hyperbolic cosine (cosh) of its argument. When DEFN is on, you can see the Standard Lisp equivalent of the function, but it is not entered into the system as shown by the message DECLARE COSHVAL OPERATOR? . It must be reentered with DEFN off to be recognized. This procedure is used as an example; a more efficient procedure would eliminate the unnecessary local variable with ____________________________________________________________ procedure coshval(a); (exp(a) + exp(-a))/2; ____________________________________________________________ File: redhelp, Node: DEMO, Next: DFPRINT, Prev: DEFN, Up: General Switches section DEMO switch The DEMO switch is used for interactive files, causing the system to pause after each command in the file until you type a RETURN . Default is OFF . The switch DEMO has no effect on top level interactive statements. Use it when you want to slow down operations in a file so you can see what is happening. You can either include the ON DEMO command in the file, or enter it from the top level before bringing in any file. Unlike the [*note PAUSE::.] command, ON DEMO does not permit you to interrupt the file for questions of your own. File: redhelp, Node: DFPRINT, Next: DIV, Prev: DEMO, Up: General Switches section DFPRINT switch When DFPRINT is on, expressions in the differentiation operator [*note DF::.] are printed in a more "natural" notation, with the differentiation variables appearing as subscripts. In addition, if the switch [*note NOARG::.] is on (the default), the arguments of the differentiated operator are suppressed. examples: ____________________________________________________________ operator f; df(f x,x); DF(F(X),X); on dfprint; ws; F X df(f(x,y),x,y); F Y off noarg; ws; F(X,Y) X ____________________________________________________________ File: redhelp, Node: DIV, Next: ECHO, Prev: DFPRINT, Up: General Switches section DIV switch When DIV is on, the system divides any simple factors found in the denominator of an expression into the numerator. Default is OFF . examples: ____________________________________________________________ on div; a := x**2/y**2; 2 -2 A := X *Y b := a/(3*z); 1 2 -2 -1 B := -*X *Y *Z 3 off div; a; 2 X --- 2 Y b; 2 X ------- 2 3*Y *Z ____________________________________________________________ The DIV switch only has effect when the [*note PRI::.] switch is on. When PRI is off, regardless of the setting of DIV , the printing behavior is as if DIV were off. File: redhelp, Node: ECHO, Next: ERRCONT, Prev: DIV, Up: General Switches section ECHO switch The ECHO switch is normally off for top-level entry, and on when files are brought in. If ECHO is turned on at the top level, your input statements are echoed to the screen (thus appearing twice). Default OFF (but note default ON for files). If you want to display certain portions of a file and not others, use the commands OFF ECHO and ON ECHO inside the file. If you want no display of the file, use the input command IN filename$ rather than using the semicolon delimiter. Be careful when you use commands within a file to generate another file. Since ECHO is on for files, the output file echoes input statements (unlike its behavior from the top level). You should explicitly turn off ECHO when writing output, and turn it back on when you're done. File: redhelp, Node: ERRCONT, Next: EVALLHSEQP, Prev: ECHO, Up: General Switches section ERRCONT switch When the ERRCONT switch is on, error conditions do not stop file execution. Error messages will be printed whether ERRCONT is on or off. Default is OFF . The following describes what happens when an error occurs in a file under each setting of ERRCONT and INT : Both off: Message is printed and parsing continues, but no further statements are executed; no commands from keyboard accepted except bye or end; ERRCONT off, INT on: Message is printed, and you are asked if you wish to continue. (This is the default behavior); ERRCONT on, INT off: Message is printed, and file continues to execute without pause; Both on: Message is printed, and file continues to execute without pause. File: redhelp, Node: EVALLHSEQP, Next: EXP switch, Prev: ERRCONT, Up: General Switches section EVALLHSEQP switch Under normal circumstances, the right-hand-side of an [*note EQUATION::.] is evaluated but not the left-hand-side. This also applies to any substitutions made by the [*note SUB::.] operator. If both sides are to be evaluated, the switch EVALLHSEQP should be turned on. File: redhelp, Node: EXP switch, Next: EXPANDLOGS, Prev: EVALLHSEQP, Up: General Switches section EXP switch When the EXP switch is on, powers and products of expressions are expanded. Default is ON . examples: ____________________________________________________________ (x+1)**3; 3 2 X + 3*X + 3*X + 1 (a + b*i)*(c + d*i); A*C + A*D*I + B*C*I - B*D off exp; (x+1)**3; 3 (X + 1) (a + b*i)*(c + d*i); (A + B*I)*(C + D*I) length((x+1)**2/(y+1)); 2 ____________________________________________________________ Note that REDUCE knows that i^2 = -1. When EXP is off, equivalent expressions may not simplify to the same form, although zero expressions still simplify to zero. Several operators that expect a polynomial argument behave differently when EXP is off, such as [*note LENGTH::.] . Be cautious about leaving EXP off. File: redhelp, Node: EXPANDLOGS, Next: EZGCD, Prev: EXP switch, Up: General Switches section EXPANDLOGS switch In many cases it is desirable to expand product arguments of logarithms, or collect a sum of logarithms into a single logarithm. Since these are inverse operations, it is not possible to provide rules for doing both at the same time and preserve the REDUCE concept of idempotent evaluation. As an alternative, REDUCE provides two switches EXPANDLOGS and [*note COMBINELOGS::.] to carry out these operations. Both are off by default. examples: ____________________________________________________________ on expandlogs; log(x*y); LOG(X) + LOG(Y) on combinelogs; ws; LOG(X*Y) ____________________________________________________________ At the present time, it is possible to have both switches on at once, which could lead to infinite recursion. However, an expression is switched from one form to the other in this case. Users should not rely on this behavior, since it may change in the next release. File: redhelp, Node: EZGCD, Next: FACTOR, Prev: EXPANDLOGS, Up: General Switches section EZGCD switch When EZGCD and [*note GCD::.] are on, greatest common divisors are computed using the EZ GCD algorithm that uses modular arithmetic (and is usually faster). Default is OFF . As a side effect of the gcd calculation, the expressions involved are factored, though not the heavy-duty factoring of [*note FACTORIZE::.] . The EZ GCD algorithm was introduced in a paper by J. Moses and D.Y.Y. Yun in <Proceedings of the ACM>, 1973, pp. 159-166. Note that the [*note GCD::.] switch must also be on for EZGCD to have effect. File: redhelp, Node: FACTOR, Next: FAILHARD, Prev: EZGCD, Up: General Switches section FACTOR switch When the FACTOR switch is on, input expressions and results are automatically factored. examples: ____________________________________________________________ on factor; aa := 3*x**3*a + 6*x**2*y*a + 3*x**3*b + 6*x**2*y*b + x*y*a + 2*y**2*a + x*y*b + 2*y**2*b; 2 AA := (A + B)*(3*X + Y)*(X + 2*Y) off factor; aa; 3 2 2 3 2 3*A*X + 6*A*X *Y + A*X*Y + 2*A*Y + 3*B*X + 6*B*X *Y + B*X*Y + 2*B*Y^{2} on factor; ab := x**2 - 2; 2 AB := X - 2 ____________________________________________________________ REDUCE factors univariate and multivariate polynomials with integer coefficients, finding any factors that also have integer coefficients. The factoring is done by reducing multivariate problems to univariate ones with symbolic coefficients, and then solving the univariate ones modulo small primes. The results of these calculations are merged to determine the factors of the original polynomial. The factorizer normally selects evaluation points and primes using a random number generator. Thus, the detailed factoring behavior may be different each time any particular problem is tackled. When the FACTOR switch is turned on, the [*note EXP::.] switch is turned off, and when the FACTOR switch is turned off, the [*note EXP::.] switch is turned on, whether it was on previously or not. When the switch [*note TRFAC::.] is on, informative messages are generated at each call to the factorizer. The [*note TRALLFAC::.] switch causes the production of a more verbose trace message. It takes precedence over TRFAC if they are both on. To factor a polynomial explicitly and store the results, use the operator [*note FACTORIZE::.] . File: redhelp, Node: FAILHARD, Next: FORT, Prev: FACTOR, Up: General Switches section FAILHARD switch When the FAILHARD switch is on, the integration operator [*note INT::.] terminates with an error message if the integral cannot be done in closed terms. Default is off. Use the FAILHARD switch when you are dealing with complicated integrals and want to know immediately if REDUCE was unable to handle them. The integration operator sometimes returns a formal integration form that is more complicated than the original expression, when it is unable to complete the integration. File: redhelp, Node: FORT, Next: FORTUPPER, Prev: FAILHARD, Up: General Switches section FORT switch When FORT is on, output is given Fortran-compatible syntax. Default is OFF . examples: ____________________________________________________________ on fort; df(sin(7*x + y),x); ANS=7.*COS(7*X+Y) on rounded; b := log(sin(pi/5 + n*pi)); B=LOG(SIN(3.14159265359*N+0.628318530718)) ____________________________________________________________ REDUCE results can be written to a file (using [*note OUT::.] ) and used as data by Fortran programs when FORT is in effect. FORT knows about correct statement length, continuation characters, defining a symbol when it is first used, and other Fortran details. The [*note GENTRAN::.] package offers many more possibilities than the FORT switch. It produces Fortran (or C or Ratfor) code from REDUCE procedures or structured specifications, including facilities for producing double precision output. File: redhelp, Node: FORTUPPER, Next: FULLPREC, Prev: FORT, Up: General Switches section FORTUPPER switch When FORTUPPER is on, any Fortran-style output appears in upper case. Default is OFF . examples: ____________________________________________________________ on fort; df(sin(7*x + y),x); ans=7.*cos(7*x+y) on fortupper; df(sin(7*x + y),x); ANS=7.*COS(7*X+Y) ____________________________________________________________ File: redhelp, Node: FULLPREC, Next: FULLROOTS, Prev: FORTUPPER, Up: General Switches section FULLPREC switch Trailing zeroes of rounded numbers to the full system precision are normally not printed. If this information is needed, for example to get a more understandable indication of the accuracy of certain data, the switch FULLPREC can be turned on. examples: ____________________________________________________________ on rounded; 1/2; 0.5 on fullprec; ws; 0.500000000000 ____________________________________________________________ This is just an output options which neither influences the accuracy of the computation nor does it give additional information about the precision of the results. See also [*note SCIENTIFIC_NOTATION::.] . File: redhelp, Node: FULLROOTS, Next: GC, Prev: FULLPREC, Up: General Switches section FULLROOTS switch Since roots of cubic and quartic polynomials can often be very messy, a switch FULLROOTS controls the production of results in closed form. [*note SOLVE::.] will apply the formulas for explicit forms for degrees 3 and 4 only if FULLROOTS is ON . Otherwise the result forms are built using [*note ROOT_OF::.] . Default is OFF . File: redhelp, Node: GC, Next: GCD switch, Prev: FULLROOTS, Up: General Switches section GC switch With the GC switch, you can turn the garbage collection messages on or off. The form of the message depends on the particular Lisp used for the REDUCE implementation. See [*note RECLAIM::.] for an explanation of garbage collection. REDUCE does garbage collection when needed even if you have turned the notices off. File: redhelp, Node: GCD switch, Next: HORNER, Prev: GC, Up: General Switches section GCD switch When GCD is on, common factors in numerators and denominators of expressions are canceled. Default is OFF . examples: ____________________________________________________________ (2*(f*h)**2 - f**2*g*h - (f*g)**2 - f*h**3 + f*h*g**2 - h**4 + g*h**3)/(f**2*h - f**2*g - f*h**2 + 2*f*g*h - f*g**2 - g*h**2 + g**2*h); 2 2 2 2 2 2 3 3 4 F *G + F *G*H - 2*F *H - F*G *H + F*H - G*H + H ---------------------------------------------------- 2 2 2 2 2 2 F *G - F *H + F*G - 2*F*G*H + F*H - G *H + G*H on gcd; ws; 2 F*G + 2*F*H + H ---------------- F + G e2 := a*c + a*d + b*c + b*d; E2 := A*C + A*D + B*C + B*D off exp; e2; (A + B)*(C + D) ____________________________________________________________ Even with GCD off, a check is automatically made for common variable and numerical products in the numerators and denominators of expression, and the appropriate cancellations made. Thus the example demonstrating the use of GCD is somewhat complicated. Note when [*note EXP::.] is off, GCD has the side effect of factoring the expression. File: redhelp, Node: HORNER, Next: IFACTOR, Prev: GCD switch, Up: General Switches section HORNER switch When the HORNER switch is on, polynomial expressions are printed in Horner's form for faster and safer numerical evaluation. Default is OFF . The leading variable of the expression is selected as Horner variable. To select the Horner variable explicitly use the [*note KORDER::.] declaration. examples: ____________________________________________________________ on horner; (13p-4q)^3; 3 2 ( - 64)*q + p*(624*q + p*(( - 2028)*q + p*2197)) korder q; ws; 3 2 2197*p + q*(( - 2028)*p + q*(624*p + q*(-64))) ____________________________________________________________ File: redhelp, Node: IFACTOR, Next: INT switch, Prev: HORNER, Up: General Switches section IFACTOR switch When the IFACTOR switch is on, any integer terms appearing as a result of the [*note FACTORIZE::.] command are factored themselves into primes. Default is OFF . If the argument of FACTORIZE is an integer, IFACTOR has no effect, since the integer is always factored. examples: ____________________________________________________________ factorize(4*x**2 + 28*x + 48); {4,X + 3,X + 4} factorize(22587); {3,7529} on ifactor; factorize(4*x**2 + 28*x + 48); {2,2,X + 4,X + 3} factorize(22587); {3,7529} ____________________________________________________________ Constant terms that appear within nonconstant polynomial factors are not factored. The IFACTOR switch affects only factoring done specifically with [*note FACTORIZE::.] , not on factoring done automatically when the [*note FACTOR::.] switch is on. File: redhelp, Node: INT switch, Next: INTSTR, Prev: IFACTOR, Up: General Switches section INT switch The INT switch specifies an interactive mode of operation. Default ON . There is no reason to turn INT off during interactive calculations, since there are no benefits to be gained. If you do have INT off while inputting a file, and REDUCE finds an error, it prints the message "Continuing with parsing only." In this state, REDUCE accepts only [*note END::.] ; or [*note BYE::.] ; from the keyboard; everything else is ignored, even the command ON INT . File: redhelp, Node: INTSTR, Next: LCM, Prev: INT switch, Up: General Switches section INTSTR switch If INTSTR (for "internal structure") is on, arguments of an operator are printed in a more structured form. examples: ____________________________________________________________ operator f; f(2x+2y); F(2*X + 2*Y) on intstr; ws; F(2*(X + Y)) ____________________________________________________________ File: redhelp, Node: LCM, Next: LESSSPACE, Prev: INTSTR, Up: General Switches section LCM switch The LCM switch instructs REDUCE to compute the least common multiple of denominators whenever rational expressions occur. Default is ON . examples: ____________________________________________________________ off lcm; z := 1/(x**2 - y**2) + 1/(x-y)**2; 2*X*(X - Y) Z := ------------------------- 4 3 3 4 X - 2*X *Y + 2*X*Y - Y on lcm; z; 2*X*(X - Y) ------------------------- 4 3 3 4 X - 2*X *Y + 2*X*Y - Y zz := 1/(x**2 - y**2) + 1/(x-y)**2; 2*X ZZ := --------------------- 3 2 2 3 X - X *Y - X*Y + Y on gcd; z; 2*X ---------------------- 3 2 2 3 X - X *Y - X*Y + Y ____________________________________________________________ Note that LCM has effect only when rational expressions are first combined. It does not examine existing structures for simplifications on display. That is shown above when z is entered with LCM off. It remains unsimplified even after LCM is turned back on. However, a new variable containing the same expression is simplified on entry. The switch [*note GCD::.] does examine existing structures, as shown in the last example line above. Full greatest common divisor calculations become expensive if work with large rational expressions is required. A considerable savings of time can be had if a full gcd check is made only when denominators are combined, and only a partial check for numerators. This is the effect of the LCM switch. File: redhelp, Node: LESSSPACE, Next: LIMITEDFACTORS, Prev: LCM, Up: General Switches section LESSSPACE switch You can turn on the switch LESSSPACE if you want fewer blank lines in your output. File: redhelp, Node: LIMITEDFACTORS, Next: LIST switch, Prev: LESSSPACE, Up: General Switches section LIMITEDFACTORS switch To get limited factorization in cases where it is too expensive to use full multivariate polynomial factorization, the switch LIMITEDFACTORS can be turned on. In that case, only "inexpensive" factoring operations, such as square-free factorization, will be used when [*note FACTORIZE::.] is called. examples: ____________________________________________________________ a := (y-x)^2*(y^3+2x*y+5)*(y^2-3x*y+7)$ factorize a; { - X + Y, X - Y, 3 2*X*Y + Y + 5, 2 3*X*Y - Y - 7} on limitedfactors; factorize a; { - X + Y, X - Y, 2 2 4 3 5 3 2 6*X *Y + 3*X*Y - 2*X*Y + X*Y - Y - 7*Y - 5*Y - 35} ____________________________________________________________ File: redhelp, Node: LIST switch, Next: LISTARGS, Prev: LIMITEDFACTORS, Up: General Switches section LIST switch The LIST switch causes REDUCE to print each term in any sum on separate lines. examples: ____________________________________________________________ x**2*(y**2 + 2*y) + x*(y**2 + z)/(2*a); 2 2 X*(2*A*X*Y + 4*A*X*Y + Y +Z) ------------------------------ 2*A on list; ws; 2 (X*(2*A*X*Y + 4*A*X*Y 2 + Y + Z))/(2*A) ____________________________________________________________ File: redhelp, Node: LISTARGS, Next: MCD, Prev: LIST switch, Up: General Switches section LISTARGS switch If an operator other than those specifically defined for lists is given a single argument that is a list, then the result of this operation will be a list in which that operator is applied to each element of the list. This process can be inhibited globally by turning on the switch LISTARGS . examples: ____________________________________________________________ log {a,b,c}; LOG(A),LOG(B),LOG(C) on listargs; log {a,b,c}; LOG(A,B,C) ____________________________________________________________ It is possible to inhibit such distribution for a specific operator by using the declaration [*note LISTARGP::.] . In addition, if an operator has more than one argument, no such distribution occurs, so LISTARGS has no effect. File: redhelp, Node: MCD, Next: MODULAR, Prev: LISTARGS, Up: General Switches section MCD switch When MCD is on, sums and differences of rational expressions are put on a common denominator. Default is ON . examples: ____________________________________________________________ a/(x+1) + b/5; 5*A + B*X + B ------------- 5*(X + 1) off mcd; a/(x+1) + b/5; -1 (X + 1) *A + 1/5*B 1/6 + 1/7; 13/42 ____________________________________________________________ Even with MCD off, rational expressions involving only numbers are still put over a common denominator. Turning MCD off is useful when explicit negative powers are needed, or if no greatest common divisor calculations are desired, or when differentiating complicated rational expressions. Results when MCD is off are no longer in canonical form, and expressions equivalent to zero may not simplify to 0. Some operations, such as factoring cannot be done while MCD is off. This option should therefore be used with some caution. Turning MCD off is most valuable in intermediate parts of a complicated calculation, and should be turned back on for the last stage. File: redhelp, Node: MODULAR, Next: MSG, Prev: MCD, Up: General Switches section MODULAR switch When MODULAR is on, polynomial coefficients are reduced by the modulus set by [*note SETMOD::.] . If no modulus has been set, MODULAR has no effect. examples: ____________________________________________________________ setmod 2; 1 on modular; (x+y)**2; 2 2 X + Y 145*x**2 + 20*x**3 + 17 + 15*x*y; 2 X + X*Y + 1 ____________________________________________________________ Modular operations are only conducted on the coefficients, not the exponents. The modulus is not restricted to being prime. When the modulus is prime, division by a number not relatively prime to the modulus results in a <Zero divisor> error message. When the modulus is a composite number, division by a power of the modulus results in an error message, but division by an integer which is a factor of the modulus does not. The representation of modular number can be influenced by [*note BALANCED_MOD::.] . File: redhelp, Node: MSG, Next: MULTIPLICITIES, Prev: MODULAR, Up: General Switches section MSG switch When MSG is off, the printing of warning messages is suppressed. Error messages are still printed. Warning messages include those about redimensioning an [*note ARRAY::.] or declaring an [*note OPERATOR::.] where one is expected. File: redhelp, Node: MULTIPLICITIES, Next: NAT, Prev: MSG, Up: General Switches section MULTIPLICITIES switch When [*note SOLVE::.] is applied to a set of equations with multiple roots, solution multiplicities are normally stored in the global variable [*note ROOT_MULTIPLICITIES::.] rather than the solution list. If you want the multiplicities explicitly displayed, the switch MULTIPLICITIES should be turned on. In this case, ROOT_MULTIPLICITIES has no value. examples: ____________________________________________________________ solve(x^2=2x-1,x); X=1 root_multiplicities; 2 on multiplicities; solve(x^2=2x-1,x); X=1,X=1 root_multiplicities; ____________________________________________________________ File: redhelp, Node: NAT, Next: NERO, Prev: MULTIPLICITIES, Up: General Switches section NAT switch When NAT is on, output is printed to the screen in natural form, with raised exponents. NAT should be turned off when outputting expressions to a file for future input. Default is ON . examples: ____________________________________________________________ (x + y)**3; 3 2 2 3 X + 3*X *Y + 3*X*Y + Y off nat; (x + y)**3; X**3 + 3*X**2*Y + 3*X*Y**2 + Y**3$ on fort; (x + y)**3; ANS=X**3+3.*X**2*Y+3.*X*Y**2+Y**3 ____________________________________________________________ With NAT off, a dollar sign is printed at the end of each expression. An output file written with NAT off is ready to be read into REDUCE using the command [*note IN::.] . File: redhelp, Node: NERO, Next: NOARG, Prev: NAT, Up: General Switches section NERO switch When NERO is on, zero assignments (such as matrix elements) are not printed. examples: ____________________________________________________________ matrix a; a := mat((1,0),(0,1)); A(1,1) := 1 A(1,2) := 0 A(2,1) := 0 A(2,2) := 1 on nero; a; MAT(1,1) := 1 MAT(2,2) := 1 a(1,2); ____________________________________________________________ nothing is printed. ____________________________________________________________ b := 0; ____________________________________________________________ nothing is printed. ____________________________________________________________ off nero; b := 0; B := 0 ____________________________________________________________ NERO is often used when dealing with large sparse matrices, to avoid being overloaded with zero assignments. File: redhelp, Node: NOARG, Next: NOLNR, Prev: NERO, Up: General Switches section NOARG switch When [*note DFPRINT::.] is on, expressions in the differentiation operator [*note DF::.] are printed in a more "natural" notation, with the differentiation variables appearing as subscripts. When NOARG is on (the default), the arguments of the differentiated operator are also suppressed. examples: ____________________________________________________________ operator f; df(f x,x); DF(F(X),X); on dfprint; ws; F X off noarg; ws; F(X) X ____________________________________________________________ File: redhelp, Node: NOLNR, Next: NOSPLIT, Prev: NOARG, Up: General Switches section NOLNR switch When NOLNR is on, the linear properties of the integration operator [*note INT::.] are suppressed if the integral cannot be found in closed terms. REDUCE uses the linear properties of integration to attempt to break down an integral into manageable pieces. If an integral cannot be found in closed terms, these pieces are returned. When the NOLNR switch is off, as many of the pieces as possible are integrated. When it is on, if any piece fails, the rest of them remain unevaluated. File: redhelp, Node: NOSPLIT, Next: NUMVAL, Prev: NOLNR, Up: General Switches section NOSPLIT switch Under normal circumstances, the printing routines try to break an expression across lines at a natural point. This is a fairly expensive process. If you are not overly concerned about where the end-of-line breaks come, you can speed up the printing of expressions by turning off the switch NOSPLIT . This switch is normally on. File: redhelp, Node: NUMVAL, Next: OUTPUT, Prev: NOSPLIT, Up: General Switches section NUMVAL switch With [*note ROUNDED::.] on, elementary functions with numerical arguments will return a numerical answer where appropriate. If you wish to inhibit this evaluation, NUMVAL should be turned off. It is normally on. examples: ____________________________________________________________ on rounded; cos 3.4; - 0.966798192579 off numval; cos 3.4; COS(3.4) ____________________________________________________________ File: redhelp, Node: OUTPUT, Next: OVERVIEW, Prev: NUMVAL, Up: General Switches section OUTPUT switch When OUTPUT is off, no output is printed from any REDUCE calculation. The calculations have their usual effects other than printing. Default is ON . Turn output OFF if you do not wish to see output when executing large files, or to save the time REDUCE spends formatting large expressions for display. Results are still available with [*note WS::.] , or in their assigned variables. File: redhelp, Node: OVERVIEW, Next: PERIOD, Prev: OUTPUT, Up: General Switches section OVERVIEW switch When OVERVIEW is on, the amount of detail reported by the factorizer switches [*note TRFAC::.] and [*note TRALLFAC::.] is reduced. File: redhelp, Node: PERIOD, Next: PRECISE, Prev: OVERVIEW, Up: General Switches section PERIOD switch When PERIOD is on, periods are added after integers in Fortran-compatible output (when [*note FORT::.] is on). There is no effect when FORT is off. Default is ON . File: redhelp, Node: PRECISE, Next: PRET, Prev: PERIOD, Up: General Switches section PRECISE switch When the PRECISE switch is on, simplification of roots of even powers returns absolute values, a more precise answer mathematically. Default is ON . examples: ____________________________________________________________ sqrt(x**2); X (x**2)**(1/4); SQRT(X) on precise; sqrt(x**2); ABS(X) (x**2)**(1/4); SQRT(ABS(X)) ____________________________________________________________ In many types of mathematical work, simplification of powers and surds can proceed by the fastest means of simplifying the exponents arithmetically. When it is important to you that the positive root be returned, turn PRECISE on. One situation where this is important is when graphing square-root expressions such as sqrt(x^2+y^2) to avoid a spike caused by REDUCE simplifying sqrt(y^2) to y when x is zero. File: redhelp, Node: PRET, Next: PRI, Prev: PRECISE, Up: General Switches section PRET switch When PRET is on, input is printed in standard REDUCE format and then evaluated. examples: ____________________________________________________________ on pret; (x+1)^3; (x + 1)**3; 3 2 X + 3*X + 3*X + 1 procedure fac(n); if not (fixp(n) and n>=0) then rederr "Choose nonneg. integer only" else for i := 0:n-1 product i+1; procedure fac n; if not (fixp n and n>=0) then rederr "Choose nonneg. integer only" else for i := 0:n - 1 product i + 1; FAC fac 5; fac 5; 120 ____________________________________________________________ Note that all input is converted to lower case except strings (which keep the same case) all operators with a single argument have had the parentheses removed, and all infix operators have had a space added on each side. In addition, syntactical constructs like IF ...THEN ...ELSE are printed in a standard format. File: redhelp, Node: PRI, Next: RAISE, Prev: PRET, Up: General Switches section PRI switch When PRI is on, the declarations [*note ORDER::.] and [*note FACTOR::.] can be used, and the switches [*note ALLFAC::.] , [*note DIV::.] , [*note RAT::.] , and [*note REVPRI::.] take effect when they are on. Default is ON . Printing of expressions is faster with PRI off. The expressions are then returned in one standard form, without any of the display options that can be used to feature or display various parts of the expression. You can also gain insight into REDUCE's representation of expressions with PRI off. File: redhelp, Node: RAISE, Next: RAT, Prev: PRI, Up: General Switches section RAISE switch When RAISE is on, lower case letters are automatically converted to upper case on input. RAISE is normally on. This conversion affects the internal representation of the letter, and is independent of the case with which a letter is printed, which is normally lower case. File: redhelp, Node: RAT, Next: RATARG, Prev: RAISE, Up: General Switches section RAT switch When the RAT switch is on, and kernels have been selected to display with the [*note FACTOR::.] declaration, the denominator is printed with each term rather than one common denominator at the end of an expression. examples: ____________________________________________________________ (x+1)/x + x**2/sin y; 3 SIN(Y)*X + SIN(Y) + X ---------------------- factor x; SIN(Y)*X (x+1)/x + x**2/sin y; 3 X + X*SIN(Y) + SIN(Y) ---------------------- on rat; X*SIN(Y) (x+1)/x + x**2/sin y; 2 X -1 ------ + 1 + X SIN(Y) ____________________________________________________________ The RAT switch only has effect when the [*note PRI::.] switch is on. When PRI is off, regardless of the setting of RAT , the printing behavior is as if RAT were off. RAT only has effect upon the display of expressions, not their internal form. File: redhelp, Node: RATARG, Next: RATIONAL, Prev: RAT, Up: General Switches section RATARG switch When RATARG is on, rational expressions can be given to operators such as [*note COEFF::.] and [*note LTERM::.] that normally require polynomials in one of their arguments. When RATARG is off, rational expressions cause an error message. examples: ____________________________________________________________ aa := x/y**2 + 1/x + y/x**2; 3 2 3 X + X*Y + Y AA := -------------- 2 2 X *Y coeff(aa,x); 3 2 3 X + X*Y + Y ***** -------------- invalid as POLYNOMIAL 2 2 X *Y on ratarg; coeff(aa,x); Y 1 1 {--,--,0,-----} 2 2 2 2 X X X *Y ____________________________________________________________ File: redhelp, Node: RATIONAL, Next: RATIONALIZE, Prev: RATARG, Up: General Switches section RATIONAL switch When RATIONAL is on, polynomial expressions with rational coefficients are produced. examples: ____________________________________________________________ x/2 + 3*y/4; 2*X + 3*Y --------- 4 (x**2 + 5*x + 17)/2; 2 X + 5*X + 17 ------------- 2 on rational; x/2 + 3y/4; 1 3 -*(X + -*Y) 2 2 (x**2 + 5*x + 17)/2; 1 2 -*(X + 5*X + 17) 2 ____________________________________________________________ By using RATIONAL , polynomial expressions with rational coefficients can be used in some commands that expect polynomials. With RATIONAL off, such a polynomial becomes a rational expression, with denominator the least common multiple of the denominators of the rational number coefficients. File: redhelp, Node: RATIONALIZE, Next: RATPRI, Prev: RATIONAL, Up: General Switches section RATIONALIZE switch When the RATIONALIZE switch is on, denominators of rational expressions that contain complex numbers or root expressions are simplified by multiplication by their conjugates. examples: ____________________________________________________________ qq := (1+sqrt(3))/(sqrt(3)-7); SQRT(3) + 1 QQ := ----------- SQRT(3) - 7 on rationalize; qq; - 4*SQRT(3) - 5 --------------- 23 2/(4 + 6**(1/3)); 2/3 1/3 6 - 4*6 + 16 ------------------ 35 (i-1)/(i+3); 2*I - 1 ------- 5 off rationalize; (i-1)/(i+3); I - 1 ------ I + 3 ____________________________________________________________ File: redhelp, Node: RATPRI, Next: REVPRI, Prev: RATIONALIZE, Up: General Switches section RATPRI switch When the RATPRI switch is on, rational expressions and fractions are printed as two lines separated by a fraction bar, rather than in a linear style. Default is ON . examples: ____________________________________________________________ 3/17; 3 -- 17 2/b + 3/y; 3*B + 2*Y --------- B*Y off ratpri; 3/17; 3/17 2/b + 3/y; (3*B + 2*Y)/(B*Y) ____________________________________________________________ File: redhelp, Node: REVPRI, Next: RLISP88, Prev: RATPRI, Up: General Switches section REVPRI switch When the REVPRI switch is on, terms are printed in reverse order from the normal printing order. examples: ____________________________________________________________ x**5 + x**2 + 18 + sqrt(y); 5 2 SQRT(Y) + X + X + 18 a + b + c + w; A + B + C + W on revpri; x**5 + x**2 + 18 + sqrt(y); 2 5 17 + X + X + SQRT(Y) a + b + c + w; W + C + B + A ____________________________________________________________ Turn REVPRI on when you want to display a polynomial in ascending rather than descending order. File: redhelp, Node: RLISP88, Next: ROUNDALL, Prev: REVPRI, Up: General Switches section RLISP88 switch Rlisp '88 is a superset of the Rlisp that has been traditionally used for the support of REDUCE. It is fully documented in the book Marti, J.B., "RLISP '88: An Evolutionary Approach to Program Design and Reuse", World Scientific, Singapore (1993). It supports different looping constructs from the traditional Rlisp, and treats "-" as a letter unless separated by spaces. Turning on the switch RLISP88 converts to Rlisp '88 parsing conventions in symbolic mode, and enables the use of Rlisp '88 extensions. Turning off the switch reverts to the traditional Rlisp and the previous mode ( ([*note SYMBOLIC::.] or [*note ALGEBRAIC::.] ) in force before RLISP88 was turned on. File: redhelp, Node: ROUNDALL, Next: ROUNDBF, Prev: RLISP88, Up: General Switches section ROUNDALL switch In [*note ROUNDED::.] mode, rational numbers are normally converted to a floating point representation. If ROUNDALL is off, this conversion does not occur. ROUNDALL is normally ON . examples: ____________________________________________________________ on rounded; 1/2; 0.5 off roundall; ____________________________________________________________ File: redhelp, Node: ROUNDBF, Next: ROUNDED, Prev: ROUNDALL, Up: General Switches section ROUNDBF switch When [*note ROUNDED::.] is on, the normal defaults cause underflows to be converted to zero. If you really want the small number that results in such cases, ROUNDBF can be turned on. examples: ____________________________________________________________ on rounded; exp(-100000.1^2); 0 on roundbf; exp(-100000.1^2); 1.18441281937E-4342953505 ____________________________________________________________ If a polynomial is input in [*note ROUNDED::.] mode at the default precision into any [*note ROOTS::.] function, and it is not possible to represent any of the coefficients of the polynomial precisely in the system floating point representation, the switch ROUNDBF will be automatically turned on. All rounded computation will use the internal bigfloat representation until the user subsequently turns ROUNDBF off. (A message is output to indicate that this condition is in effect.) File: redhelp, Node: ROUNDED, Next: SAVESTRUCTR, Prev: ROUNDBF, Up: General Switches section ROUNDED switch When ROUNDED is on, floating-point arithmetic is enabled, with precision initially at a system default value, which is usually 12 digits. The precise number can be found by the command [*note PRECISION::.] (0). examples: ____________________________________________________________ pi; PI 35/217; 5 -- 31 on rounded; pi; 3.14159265359 35/217; 0.161 sqrt(3); 1.73205080756 ____________________________________________________________ If more than the default number of decimal places are required, use the [*note PRECISION::.] command to set the required number. File: redhelp, Node: SAVESTRUCTR, Next: SOLVESINGULAR, Prev: ROUNDED, Up: General Switches section SAVESTRUCTR switch When SAVESTRUCTR is on, results of the [*note STRUCTR::.] command are returned as a list whose first element is the representation for the expression and the remaining elements are equations showing the relationships of the generated variables. examples: ____________________________________________________________ off exp; structr((x+y)^3 + sin(x)^2); ANS3 where 3 2 ANS3 := ANS1 + ANS2 ANS2 := SIN(X) ANS1 := X + Y ans3; ANS3 on savestructr; structr((x+y)^{3} + sin(x)^{2}); 3 2 ANS3,ANS3=ANS1 + ANS2 ,ANS2=SIN(X),ANS1=X + Y ans3 where rest ws; 3 2 (X + Y) + SIN(X) ____________________________________________________________ In normal operation, [*note STRUCTR::.] is only a display command. With SAVESTRUCTR on, you can access the various parts of the expression produced by STRUCTR . The generic system names use the stem ANS . You can change this to your own stem by the command [*note VARNAME::.] . REDUCE adds integers to this stem to make unique identifiers. File: redhelp, Node: SOLVESINGULAR, Next: TIME, Prev: SAVESTRUCTR, Up: General Switches section SOLVESINGULAR switch When SOLVESINGULAR is on, singular or underdetermined systems of linear equations are solved, using arbitrary real, complex or integer variables in the answer. Default is ON . examples: ____________________________________________________________ solve({2x + y,4x + 2y},{x,y}); ARBCOMPLEX(1) {{X= - -------------,Y=ARBCOMPLEX(1)}} 2 solve({7x + 15y - z,x - y - z},{x,y,z}); 8*ARBCOMPLEX(3) {{X=---------------- 11 3*ARBCOMPLEX(3) Y= - ---------------- 11 Z=ARBCOMPLEX(3)}} off solvesingular; solve({2x + y,4x + 2y},{x,y}); ***** SOLVE given singular equations solve({7x + 15y - z,x - y - z},{x,y,z}); ***** SOLVE given singular equations ____________________________________________________________ The integer following the identifier [*note ARBCOMPLEX::.] above is assigned by the system, and serves to identify the variable uniquely. It has no other significance. File: redhelp, Node: TIME, Next: TRALLFAC, Prev: SOLVESINGULAR, Up: General Switches section TIME switch When TIME is on, the system time used in executing each REDUCE statement is printed after the answer is printed. examples: ____________________________________________________________ on time; Time: 4940 ms df(sin(x**2 + y),y); 2 COS(X + Y ) Time: 180 ms solve(x**2 - 6*y,x); {X= - SQRT(Y)*SQRT(6), X=SQRT(Y)*SQRT(6)} Time: 320 ms ____________________________________________________________ When TIME is first turned on, the time since the beginning of the REDUCE session is printed. After that, the time used in computation, (usually in milliseconds, though this is system dependent) is printed after the results of each command. Idle time or time spent typing in commands is not counted. If TIME is turned off, the first reading after it is turned on again gives the time elapsed since it was turned off. The time printed is CPU or wall clock time, depending on the system. File: redhelp, Node: TRALLFAC, Next: TRFAC, Prev: TIME, Up: General Switches section TRALLFAC switch When TRALLFAC is on, a more detailed trace of factorizer calls is generated. The TRALLFAC switch takes precedence over [*note TRFAC::.] if they are both on. TRFAC gives a factorization trace with less detail in it. When the [*note FACTOR::.] switch is on also, all input polynomials are sent to the factorizer automatically and trace information is generated. The [*note OUT::.] command saves the results of the factoring, but not the trace. File: redhelp, Node: TRFAC, Next: TRIGFORM, Prev: TRALLFAC, Up: General Switches section TRFAC switch When TRFAC is on, a narrative trace of any calls to the factorizer is generated. Default is OFF . When the switch [*note FACTOR::.] is on, and TRFAC is on, every input polynomial is sent to the factorizer, and a trace generated. With FACTOR off, only polynomials that are explicitly factored with the command [*note FACTORIZE::.] generate trace information. The [*note OUT::.] command saves the results of the factoring, but not the trace. The [*note TRALLFAC::.] switch gives trace information to a greater level of detail. File: redhelp, Node: TRIGFORM, Next: TRINT, Prev: TRFAC, Up: General Switches section TRIGFORM switch When [*note FULLROOTS::.] is on, [*note SOLVE::.] will compute the roots of a cubic or quartic polynomial is closed form. When TRIGFORM is on, the roots will be expressed by trigonometric forms. Otherwise nested surds are used. Default is ON . File: redhelp, Node: TRINT, Next: TRNONLNR, Prev: TRIGFORM, Up: General Switches section TRINT switch When TRINT is on, a narrative tracing various steps in the integration process is produced. The [*note OUT::.] command saves the results of the integration, but not the trace. File: redhelp, Node: TRNONLNR, Next: VAROPT, Prev: TRINT, Up: General Switches section TRNONLNR switch When TRNONLNR is on, a narrative tracing various steps in the process for solving non-linear equations is produced. TRNONLNR can only be used after the solve package has been loaded (e.g., by an explicit call of [*note LOAD_PACKAGE::.] ). The [*note OUT::.] command saves the results of the equation solving, but not the trace. File: redhelp, Node: VAROPT, Prev: TRNONLNR, Up: General Switches section VAROPT switch When VAROPT is on, the sequence of variables is optimized by [*note SOLVE::.] with respect to execution speed. Otherwise, the sequence given in the call to [*note SOLVE::.] is preserved. Default is ON . In combination with the switch [*note ARBVARS::.] , VAROPT can be used to control variable elimination. examples: ____________________________________________________________ off arbvars; solve({x+2z,x-3y},{x,y,z}); x x {{y=-,z= - -}} 3 2 solve({x*y=1,z=x},{x,y,z}); 1 {{z=x,y=-}} x off varopt; solve({x+2z,x-3y},{x,y,z}); 2*z {{x= - 2*z,y= - ---}} 3 solve({x*y=1,z=x},{x,y,z}); 1 {{y=-,x=z}} z ____________________________________________________________ File: redhelp, Node: General Switches section, Next: Matrix Operations section, Prev: Elementary Functions section, Up: Top General Switches section * Menu: * SWITCHES:: introduction * ALGINT:: switch * ALLBRANCH:: switch * ALLFAC:: switch * ARBVARS:: switch * BALANCED_MOD:: switch * BFSPACE:: switch * COMBINEEXPT:: switch * COMBINELOGS:: switch * COMP:: switch * COMPLEX:: switch * CREF:: switch * CRAMER:: switch * DEFN:: switch * DEMO:: switch * DFPRINT:: switch * DIV:: switch * ECHO:: switch * ERRCONT:: switch * EVALLHSEQP:: switch * EXP switch:: switch * EXPANDLOGS:: switch * EZGCD:: switch * FACTOR:: switch * FAILHARD:: switch * FORT:: switch * FORTUPPER:: switch * FULLPREC:: switch * FULLROOTS:: switch * GC:: switch * GCD switch:: switch * HORNER:: switch * IFACTOR:: switch * INT switch:: switch * INTSTR:: switch * LCM:: switch * LESSSPACE:: switch * LIMITEDFACTORS:: switch * LIST switch:: switch * LISTARGS:: switch * MCD:: switch * MODULAR:: switch * MSG:: switch * MULTIPLICITIES:: switch * NAT:: switch * NERO:: switch * NOARG:: switch * NOLNR:: switch * NOSPLIT:: switch * NUMVAL:: switch * OUTPUT:: switch * OVERVIEW:: switch * PERIOD:: switch * PRECISE:: switch * PRET:: switch * PRI:: switch * RAISE:: switch * RAT:: switch * RATARG:: switch * RATIONAL:: switch * RATIONALIZE:: switch * RATPRI:: switch * REVPRI:: switch * RLISP88:: switch * ROUNDALL:: switch * ROUNDBF:: switch * ROUNDED:: switch * SAVESTRUCTR:: switch * SOLVESINGULAR:: switch * TIME:: switch * TRALLFAC:: switch * TRFAC:: switch * TRIGFORM:: switch * TRINT:: switch * TRNONLNR:: switch * VAROPT:: switch File: redhelp, Node: COFACTOR, Next: DET, Up: Matrix Operations section COFACTOR operator The operator COFACTOR returns the cofactor of the element in row <row> and column <column> of a [*note MATRIX::.] . Errors occur if <row> or <column> do not evaluate to integer expressions or if the matrix is not square. syntax: COFACTOR (<matrix_expression>,<row>,<column>) examples: ____________________________________________________________ cofactor(mat((a,b,c),(d,e,f),(p,q,r)),2,2); A*R - C*P cofactor(mat((a,b,c),(d,e,f)),1,1); ***** non-square matrix ____________________________________________________________ File: redhelp, Node: DET, Next: MAT, Prev: COFACTOR, Up: Matrix Operations section DET operator The DET operator returns the determinant of its (square [*note MATRIX::.] ) argument. syntax: DET (<expression>) or DET <expression> <expression> must evaluate to a square matrix. examples: ____________________________________________________________ matrix m,n; m := mat((a,b),(c,d)); M(1,1) := A M(1,2) := B M(2,1) := C M(2,2) := D det m; A*D - B*C n := mat((1,2),(1,2)); N(1,1) := 1 N(1,2) := 2 N(2,1) := 1 N(2,2) := 2 det(n); 0 det(5); 5 ____________________________________________________________ Given a numerical argument, DET returns the number. However, given a variable name that has not been declared of type matrix, or a non-square matrix, DET returns an error message. File: redhelp, Node: MAT, Next: MATEIGEN, Prev: DET, Up: Matrix Operations section MAT operator The MAT operator is used to represent a two-dimensional [*note MATRIX::.] . syntax: MAT ((<expr>,<expr>*) (<expr>, <expr>*)*) <expr> may be any valid REDUCE scalar expression. examples: ____________________________________________________________ mat((1,2),(3,4)); MAT(1,1) := 1 MAT(2,3) := 2 MAT(2,1) := 3 MAT(2,2) := 4 mat(2,1); ***** Matrix mismatch Cont? (Y or N) matrix qt; qt := ws; QT(1,1) := 1 QT(1,2) := 2 QT(2,1) := 3 QT(2,2) := 4 matrix a,b; a := mat((x),(y),(z)); A(1,1) := X A(2,1) := Y A(3,1) := Z b := mat((sin x,cos x,1)); B(1,1) := SIN(X) B(1,2) := COS(X) B(1,3) := 1 ____________________________________________________________ Matrices need not have a size declared (unlike arrays). MAT redimensions a matrix variable as needed. It is necessary, of course, that all rows be the same length. An anonymous matrix, as shown in the first example, must be named before it can be referenced (note error message). When using MAT to fill a 1 x n matrix, the row of values must be inside a second set of parentheses, to eliminate ambiguity. File: redhelp, Node: MATEIGEN, Next: MATRIX, Prev: MAT, Up: Matrix Operations section MATEIGEN operator The MATEIGEN operator calculates the eigenvalue equation and the corresponding eigenvectors of a [*note MATRIX::.] . syntax: MATEIGEN (<matrix-id>,<tag-id>) <matrix-id> must be a declared matrix of values, and <tag-id> must be a legal REDUCE identifier. examples: ____________________________________________________________ aa := mat((2,5),(1,0))$ mateigen(aa,alpha); 2 {{ALPHA - 2*ALPHA - 5, 1, 5*ARBCOMPLEX(1) MAT(1,1) := ---------------, ALPHA - 2 @ MAT(2,1) := ARBCOMPLEX(1) }} charpoly := first first ws; 2 CHARPOLY := ALPHA - 2*ALPHA - 5 bb := mat((1,0,1),(1,1,0),(0,0,1))$ mateigen(bb,lamb); {{LAMB - 1,3, [ 0 ] [ARBCOMPLEX(2)] [ 0 ] }} ____________________________________________________________ The MATEIGEN operator returns a list of lists of three elements. The first element is a square free factor of the characteristic polynomial; the second element is its multiplicity; and the third element is the corresponding eigenvector. If the characteristic polynomial can be completely factored, the product of the first elements of all the sublists will produce the minimal polynomial. You can access the various parts of the answer with the usual list access operators. If the matrix is degenerate, more than one eigenvector can be produced for the same eigenvalue, as shown by more than one arbitrary variable in the eigenvector. The identification numbers of the arbitrary complex variables shown in the examples above may not be the same as yours. Note that since LAMBDA is a reserved word in REDUCE, you cannot use it as a tag-id for this operator. File: redhelp, Node: MATRIX, Next: NULLSPACE, Prev: MATEIGEN, Up: Matrix Operations section MATRIX declaration Identifiers are declared to be of type MATRIX . syntax: MATRIX <identifier> option (<index>,<index>) ,<identifier> option (<index>,<index>)* <identifier> must not be an already-defined operator or array or the name of a scalar variable. Dimensions are optional, and if used appear inside parentheses. <index> must be a positive integer. examples: ____________________________________________________________ matrix a,b(1,4),c(4,4); b(1,1); 0 a(1,1); ***** Matrix A not set a := mat((x0,y0),(x1,y1)); A(1,1) := X0 A(1,2) := Y0 A(2,1) := X0 A(2,2) := X1 length a; {2,2} b := a**2; 2 B(1,1) := X0 + X1*Y0 B(1,2) := Y0*(X0 + Y1) B(2,1) := X1*(X0 + Y1) 2 B(2,2) := X1*Y0 + Y1 ____________________________________________________________ When a matrix variable has not been dimensioned, matrix elements cannot be referenced until the matrix is set by the [*note MAT::.] operator. When a matrix is dimensioned in its declaration, matrix elements are set to 0. Matrix elements cannot stand for themselves. When you use [*note LET::.] on a matrix element, there is no effect unless the element contains a constant, in which case an error message is returned. The same behavior occurs with [*note CLEAR::.] . Do <not> use [*note CLEAR::.] to try to set a matrix element to 0. [*note LET::.] statements can be applied to matrices as a whole, if the right-hand side of the expression is a matrix expression, and the left-hand side identifier has been declared to be a matrix. Arithmetical operators apply to matrices of the correct dimensions. The operators + and - can be used with matrices of the same dimensions. The operator * can be used to multiply m x n matrices by n x p matrices. Matrix multiplication is non-commutative. Scalars can also be multiplied with matrices, with the result that each element of the matrix is multiplied by the scalar. The operator / applied to two matrices computes the first matrix multiplied by the inverse of the second, if the inverse exists, and produces an error message otherwise. Matrices can be divided by scalars, which results in dividing each element of the matrix. Scalars can also be divided by matrices when the matrices are invertible, and the result is the multiplication of the scalar by the inverse of the matrix. Matrix inverses can by found by 1/A or /A , where A is a matrix. Square matrices can be raised to positive integer powers, and also to negative integer powers if they are nonsingular. When a matrix variable is assigned to the results of a calculation, the matrix is redimensioned if necessary. File: redhelp, Node: NULLSPACE, Next: RANK, Prev: MATRIX, Up: Matrix Operations section NULLSPACE operator syntax: NULLSPACE (<matrix_expression>) <nullspace> calculates for its [*note MATRIX::.] argument, A , a list of linear independent vectors (a basis) whose linear combinations satisfy the equation a x = 0. The basis is provided in a form such that as many upper components as possible are isolated. examples: ____________________________________________________________ nullspace mat((1,2,3,4),(5,6,7,8)); { [ 1 ] [ ] [ 0 ] [ ] [ - 3] [ ] [ 2 ] , [ 0 ] [ ] [ 1 ] [ ] [ - 2] [ ] [ 1 ] } ____________________________________________________________ Note that with B := NULLSPACE A , the expression LENGTH B is the nullity/ of A, and that SECOND LENGTH A - LENGTH B calculates the rank/ of A. The rank of a matrix expression can also be found more directly by the [*note RANK::.] operator. In addition to the REDUCE matrix form, NULLSPACE accepts as input a matrix given as a [*note LIST::.] of lists, that is interpreted as a row matrix. If that form of input is chosen, the vectors in the result will be represented by lists as well. This additional input syntax facilitates the use of NULLSPACE in applications different from classical linear algebra. File: redhelp, Node: RANK, Next: TP, Prev: NULLSPACE, Up: Matrix Operations section RANK operator syntax: RANK (<matrix_expression>) RANK calculates the rank of its matrix argument. examples: ____________________________________________________________ rank mat((a,b,c),(d,e,f)); 2 ____________________________________________________________ The argument to RANK can also be a [*note LIST::.] of lists, interpreted either as a row matrix or a set of equations. If that form of input is chosen, the vectors in the result will be represented by lists as well. This additional input syntax facilitates the use of RANK in applications different from classical linear algebra. File: redhelp, Node: TP, Next: TRACE, Prev: RANK, Up: Matrix Operations section TP operator The TP operator returns the transpose of its [*note MATRIX::.] argument. syntax: TP <identifier> or TP (<identifier>) <identifier> must be a matrix, which either has had its dimensions set in its declaration, or has had values put into it by MAT . examples: ____________________________________________________________ matrix m,n; m := mat((1,2,3),(4,5,6))$ n := tp m; N(1,1) := 1 N(1,2) := 4 N(2,1) := 2 N(2,2) := 5 N(3,1) := 3 N(3,2) := 6 ____________________________________________________________ In an assignment statement involving TP , the matrix identifier on the left-hand side is redimensioned to the correct size for the transpose. File: redhelp, Node: TRACE, Prev: TP, Up: Matrix Operations section TRACE operator The TRACE operator finds the trace of its [*note MATRIX::.] argument. syntax: TRACE (<expression>) or TRACE <simple_expression> <expression> or <simple_expression> must evaluate to a square matrix. examples: ____________________________________________________________ matrix a; a := mat((x1,y1),(x2,y2))$ trace a; X1 + Y2 ____________________________________________________________ The trace is the sum of the entries along the diagonal of a square matrix. Given a non-matrix expression, or a non-square matrix, TRACE returns an error message. File: redhelp, Node: Matrix Operations section, Next: Groebner package section, Prev: General Switches section, Up: Top Matrix Operations section * Menu: * COFACTOR:: operator * DET:: operator * MAT:: operator * MATEIGEN:: operator * MATRIX:: declaration * NULLSPACE:: operator * RANK:: operator * TP:: operator * TRACE:: operator File: redhelp, Node: Groebner bases, Next: Ideal Parameters, Up: Groebner package section GROEBNER BASES introduction The GROEBNER package calculates GROEBNER BASES using the BUCHBERGER ALGORITHM and provides related algorithms for arithmetic with ideal bases, such as ideal quotients, Hilbert polynomials ( HOLLMANN ALGORITHM ), basis conversion ( FAUGERE-GIANNI-LAZARD-MORA ALGORITHM ), independent variable set ( KREDEL-WEISPFENNING ALGORITHM ). Some routines of the Groebner package are used by [*note SOLVE::.] - in that context the package is loaded automatically. However, if you want to use the package by explicit calls you must load it by ____________________________________________________________ load_package groebner; ____________________________________________________________ For the common parameter setting of most operators in this package see [*note Ideal Parameters::.] . File: redhelp, Node: Ideal Parameters, Next: Term order section, Prev: Groebner bases, Up: Groebner package section IDEAL PARAMETERS Most operators of the GROEBNER package compute expressions in a polynomial ring which given as <R>[<var>,<var>,...] where <R> is the current REDUCE coefficient domain. All algebraically exact domains of REDUCE are supported. The package can operate over rings and fields. The operation mode is distinguished automatically. In general the ring mode is a bit faster than the field mode. The factoring variant can be applied only over domains which allow you factoring of multivariate polynomials. The variable sequence <var> is either declared explicitly as argument in form of a [*note LIST::.] in [*note TORDER::.] , or it is extracted automatically from the expressions. In the second case the current REDUCE system order is used (see [*note KORDER::.] ) for arranging the variables. If some kernels should play the role of formal parameters (the ground domain <R> then is the polynomial ring over these), the variable sequences must be given explicitly. All REDUCE [*note KERNEL::.] s can be used as variables. But please note, that all variables are considered as independent. E.g. when using SIN(A) and COS(A) as variables, the basic relation SIN(A)^2+COS(A)^2-1=0 must be explicitly added to an equation set because the Groebner operators don't include such knowledge automatically. The terms (monomials) in polynomials are arranged according to the current [*note Term order::.] . Note that the algebraic properties of the computed results only are valid as long as neither the ordering nor the variable sequence changes. The input expressions <exp> can be polynomials <p>, rational functions <n>/<d> or equations <lh>=<rh> built from polynomials or rational functions. Apart from the TRACING algorithms [*note groebnert::.] and [*note preducet::.] , where the equations have a specific meaning, equations are converted to simple expressions by taking the difference of the left-hand and right-hand sides <lh>-<rh>=><p>. Rational functions are converted to polynomials by converting the expression to a common denominator form first, and then using the numerator only <n>=><p>. So eventual zeros of the denominators are ignored. A basis on input or output of an algorithm is coded as [*note LIST::.] of expressions <exp>,<exp>,... . File: redhelp, Node: Term order, Next: TORDER, Up: Term order section TERM ORDER introduction For all GROEBNER operations the polynomials are represented in distributive form: a sum of terms (monomials). The terms are ordered corresponding to the actual TERM ORDER which is set by the [*note TORDER::.] operator, and to the actual variable sequence which is either given as explicit parameter or by the system [*note KERNEL::.] order. File: redhelp, Node: TORDER, Next: torder_compile, Prev: Term order, Up: Term order section TORDER operator The operator TORDER sets the actual variable sequence and term order. 1. simple term order: syntax: TORDER (<vl>, <m>) where <vl> is a [*note LIST::.] of variables ([*note KERNEL::.] s) and <m> is the name of a simple [*note Term order::.] mode [*note lex term order::.] , [*note gradlex term order::.] , [*note revgradlex term order::.] or another implemented parameterless mode. 2. stepped term order: syntax: TORDER (<vl>,<m>,<n>) where <m> is the name of a two step term order, one of [*note gradlexgradlex term order::.] , [*note gradlexrevgradlex term order::.] , [*note lexgradlex term order::.] or [*note lexrevgradlex term order::.] , and <n> is a positive integer. 3. weighted term order syntax: TORDER (<vl>, WEIGHTED , <n>,<n>,...); where the <n> are positive integers, see [*note weighted term order::.] . 4. matrix term order syntax: TORDER (<vl>, MATRIX , <m>); where <m> is a matrix with integer elements, see [*note torder_compile::.] . 5. compiled term order syntax: TORDER (<vl>, CO ); where <co> is the name of a routine generated by [*note torder_compile::.] . TORDER sets the variable sequence and the term order mode. If the an empty list is used as variable sequence, the automatic variable extraction is activated. The defaults are the empty variable list an the [*note lex term order::.] . The previous setting is returned as a list. Alternatively to the above syntax the arguments of TORDER may be collected in a [*note LIST::.] and passed as one argument to TORDER . File: redhelp, Node: torder_compile, Next: lex term order, Prev: TORDER, Up: Term order section TORDER_COMPILE operator A matrix can be converted into a compilable LISP program for faster execution by using syntax: TORDER_COMPILE (<name>,<mat>) where <name> is an identifier for the new term order and <mat> is an integer matrix to be used as [*note matrix term order::.] . Afterwards the term order can be activated by using <name> in a [*note TORDER::.] expression. The resulting program is compiled if the switch [*note COMP::.] is on, or if the TORDER_COMPILE expression is part of a compiled module. File: redhelp, Node: lex term order, Next: gradlex term order, Prev: torder_compile, Up: Term order section LEX TERM ORDER The terms are ordered lexicographically: two terms t1 t2 are compared for their degrees along the fixed variable sequence: t1 is higher than t2 if the first different degree is higher in t1. This order has the ELIMINATION PROPERTY for GROEBNER BASIS calculations. If the ideal has a univariate polynomial in the last variable the groebner basis will contain such polynomial. LEX is best suited for solving of polynomial equation systems. File: redhelp, Node: gradlex term order, Next: revgradlex term order, Prev: lex term order, Up: Term order section GRADLEX TERM ORDER The terms are ordered first with their total degree, and if the total degree is identical the comparison is [*note lex term order::.] . With GROEBNER basis calculations this term order produces polynomials of lowest degree. File: redhelp, Node: revgradlex term order, Next: gradlexgradlex term order, Prev: gradlex term order, Up: Term order section REVGRADLEX TERM ORDER The terms are ordered first with their total degree (degree sum), and if the total degree is identical the comparison is the inverse of [*note lex term order::.] . With [*note GROEBNER::.] and [*note groebnerf::.] calculations this term order is similar to [*note gradlex term order::.] ; it is known as most efficient ordering with respect to computing time. File: redhelp, Node: gradlexgradlex term order, Next: gradlexrevgradlex term order, Prev: revgradlex term order, Up: Term order section GRADLEXGRADLEX TERM ORDER The terms are separated into two groups where the second parameter of the [*note TORDER::.] call determines the length of the first group. For a comparison first the total degrees of both variable groups are compared. If both are equal [*note gradlex term order::.] comparison is applied to the first group, and if that does not decide [*note gradlex term order::.] is applied for the second group. This order has the elimination property for the variable groups. It can be used e.g. for separating variables from parameters. File: redhelp, Node: gradlexrevgradlex term order, Next: lexgradlex term order, Prev: gradlexgradlex term order, Up: Term order section GRADLEXREVGRADLEX TERM ORDER Similar to [*note gradlexgradlex term order::.] , but using [*note revgradlex term order::.] for the second group. File: redhelp, Node: lexgradlex term order, Next: lexrevgradlex term order, Prev: gradlexrevgradlex term order, Up: Term order section LEXGRADLEX TERM ORDER Similar to [*note gradlexgradlex term order::.] , but using [*note lex term order::.] for the first group. File: redhelp, Node: lexrevgradlex term order, Next: weighted term order, Prev: lexgradlex term order, Up: Term order section LEXREVGRADLEX TERM ORDER Similar to [*note gradlexgradlex term order::.] , but using [*note lex term order::.] for the first group [*note revgradlex term order::.] for the second group. File: redhelp, Node: weighted term order, Next: graded term order, Prev: lexrevgradlex term order, Up: Term order section WEIGHTED TERM ORDER establishes a graduated ordering similar to [*note gradlex term order::.] , where the exponents first are multiplied by the given weights. If there are less weight values than variables, the weight list is extended by ones. If the weighted degree comparison is not decidable, the [*note lex term order::.] is used. File: redhelp, Node: graded term order, Next: matrix term order, Prev: weighted term order, Up: Term order section GRADED TERM ORDER establishes a cascaded term ordering: first a graduated ordering similar to [*note gradlex term order::.] is used, where the exponents first are multiplied by the given weights. If there are less weight values than variables, the weight list is extended by ones. If the weighted degree comparison is not decidable, the term ordering described in the following parameters of the [*note TORDER::.] command is used. File: redhelp, Node: matrix term order, Prev: graded term order, Up: Term order section MATRIX TERM ORDER Any arbitrary term order mode can be installed by a matrix with integer elements where the row length corresponds to the variable number. The matrix must have at least as many rows as columns. It must have full rank, and the top nonzero element of each column must be positive. The matrix TERM ORDER MODE defines a term order where the exponent vectors of the monomials are first multiplied by the matrix and the resulting vectors are compared lexicographically. If the switch [*note COMP::.] is on, the matrix is converted into a compiled LISP program for faster execution. A matrix can also be compiled explicitly, see [*note torder_compile::.] . File: redhelp, Node: Term order section, Next: Basic Groebner operators section, Prev: Ideal Parameters, Up: Groebner package section Term order section * Menu: * Term order:: introduction * TORDER:: operator * torder_compile:: operator * lex term order:: concept * gradlex term order:: concept * revgradlex term order:: concept * gradlexgradlex term order::concept * gradlexrevgradlex term order::concept * lexgradlex term order:: concept * lexrevgradlex term order::concept * weighted term order:: concept * graded term order:: concept * matrix term order:: concept File: redhelp, Node: GVARS, Next: GROEBNER, Up: Basic Groebner operators section GVARS operator syntax: GVARS (<exp>,<exp>,... ) where <exp> are expressions or [*note EQUATION::.] s. GVARS extracts from the expressions the [*note KERNEL::.] S which can play the role of variables for a [*note GROEBNER::.] or [*note groebnerf::.] calculation. File: redhelp, Node: GROEBNER, Next: groebopt, Prev: GVARS, Up: Basic Groebner operators section GROEBNER operator syntax: GROEBNER (EXP , ...) where EXP , ... is a list of expressions or equations. The operator GROEBNER implements the Buchberger algorithm for computing Groebner bases for a given set of expressions with respect to the given set of variables in the order given. As a side effect, the sequence of variables is stored as a REDUCE list in the shared variable [*note gvarslast::.] - this is important in cases where the algorithm rearranges the variable sequence because [*note groebopt::.] is ON . examples: ____________________________________________________________ groebner({x**2+y**2-1,x-y}) {X - Y,2*Y**2 -1} ____________________________________________________________ related: [*note groebnerf::.] operator [*note gvarslast::.] variable [*note groebopt::.] switch [*note groebprereduce::.] switch [*note groebfullreduction::.] switch [*note gltbasis::.] switch [*note gltb::.] variable [*note glterms::.] variable [*note groebstat::.] switch [*note trgroeb::.] switch [*note trgroebs::.] switch [*note groebprot::.] switch [*note groebprotfile::.] variable [*note groebnert::.] operator File: redhelp, Node: groebopt, Next: gvarslast, Prev: GROEBNER, Up: Basic Groebner operators section GROEBOPT switch If GROEBOPT is set ON, the sequence of variables is optimized with respect to execution speed of GROEBNER calculations; note that the final list of variables is available in [*note gvarslast::.] . By default GROEBOPT is off, conserving the original variable sequence. An explicitly declared dependency using the [*note DEPEND::.] declaration supersedes the variable optimization. examples: ____________________________________________________________ ____________________________________________________________ guarantees that a will be placed in front of x and y. File: redhelp, Node: gvarslast, Next: groebprereduce, Prev: groebopt, Up: Basic Groebner operators section GVARSLAST variable After a [*note GROEBNER::.] or [*note groebnerf::.] calculation the actual variable sequence is stored in the variable GVARSLAST . If [*note groebopt::.] is ON GVARSLAST shows the variable sequence after reordering. File: redhelp, Node: groebprereduce, Next: groebfullreduction, Prev: gvarslast, Up: Basic Groebner operators section GROEBPREREDUCE switch If GROEBPREREDUCE set ON, [*note GROEBNER::.] and [*note groebnerf::.] try to simplify the input expressions: if the head term of an input expression is a multiple of the head term of another expression, it can be reduced; these reductions are done cyclicly as long as possible in order to shorten the main part of the algorithm. By default GROEBPREREDUCE is off. File: redhelp, Node: groebfullreduction, Next: gltbasis, Prev: groebprereduce, Up: Basic Groebner operators section GROEBFULLREDUCTION switch If GROEBFULLREDUCTION set off, the polynomial reduction steps during [*note GROEBNER::.] and [*note groebnerf::.] are limited to the pure head term reduction; subsequent terms are reduced otherwise. By default GROEBFULLREDUCTION is on. File: redhelp, Node: gltbasis, Next: gltb, Prev: groebfullreduction, Up: Basic Groebner operators section GLTBASIS switch If GLTBASIS set on, the leading terms of the result basis of a [*note GROEBNER::.] or [*note groebnerf::.] calculation are extracted. They are collected as a basis of monomials, which is available as value of the global variable [*note gltb::.] . File: redhelp, Node: gltb, Next: glterms, Prev: gltbasis, Up: Basic Groebner operators section GLTB variable See [*note gltbasis::.] File: redhelp, Node: glterms, Next: groebstat, Prev: gltb, Up: Basic Groebner operators section GLTERMS variable If the expressions in a [*note GROEBNER::.] or [*note groebnerf::.] call contain parameters (symbols which are not member of the variable list), the share variable GLTERMS is set to a list of expression which during the calculation were assumed to be nonzero. The calculated bases are valid only under the assumption that all these expressions do not vanish. File: redhelp, Node: groebstat, Next: trgroeb, Prev: glterms, Up: Basic Groebner operators section GROEBSTAT switch if GROEBSTAT is on, a summary of the [*note GROEBNER::.] or [*note groebnerf::.] computation is printed at the end including the computing time, the number of intermediate H polynomials and the counters for the criteria hits. File: redhelp, Node: trgroeb, Next: trgroebs, Prev: groebstat, Up: Basic Groebner operators section TRGROEB switch if TRGROEB is on, intermediate H polynomials are printed during a [*note GROEBNER::.] or [*note groebnerf::.] calculation. File: redhelp, Node: trgroebs, Next: gzerodim?, Prev: trgroeb, Up: Basic Groebner operators section TRGROEBS switch if TRGROEBS is on, intermediate H and S polynomials are printed during a [*note GROEBNER::.] or [*note groebnerf::.] calculation. File: redhelp, Node: gzerodim?, Next: gdimension, Prev: trgroebs, Up: Basic Groebner operators section GZERODIM? operator syntax: GZERODIM!? (<basis>) where <bas> is a Groebner basis in the current [*note Term order::.] with the actual setting (see [*note Ideal Parameters::.] ). GZERODIM!? tests whether the ideal spanned by the given basis has dimension zero. If yes, the number of zeros is returned, [*note NIL::.] otherwise. File: redhelp, Node: gdimension, Next: gindependent_sets, Prev: gzerodim?, Up: Basic Groebner operators section GDIMENSION operator syntax: GDIMENSION (<bas>) where <bas> is a [*note GROEBNER::.] basis in the current term order (see [*note Ideal Parameters::.] ). GDIMENSION computes the dimension of the ideal spanned by the given basis and returns the dimension as an integer number. The Kredel-Weispfenning algorithm is used: the dimension is the length of the longest independent variable set, see [*note gindependent_sets::.] File: redhelp, Node: gindependent_sets, Next: dd_groebner, Prev: gdimension, Up: Basic Groebner operators section GINDEPENDENT_SETS operator syntax: GINDEPENDENT_SETS (<bas>) where <bas> is a [*note GROEBNER::.] basis in any TERM ORDER (which must be the current TERM ORDER ) with the specified variables (see [*note Ideal Parameters::.] ). GINDEPENDENT_SETS computes the maximal left independent variable sets of the ideal, that are the variable sets which play the role of free parameters in the current ideal basis. Each set is a list which is a subset of the variable list. The result is a list of these sets. For an ideal with dimension zero the list is empty. The Kredel-Weispfenning algorithm is used. File: redhelp, Node: dd_groebner, Next: glexconvert, Prev: gindependent_sets, Up: Basic Groebner operators section DD_GROEBNER operator For a homogeneous system of polynomials under [*note graded term order::.] , [*note gradlex term order::.] , [*note revgradlex term order::.] or [*note weighted term order::.] a Groebner Base can be computed with limiting the grade of the intermediate S polynomials: syntax: DD_GROEBNER (<d1>,<d2>,<plist>) where <d1> is a non negative integer and <d2> is an integer or "infinity". A pair of polynomials is considered only if the grade of the lcm of their head terms is between <d1> and <d2>. For the term orders GRADED or WEIGHTED the (first) weight vector is used for the grade computation. Otherwise the total degree of a term is used. File: redhelp, Node: glexconvert, Next: greduce, Prev: dd_groebner, Up: Basic Groebner operators section GLEXCONVERT operator syntax: GLEXCONVERT (<bas>[,<vars>][,MAXDEG=<mx>] [,NEWVARS=<nv>]) where <bas> is a [*note GROEBNER::.] basis in the current term order, <mx> (optional) is a positive integer and <nvl> (optional) is a list of variables (see [*note Ideal Parameters::.] ). The operator GLEXCONVERT converts the basis of a zero-dimensional ideal (finite number of isolated solutions) from arbitrary ordering into a basis under [*note lex term order::.] . The parameter <newvars> defines the new variable sequence. If omitted, the original variable sequence is used. If only a subset of variables is specified here, the partial ideal basis is evaluated. If <newvars> is a list with one element, the minimal UNIVARIATE POLYNOMIAL is computed. <maxdeg> is an upper limit for the degrees. The algorithm stops with an error message, if this limit is reached. A warning occurs, if the ideal is not zero dimensional. During the call the TERM ORDER of the input basis must be active. File: redhelp, Node: greduce, Next: preduce, Prev: glexconvert, Up: Basic Groebner operators section GREDUCE operator syntax: GREDUCE (exp, exp1, exp2, ... , expm) where exp is an expression, and exp1, exp2, ... , expm is a list of expressions or equations. GREDUCE is functionally equivalent with a call to [*note GROEBNER::.] and then a call to [*note preduce::.] . File: redhelp, Node: preduce, Next: idealquotient, Prev: greduce, Up: Basic Groebner operators section PREDUCE operator syntax: PREDUCE (<p>, <exp>, ... ) where <p> is an expression, and <exp>, ... is a list of expressions or equations. PREDUCE computes the remainder of EXP modulo the given set of polynomials resp. equations. This result is unique (canonical) only if the given set is a GROEBNER basis under the current [*note Term order::.] see also: [*note preducet::.] operator. File: redhelp, Node: idealquotient, Next: hilbertpolynomial, Prev: preduce, Up: Basic Groebner operators section IDEALQUOTIENT operator syntax: IDEALQUOTIENT (<exp>, ..., <d>) where <exp>,... is a list of expressions or equations, <d> is a single expression or equation. IDEALQUOTIENT computes the ideal quotient: ideal spanned by the expressions <exp>,... divided by the single polynomial/expression <f>. The result is the [*note GROEBNER::.] basis of the quotient ideal. File: redhelp, Node: hilbertpolynomial, Prev: idealquotient, Up: Basic Groebner operators section HILBERTPOLYNOMIAL operator syntax: hilbertpolynomial(<bas>) where <bas> is a [*note GROEBNER::.] basis in the current [*note Term order::.] . The degree of the HILBERT POLYNOMIAL is the dimension of the ideal spanned by the basis. For an ideal of dimension zero the Hilbert polynomial is a constant which is the number of common zeros of the ideal (including eventual multiplicities). The HOLLMANN ALGORITHM is used. File: redhelp, Node: Basic Groebner operators section, Next: Factorizing Groebner bases section, Prev: Term order section, Up: Groebner package section Basic Groebner operators section * Menu: * GVARS:: operator * GROEBNER:: operator * groebopt:: switch * gvarslast:: variable * groebprereduce:: switch * groebfullreduction:: switch * gltbasis:: switch * gltb:: variable * glterms:: variable * groebstat:: switch * trgroeb:: switch * trgroebs:: switch * gzerodim?:: operator * gdimension:: operator * gindependent_sets:: operator * dd_groebner:: operator * glexconvert:: operator * greduce:: operator * preduce:: operator * idealquotient:: operator * hilbertpolynomial:: operator File: redhelp, Node: groebnerf, Next: groebmonfac, Up: Factorizing Groebner bases section GROEBNERF operator syntax: GROEBNERF (<exp>, ...[,,<nz>, ... ]); where <exp>, ... is a list of expressions or equations, and <nz>,... is an optional list of polynomials to be considered as non zero for this calculation. An empty list must be passed as second argument if the non-zero list is specified. GROEBNERF tries to separate polynomials into individual factors and to branch the computation in a recursive manner (factorization tree). The result is a list of partial Groebner bases. Multiplicities (one factor with a higher power, the same partial basis twice) are deleted as early as possible in order to speed up the calculation. The third parameter of GROEBNERF declares some polynomials nonzero. If any of these is found in a branch of the calculation the branch is canceled. example: ____________________________________________________________ groebnerf({ 3*x**2*y+2*x*y+y+9*x**2+5*x = 3, 2*x**3*y-x*y-y+6*x**3-2*x**2-3*x = -3, x**3*y+x**2*y+3*x**3+2*x**2 }, {y,x}); {{Y - 3,X}, 2 {2*Y + 2*X - 1,2*X - 5*X - 5}} ____________________________________________________________ related: [*note groebresmax::.] variable [*note groebmonfac::.] variable [*note groebrestriction::.] variable [*note GROEBNER::.] operator [*note gvarslast::.] variable [*note groebopt::.] switch [*note groebprereduce::.] switch [*note groebfullreduction::.] switch [*note gltbasis::.] switch [*note gltb::.] variable [*note glterms::.] variable [*note groebstat::.] switch [*note trgroeb::.] switch [*note trgroebs::.] switch [*note groebnert::.] operator File: redhelp, Node: groebmonfac, Next: groebresmax, Prev: groebnerf, Up: Factorizing Groebner bases section GROEBMONFAC variable The variable GROEBMONFAC is connected to the handling of monomial factors. A monomial factor is a product of variable powers as a factor, e.g. x**2*y in x**3*y - 2*x**2*y**2. A monomial factor represents a solution of the type x = 0 or y = 0 with a certain multiplicity. With [*note groebnerf::.] the multiplicity of monomial factors is lowered to the value of the shared variable GROEBMONFAC which by default is 1 (= monomial factors remain present, but their multiplicity is brought down). With GROEBMONFAC := 0 the monomial factors are suppressed completely. File: redhelp, Node: groebresmax, Next: groebrestriction, Prev: groebmonfac, Up: Factorizing Groebner bases section GROEBRESMAX variable The variable GROEBRESMAX controls during [*note groebnerf::.] calculations the number of partial results. Its default value is 300. If more partial results are calculated, the calculation is terminated. File: redhelp, Node: groebrestriction, Prev: groebresmax, Up: Factorizing Groebner bases section GROEBRESTRICTION variable During [*note groebnerf::.] calculations irrelevant branches can be excluded by setting the variable GROEBRESTRICTION . The following restrictions are implemented: syntax: GROEBRESTRICTION := NONNEGATIVE GROEBRESTRICTION := POSITIVE GROEBRESTRICTION := ZEROPOINT With NONNEGATIVE branches are excluded where one polynomial has no nonnegative real zeros; with POSITIVE the restriction is sharpened to positive zeros only. The restriction ZEROPOINT excludes all branches which do not have the origin (0,0,...0) in their solution set. File: redhelp, Node: Factorizing Groebner bases section, Next: Tracing Groebner bases section, Prev: Basic Groebner operators section, Up: Groebner package section Factorizing Groebner bases section * Menu: * groebnerf:: operator * groebmonfac:: variable * groebresmax:: variable * groebrestriction:: variable File: redhelp, Node: groebprot, Next: groebprotfile, Up: Tracing Groebner bases section GROEBPROT switch If GROEBPROT is ON the computation steps during [*note preduce::.] , [*note greduce::.] and [*note GROEBNER::.] are collected in a list which is assigned to the variable [*note groebprotfile::.] . File: redhelp, Node: groebprotfile, Next: groebnert, Prev: groebprot, Up: Tracing Groebner bases section GROEBPROTFILE variable See [*note groebprot::.] switch. File: redhelp, Node: groebnert, Next: preducet, Prev: groebprotfile, Up: Tracing Groebner bases section GROEBNERT operator syntax: GROEBNERT (<v>=<exp>,...) where <v> are [*note KERNEL::.] S (simple or indexed variables), <exp> are polynomials. GROEBNERT is functionally equivalent to a [*note GROEBNER::.] call for <exp>,..., but the result is a set of equations where the left-hand sides are the basis elements while the right-hand sides are the same values expressed as combinations of the input formulas, expressed in terms of the names <v> example: ____________________________________________________________ groebnert({p1=2*x**2+4*y**2-100,p2=2*x-y+1}); GB1 := {2*X - Y + 1=P2, 2 9*Y - 2*Y - 199= - 2*X*P2 - Y*P2 + 2*P1 + P2} ____________________________________________________________ File: redhelp, Node: preducet, Prev: groebnert, Up: Tracing Groebner bases section PREDUCET operator syntax: PREDUCE (<p>,<v>=<exp>...) where <p> is an expression, <v> are kernels (simple or indexed variables), EXP are polynomials. PREDUCET computes the remainder of <p> modulo <exp>,... similar to [*note preduce::.] , but the result is an equation which expresses the remainder as combination of the polynomials. example: ____________________________________________________________ GB2 := {G1=2*X - Y + 1,G2=9*Y**2 - 2*Y - 199} preducet(q=x**2,gb2); - 16*Y + 208= - 18*X*G1 - 9*Y*G1 + 36*Q + 9*G1 - G2 ____________________________________________________________ File: redhelp, Node: Tracing Groebner bases section, Next: Groebner Bases for Modules section, Prev: Factorizing Groebner bases section, Up: Groebner package section Tracing Groebner bases section * Menu: * groebprot:: switch * groebprotfile:: variable * groebnert:: operator * preducet:: operator File: redhelp, Node: Module, Next: gmodule, Up: Groebner Bases for Modules section MODULE Given a polynomial ring, e.g. R=Z[x,y,...] and an integer n>1. The vectors with n elements of R form a free MODULE under elementwise addition and multiplication with elements of R. For a submodule given by a finite basis a Groebner basis can be computed, and the facilities of the GROEBNER package are available except the operators [*note groebnerf::.] and GROESOLVE . The vectors are encoded using auxiliary variables which represent the unit vectors in the module. These are declared in the share variable [*note gmodule::.] . File: redhelp, Node: gmodule, Prev: Module, Up: Groebner Bases for Modules section GMODULE variable The vectors of a free [*note Module::.] over a polynomial ring R are encoded as linear combinations with unit vectors of M which are represented by auxiliary variables. These must be collected in the variable GMODULE before any call to an operator of the Groebner package. ____________________________________________________________ torder({x,y,v1,v2,v3})$ gmodule := {v1,v2,v3}$ g:=groebner({x^2*v1 + y*v2,x*y*v1 - v3,2y*v1 + y*v3}); ____________________________________________________________ compute the Groebner basis of the submodule ____________________________________________________________ ([x^2,y,0],[xy,0,-1],[0,2y,y]) ____________________________________________________________ The members of the list GMODULE are automatically appended to the end of the variable list, if they are not yet members there. They take part in the actual term ordering. File: redhelp, Node: Groebner Bases for Modules section, Next: Computing with distributive polynomials section, Prev: Tracing Groebner bases section, Up: Groebner package section Groebner Bases for Modules section * Menu: * Module:: concept * gmodule:: variable File: redhelp, Node: gsort, Next: gsplit, Up: Computing with distributive polynomials section GSORT operator syntax: GSORT (<p>) where <p> is a polynomial or a list of polynomials. The polynomials are reordered and sorted corresponding to the current [*note Term order::.] . examples: ____________________________________________________________ torder lex; gsort(x**2+2x*y+y**2,{y,x}); y**2+2y*x+x**2 ____________________________________________________________ File: redhelp, Node: gsplit, Next: gspoly, Prev: gsort, Up: Computing with distributive polynomials section GSPLIT operator syntax: GSPLIT (<p>[,<vars>]); where <p> is a polynomial or a list of polynomials. The polynomial is reordered corresponding to the the current [*note Term order::.] and then separated into leading term and reductum. Result is a list with the leading term as first and the reductum as second element. examples: ____________________________________________________________ torder lex; gsplit(x**2+2x*y+y**2,{y,x}); {y**2,2y*x+x**2} ____________________________________________________________ File: redhelp, Node: gspoly, Prev: gsplit, Up: Computing with distributive polynomials section GSPOLY operator syntax: GSPOLY (<p1>,<p2>); where <p1> and <p2> are polynomials. The SUBTRACTION polynomial of p1 and p2 is computed corresponding to the method of the Buchberger algorithm for computing GROEBNER BASES : p1 and p2 are multiplied with terms such that when subtracting them the leading terms cancel each other. File: redhelp, Node: Computing with distributive polynomials section, Prev: Groebner Bases for Modules section, Up: Groebner package section Computing with distributive polynomials section * Menu: * gsort:: operator * gsplit:: operator * gspoly:: operator File: redhelp, Node: Groebner package section, Next: High Energy Physics section, Prev: Matrix Operations section, Up: Top Groebner package section * Menu: * Groebner bases:: introduction * Ideal Parameters:: concept * Term order section:: * Basic Groebner operators section:: * Factorizing Groebner bases section:: * Tracing Groebner bases section:: * Groebner Bases for Modules section:: * Computing with distributive polynomials section:: File: redhelp, Node: HEPHYS, Next: HE-dot, Up: High Energy Physics section HEPHYS introduction The High-energy Physics package is historic for REDUCE, since REDUCE originated as a program to aid in computations with Dirac expressions. The commutation algebra of the gamma matrices is independent of their representation, and is a natural subject for symbolic mathematics. Dirac theory is applied to beta decay and the computation of cross-sections and scattering. The high-energy physics operators are available in the REDUCE main program, rather than as a module which must be loaded. File: redhelp, Node: HE-dot, Next: EPS, Prev: HEPHYS, Up: High Energy Physics section . HE-DOT operator The . operator is used to denote the scalar product of two Lorentz four-vectors. syntax: <vector> . <vector> <vector> must be an identifier declared to be of type VECTOR to have the scalar product definition. When applied to arguments that are not vectors, the [*note CONS::.] operator is used, whose symbol is also "dot." examples: ____________________________________________________________ vector aa,bb,cc; let aa.bb = 0; aa.bb; 0 aa.cc; AA.CC q := aa.cc; Q := AA.CC q; AA.CC ____________________________________________________________ Since vectors are special high-energy physics entities that do not contain values, the . product will not return a true scalar product. You can assign a scalar identifier to the result of a . operation, or assign a . operation to have the value of the scalar you supply, as shown above. Note that the result of a . operation is a scalar, not a vector. The metric tensor g(u,v) can be represented by U.V . If contraction over the indices is required, U and V should be declared to be of type [*note INDEX::.] . The dot operator has the highest precedence of the infix operators, so expressions involving . and other operators have the scalar product evaluated first before other operations are done. File: redhelp, Node: EPS, Next: G, Prev: HE-dot, Up: High Energy Physics section EPS operator The EPS operator denotes the completely antisymmetric tensor of order 4 and its contraction with Lorentz four-vectors, as used in high-energy physics calculations. syntax: EPS (<vector-expr>,<vector-expr>,<vector-expr>, <vector-expr>) <vector-expr> must be a valid vector expression, and may be an index. examples: ____________________________________________________________ vector g0,g1,g2,g3; eps(g1,g0,g2,g3); - EPS(G0,G1,G2,G3); eps(g1,g2,g0,g3); EPS(G0,G1,G2,G3); eps(g1,g2,g3,g1); 0 ____________________________________________________________ Vector identifiers are ordered alphabetically by REDUCE. When an odd number of transpositions is required to restore the canonical order to the four arguments of EPS , the term is ordered and carries a minus sign. When an even number of transpositions is required, the term is returned ordered and positive. When one of the arguments is repeated, the value 0 is returned. A contraction of the form eps(_i j mu nu p_mu q_nu) is represented by EPS(I,J,P,Q) when I and J have been declared to be of type [*note INDEX::.] . File: redhelp, Node: G, Next: INDEX, Prev: EPS, Up: High Energy Physics section G operator G is an n-ary operator used to denote a product of gamma matrices contracted with Lorentz four-vectors, in high-energy physics. syntax: G (<identifier>,<vector-expr> ,<vector-expr>*) <identifier> is a scalar identifier representing a fermion line identifier, <vector-expr> can be any valid vector expression, representing a vector or a gamma matrix. examples: ____________________________________________________________ vector aa,bb,cc; vector a; g(line1,aa,bb); AA.BB g(line2,aa,a); 0 g(id,aa,bb,cc); 0 g(li1,aa,bb) + k; AA.BB + K let aa.bb = m*k; g(ln1,aa)*g(ln1,bb); K*M g(ln1,aa)*g(ln2,bb); 0 ____________________________________________________________ The vector A is reserved in arguments of G to denote the special gamma matrix gamma_5. It must be declared to be a vector before you use it. Gamma matrix expressions are associated with fermion lines in a Feynman diagram. If more than one line occurs in an expression, the gamma matrices involved are separate (operating in independent spin space), as shown in the last two example lines above. A product of gamma matrices associated with a single line can be entered either as a single G command with several vector arguments, or as products of separate G commands each with a single argument. While the product of vectors is not defined, the product, sum and difference of several gamma expressions are defined, as is the product of a gamma expression with a scalar. If an expression involving gamma matrices includes a scalar, the scalar is treated as if it were the product of itself with a unit 4 x 4 matrix. Dirac expressions are evaluated by computing the trace of the expression using the commutation algebra of gamma matrices. The algorithms used are described in articles by J. S. R. Chisholm in <Il Nuovo Cimento X,> Vol. 30, p. 426, 1963, and J. Kahane, <Journal of Mathematical Physics>, Vol. 9, p. 1732, 1968. The trace is then divided by 4 to distinguish between the trace of a scalar and the trace of an expression that is the product of a scalar with a unit 4 x 4 matrix. Trace calculations may be prevented over any line identifier by declaring it to be [*note NOSPUR::.] . If it is later desired to evaluate these traces, the declaration can be undone with the [*note SPUR::.] declaration. The notation of Bjorken and Drell, <Relativistic Quantum Mechanics,> 1964, is assumed in all operations involving gamma matrices. For an example of the use of G in a calculation, see the <REDUCE User's Manual>. File: redhelp, Node: INDEX, Next: MASS, Prev: G, Up: High Energy Physics section INDEX declaration The declaration INDEX flags a four-vector as an index for subsequent high-energy physics calculations. syntax: INDEX <vector-id>,<vector-id>* <vector-id> must have been declared of type VECTOR . examples: ____________________________________________________________ vector aa,bb,cc; index uu; let aa.bb = 0; (aa.uu)*(bb.uu); 0 (aa.uu)*(cc.uu); AA.CC ____________________________________________________________ Index variables are used to represent contraction over components of vectors when scalar products are taken by the . operator, as well as indicating contraction for the [*note EPS::.] operator or metric tensor. The special status of a vector as an index can be revoked with the declaration [*note REMIND::.] . The object remains a vector, however. File: redhelp, Node: MASS, Next: MSHELL, Prev: INDEX, Up: High Energy Physics section MASS command The MASS command associates a scalar variable as a mass with the corresponding vector variable, in high-energy physics calculations. syntax: MASS <vector-var>= <scalar-var> ,<vector-var>= <scalar-var>* <vector-var> can be a declared vector variable; MASS will declare it to be of type VECTOR if it is not. This may override an existing matrix variable by that name. <scalar-var> must be a scalar variable. examples: ____________________________________________________________ vector bb,cc; mass cc=m; mshell cc; cc.cc; 2 M ____________________________________________________________ Once a mass has been attached to a vector with a MASS declaration, the [*note MSHELL::.] declaration puts the associated particle "on the mass shell." Subsequent scalar (.) products of the vector with itself will be replaced by the square of the mass expression. File: redhelp, Node: MSHELL, Next: NOSPUR, Prev: MASS, Up: High Energy Physics section MSHELL command The MSHELL command puts particles on the mass shell in high-energy physics calculations. syntax: MSHELL <vector-var>,<vector-var>* <vector-var> must have had a mass attached to it by a [*note MASS::.] declaration. examples: ____________________________________________________________ vector v1,v2; mass v1=m,v2=q; mshell v1; v1.v1; 2 M v2.v2; V2.V2 mshell v2; v1.v1*v2.v2; 2 2 M *Q ____________________________________________________________ Even though a mass is attached to a vector variable representing a particle, the replacement does not take place until the MSHELL declaration is given for that vector variable. File: redhelp, Node: NOSPUR, Next: REMIND, Prev: MSHELL, Up: High Energy Physics section NOSPUR declaration The NOSPUR declaration prevents the trace calculation over the given line identifiers in high-energy physics calculations. syntax: NOSPUR <line-id>,<line-id>* <line-id> is a scalar identifier that will be used as a line identifier. examples: ____________________________________________________________ vector a1,b1,c1; g(line1,a1,b1)*g(line2,b1,c1); A1.B1*B1.C1 nospur line2; g(line1,a1,b1)*g(line2,b1,c1); A1.B1*G(LINE2,B1,C1) ____________________________________________________________ Nospur declarations can be removed by making the declaration [*note SPUR::.] . File: redhelp, Node: REMIND, Next: SPUR, Prev: NOSPUR, Up: High Energy Physics section REMIND declaration The REMIND declaration removes the special status of its arguments as indices, which was set in the [*note INDEX::.] declaration, in high-energy physics calculations. syntax: REMIND <identifier>,<identifier>* <identifier> must have been declared to be of type [*note INDEX::.] . File: redhelp, Node: SPUR, Next: VECDIM, Prev: REMIND, Up: High Energy Physics section SPUR declaration The SPUR declaration removes the special exemption from trace calculations that was declared by [*note NOSPUR::.] , in high-energy physics calculations. syntax: SPUR <line-id>,<line-id>* <line-id> must be a line-identifier that has previously been declared NOSPUR . File: redhelp, Node: VECDIM, Next: VECTOR, Prev: SPUR, Up: High Energy Physics section VECDIM command The command VECDIM changes the vector dimension from 4 to an arbitrary integer or symbol. Used in high-energy physics calculations. syntax: VECDIM <dimension> <dimension> must be either an integer or a valid scalar identifier that does not have a floating-point value. The [*note EPS::.] operator and the gamma_5 symbol (A ) are not properly defined in anything except four dimensions and will print an error message if you use them that way. The other high-energy physics operators should work without problem. File: redhelp, Node: VECTOR, Prev: VECDIM, Up: High Energy Physics section VECTOR declaration The VECTOR declaration declares that its arguments are of type VECTOR . syntax: VECTOR <identifier>,<identifier>* <identifier> must be a valid REDUCE identifier. It may have already been used for a matrix, array, operator or scalar variable. After an identifier has been declared to be a vector, it may not be used as a scalar variable. Vectors are special entities for high-energy physics calculations. You cannot put values into their coordinates; they do not have coordinates. They are legal arguments for the high-energy physics operators [*note EPS::.] , [*note G::.] and . (dot). Vector variables are used to represent gamma matrices and gamma matrices contracted with Lorentz 4-vectors, since there are no Dirac variables per se in the system. Vectors do follow the usual vector rules for arithmetic operations: + and - operate upon two or more vectors, producing a vector; * and / cannot be used between vectors; the scalar product is represented by the . operator; and the product of a scalar and vector expression is well defined, and is a vector. You can represent components of vectors by including representations of unit vectors in your system. For instance, letting E0 represent the unit vector (1,0,0,0), the command V1.E0 := 0; would set up the substitution of zero for the first component of the vector V1 . Identifiers that are declared by the INDEX and MASS declarations are automatically declared to be vectors. The following errors can occur in calculations using the high energy physics package: A REPRESENTS ONLY GAMMA5 IN VECTOR EXPRESSIONS You have tried to use A in some way other than gamma5 in a high-energy physics expression. GAMMA5 NOT ALLOWED UNLESS VECDIM IS 4 You have used gamma_5 in a high-energy physics computation involving a vector dimension other than 4. <ID> HAS NO MASS One of the arguments to [*note MSHELL::.] has had no mass assigned to it, in high-energy physics calculations. MISSING ARGUMENTS FOR G OPERATOR A line symbol is missing in a gamma matrix expression in high-energy physics calculations. UNMATCHED INDEX <list> The parser has found unmatched indices during the evaluation of a gamma matrix expression in high-energy physics calculations. File: redhelp, Node: High Energy Physics section, Next: Numeric Package section, Prev: Groebner package section, Up: Top High Energy Physics section * Menu: * HEPHYS:: introduction * HE-dot:: . operator * EPS:: operator * G:: operator * INDEX:: declaration * MASS:: command * MSHELL:: command * NOSPUR:: declaration * REMIND:: declaration * SPUR:: declaration * VECDIM:: command * VECTOR:: declaration File: redhelp, Node: Numeric Package, Next: Interval, Up: Numeric Package section NUMERIC PACKAGE introduction The numeric package supplies algorithms based on approximation techniques of numerical mathematics. The algorithms use the [*note ROUNDED::.] mode arithmetic of REDUCE, including the variable precision feature which is exploited in some algorithms in an adaptive manner in order to reach the desired accuracy. File: redhelp, Node: Interval, Next: numeric accuracy, Prev: Numeric Package, Up: Numeric Package section INTERVAL type Intervals are generally coded as lower bound and upper bound connected by the operator .. , usually associated to a variable in an equation. syntax: <var> = (<low> .. <high>) where <var> is a [*note KERNEL::.] and <low>, <high> are numbers or expression which evaluate to numbers with <low><=<high>. examples: ____________________________________________________________ ____________________________________________________________ means that the variable x is taken in the range from 2.5 up to 3.5. File: redhelp, Node: numeric accuracy, Next: TRNUMERIC, Prev: Interval, Up: Numeric Package section NUMERIC ACCURACY The keyword parameters ACCURACY=A and ITERATIONS=I , where A and I must be positive integer numbers, control the iterative algorithms: the iteration is continued until the local error is below 10**-a; if that is impossible within I steps, the iteration is terminated with an error message. The values reached so far are then returned as the result. File: redhelp, Node: TRNUMERIC, Next: num_min, Prev: numeric accuracy, Up: Numeric Package section TRNUMERIC switch Normally the algorithms produce only a minimum of printed output during their operation. In cases of an unsuccessful or unexpected long operation a TRACE OF THE ITERATION can be printed by setting TRNUMERIC ON . File: redhelp, Node: num_min, Next: num_solve, Prev: TRNUMERIC, Up: Numeric Package section NUM_MIN operator The Fletcher Reeves version of the STEEPEST DESCENT algorithms is used to find the MINIMUM of a function of one or more variables. The function must have continuous partial derivatives with respect to all variables. The starting point of the search can be specified; if not, random values are taken instead. The steepest descent algorithms in general find only local minima. syntax: NUM_MIN (<exp>, <var>[=<val>] [,<var>[=<val>] ... [,accuracy=<a>] [,iterations=<i>]) or NUM_MIN (exp, <var>[=<val>] [,<var>[=<val>] ...] [,accuracy=<a>] [,iterations=<i>]) where <exp> is a function expression, <var> are the variables in <exp> and <val> are the (optional) start values. For <a> and <i> see [*note numeric accuracy::.] . NUM_MIN tries to find the next local minimum along the descending path starting at the given point. The result is a [*note LIST::.] with the minimum function value as first element followed by a list of [*note EQUATION::.] S , where the variables are equated to the coordinates of the result point. examples: ____________________________________________________________ num_min(sin(x)+x/5, x) {4.9489585606,{X=29.643767785}} num_min(sin(x)+x/5, x=0) { - 1.3342267466,{X= - 1.7721582671}} ____________________________________________________________ File: redhelp, Node: num_solve, Next: num_int, Prev: num_min, Up: Numeric Package section NUM_SOLVE operator An adaptively damped Newton iteration is used to find an approximative root of a function (function vector) or the solution of an [*note EQUATION::.] (equation system). The expressions must have continuous derivatives for all variables. A starting point for the iteration can be given. If not given random values are taken instead. When the number of forms is not equal to the number of variables, the Newton method cannot be applied. Then the minimum of the sum of absolute squares is located instead. With [*note COMPLEX::.] on, solutions with imaginary parts can be found, if either the expression(s) or the starting point contain a nonzero imaginary part. syntax: NUM_SOLVE (<exp>, <var>[=<val>][,accuracy=<a>][,iterations=<i>]) or NUM_SOLVE (<exp>,...,<exp>, <var>[=<val>],...,<var>[=<val>] [,accuracy=<a>][,iterations=<i>]) or NUM_SOLVE (<exp>,...,<exp>, <var>[=<val>],...,<var>[=<val>] [,accuracy=<a>][,iterations=<i>]) where <exp> are function expressions, <var> are the variables, <val> are optional start values. For <a> and <i> see [*note numeric accuracy::.] . NUM_SOLVE tries to find a zero/solution of the expression(s). Result is a list of equations, where the variables are equated to the coordinates of the result point. The JACOBIAN MATRIX is stored as side effect the shared variable JACOBIAN . examples: ____________________________________________________________ num_solve({sin x=cos y, x + y = 1},{x=1,y=2}); {X= - 1.8561957251,Y=2.856195584} jacobian; [COS(X) SIN(Y)] [ ] [ 1 1 ] ____________________________________________________________ File: redhelp, Node: num_int, Next: num_odesolve, Prev: num_solve, Up: Numeric Package section NUM_INT operator For the numerical evaluation of univariate integrals over a finite interval the following strategy is used: If [*note INT::.] finds a formal antiderivative which is bounded in the integration interval, this is evaluated and the end points and the difference is returned. Otherwise a [*note Chebyshev fit::.] is computed, starting with order 20, eventually up to order 80. If that is recognized as sufficiently convergent it is used for computing the integral by directly integrating the coefficient sequence. If none of these methods is successful, an adaptive multilevel quadrature algorithm is used. For multivariate integrals only the adaptive quadrature is used. This algorithm tolerates isolated singularities. The value ITERATIONS here limits the number of local interval intersection levels. <a> is a measure for the relative total discretization error (comparison of order 1 and order 2 approximations). syntax: NUM_INT (<exp>,<var>=(<l> .. <u>) [,<var>=(<l> .. <u>),...] [,accuracy=<a>][,iterations=<i>]) where <exp> is the function to be integrated, <var> are the integration variables, <l> are the lower bounds, <u> are the upper bounds. Result is the value of the integral. examples: ____________________________________________________________ num_int(sin x,x=(0 .. 3.1415926)); 2.0000010334 ____________________________________________________________ File: redhelp, Node: num_odesolve, Next: bounds, Prev: num_int, Up: Numeric Package section NUM_ODESOLVE operator The RUNGE-KUTTA method of order 3 finds an approximate graph for the solution of real ODE INITIAL VALUE PROBLEM . syntax: NUM_ODESOLVE (<exp>,<depvar>=<start>, <indep>=(<from> .. <to>) [,accuracy=<a>][,iterations=<i>]) or NUM_ODESOLVE (<exp>,<exp>,..., <depvar>=<start>,<depvar>=<start>,... <indep>=(<from> .. <to>) [,accuracy=<a>][,iterations=<i>]) where <depvar> and <start> specify the dependent variable(s) and the starting point value (vector), <indep>, <from> and <to> specify the independent variable and the integration interval (starting point and end point), <exp> are equations or expressions which contain the first derivative of the independent variable with respect to the dependent variable. The ODEs are converted to an explicit form, which then is used for a Runge Kutta iteration over the given range. The number of steps is controlled by the value of <i> (default: 20). If the steps are too coarse to reach the desired accuracy in the neighborhood of the starting point, the number is increased automatically. Result is a list of pairs, each representing a point of the approximate solution of the ODE problem. examples: ____________________________________________________________ depend(y,x); num_odesolve(df(y,x)=y,y=1,x=(0 .. 1), iterations=5); ,{0.2,1.2214},{0.4,1.49181796},{0.6,1.8221064563}, {0.8,2.2255208258},{1.0,2.7182511366}} ____________________________________________________________ In most cases you must declare the dependency relation between the variables explicitly using [*note DEPEND::.] ; otherwise the formal derivative might be converted to zero. The operator [*note SOLVE::.] is used to convert the form into an explicit ODE. If that process fails or if it has no unique result, the evaluation is stopped with an error message. File: redhelp, Node: bounds, Next: Chebyshev fit, Prev: num_odesolve, Up: Numeric Package section BOUNDS operator Upper and lower bounds of a real valued function over an [*note Interval::.] or a rectangular multivariate domain are computed by the operator BOUNDS . The algorithmic basis is the computation with inequalities: starting from the interval(s) of the variables, the bounds are propagated in the expression using the rules for inequality computation. Some knowledge about the behavior of special functions like ABS, SIN, COS, EXP, LOG, fractional exponentials etc. is integrated and can be evaluated if the operator BOUNDS is called with rounded mode on (otherwise only algebraic evaluation rules are available). If BOUNDS finds a singularity within an interval, the evaluation is stopped with an error message indicating the problem part of the expression. syntax: BOUNDS (<exp>,<var>=(<l> .. <u>) [,<var>=(<l> .. <u>) ...]) or BOUNDS (<exp>,<var>=(<l> .. <u>) [,<var>=(<l> .. <u>) ...]) where <exp> is the function to be investigated, <var> are the variables of <exp>, <l> and <u> specify the area as set of [*note Interval::.] S . BOUNDS computes upper and lower bounds for the expression in the given area. An [*note Interval::.] is returned. examples: ____________________________________________________________ bounds(sin x,x=(1 .. 2)); -1 .. 1 on rounded; bounds(sin x,x=(1 .. 2)); 0.84147098481 .. 1 bounds(x**2+x,x=(-0.5 .. 0.5)); - 0.25 .. 0.75 ____________________________________________________________ File: redhelp, Node: Chebyshev fit, Next: num_fit, Prev: bounds, Up: Numeric Package section CHEBYSHEV FIT The operator family CHEBYSHEV_... implements approximation and evaluation of functions by the Chebyshev method. Let T(N,A,B,X) be the Chebyshev polynomial of order N transformed to the interval (A,B) . Then a function F(X) can be approximated in (A,B) by a series ____________________________________________________________ for i := 0:n sum c(i)*T(i,a,b,x) ____________________________________________________________ The operator CHEBYSHEV_FIT computes this approximation and returns a list, which has as first element the sum expressed as a polynomial and as second element the sequence of Chebyshev coefficients. CHEBYSHEV_DF and CHEBYSHEV_INT transform a Chebyshev coefficient list into the coefficients of the corresponding derivative or integral respectively. For evaluating a Chebyshev approximation at a given point in the basic interval the operator CHEBYSHEV_EVAL can be used. CHEBYSHEV_EVAL is based on a recurrence relation which is in general more stable than a direct evaluation of the complete polynomial. syntax: CHEBYSHEV_FIT (<fcn>,<var>=(<lo> .. <hi>),<n>) CHEBYSHEV_EVAL (<coeffs>,<var>=(<lo> .. <hi>), <var>=<pt>) CHEBYSHEV_DF (<coeffs>,<var>=(<lo> .. <hi>)) CHEBYSHEV_INT (<coeffs>,<var>=(<lo> .. <hi>)) where <fcn> is an algebraic expression (the target function), <var> is the variable of <fcn>, <lo> and <hi> are numerical real values which describe an [*note Interval::.] <lo> < <hi>, the integer <n> is the approximation order (set to 20 if missing), <pt> is a number in the interval and <coeffs> is a series of Chebyshev coefficients. examples: ____________________________________________________________ on rounded; w:=chebyshev_fit(sin x/x,x=(1 .. 3),5); 3 2 w := {0.03824*x - 0.2398*x + 0.06514*x + 0.9778, {0.8991,-0.4066,-0.005198,0.009464,-0.00009511}} chebyshev_eval(second w, x=(1 .. 3), x=2.1); 0.4111 ____________________________________________________________ File: redhelp, Node: num_fit, Prev: Chebyshev fit, Up: Numeric Package section NUM_FIT operator The operator NUM_FIT finds for a set of points the linear combination of a given set of functions (function basis) which approximates the points best under the objective of the LEAST SQUARES criterion (minimum of the sum of the squares of the deviation). The solution is found as zero of the gradient vector of the sum of squared errors. syntax: NUM_FIT (<vals>,<basis>,<var>=<pts>) where <vals> is a list of numeric values, <var> is a variable used for the approximation, <pts> is a list of coordinate values which correspond to <var>, <basis> is a set of functions varying in VAR which is used for the approximation. The result is a list containing as first element the function which approximates the given values, and as second element a list of coefficients which were used to build this function from the basis. examples: ____________________________________________________________ pts:=for i:=1 step 1 until 5 collect i$ vals:=for i:=1 step 1 until 5 collect for j:=1:i product j$ num_fit(vals,{1,x,x**2},x=pts); 2 {14.571428571*X - 61.428571429*X + 54.6,{54.6, - 61.428571429,14.571428571}} ____________________________________________________________ File: redhelp, Node: Numeric Package section, Next: Roots Package section, Prev: High Energy Physics section, Up: Top Numeric Package section * Menu: * Numeric Package:: introduction * Interval:: type * numeric accuracy:: concept * TRNUMERIC:: switch * num_min:: operator * num_solve:: operator * num_int:: operator * num_odesolve:: operator * bounds:: operator * Chebyshev fit:: concept * num_fit:: operator File: redhelp, Node: Roots Package, Next: MKPOLY, Up: Roots Package section ROOTS PACKAGE introduction The root finding package is designed so that it can be used to find some or all of the roots of univariate polynomials with real or complex coefficients, to the accuracy specified by the user. Not all operators of ROOTS PACKAGE are described here. For using the operators ISOLATER (intervals isolating real roots) RLROOTNO (number of real roots in an interval) ROOTSAT-PREC (roots at system precision) ROOTVAL (result in equation form) FIRSTROOT (computing only one root) GETROOT (selecting roots from a collection) please consult the full documentation of the package. File: redhelp, Node: MKPOLY, Next: NEARESTROOT, Prev: Roots Package, Up: Roots Package section MKPOLY operator Given a roots list as returned by [*note ROOTS::.] , the operator MKPOLY constructs a polynomial which has these numbers as roots. syntax: MKPOLY <rl> where <rl> is a [*note LIST::.] with equations, which all have the same [*note KERNEL::.] on their left-hand sides and numbers as right-hand sides. examples: ____________________________________________________________ mkpoly{x=1,x=-2,x=i,x=-i}; x**4 + x**3 - x**2 + x - 2 ____________________________________________________________ Note that this polynomial is unique only up to a numeric factor. File: redhelp, Node: NEARESTROOT, Next: REALROOTS, Prev: MKPOLY, Up: Roots Package section NEARESTROOT operator The operator NEARESTROOT finds one root of a polynomial with an iteration using a given starting point. syntax: NEARESTROOT (<p>,<pt>) where <p> is a univariate polynomial and <pt> is a number. examples: ____________________________________________________________ nearestroot(x^2+2,2); {x=1.41421*i} ____________________________________________________________ The minimal accuracy of the result values is controlled by [*note ROOTACC::.] . File: redhelp, Node: REALROOTS, Next: ROOTACC, Prev: NEARESTROOT, Up: Roots Package section REALROOTS operator The operator REALROOTS finds that real roots of a polynomial to an accuracy that is sufficient to separate them and which is a minimum of 6 decimal places. syntax: REALROOTS (<p>) or REALROOTS (<p>,<from>,<to>) where <p> is a univariate polynomial. The optional parameters <from> and <to> classify an interval: if given, exactly the real roots in this interval will be returned. <from> and <to> can also take the values INFINITY or -INFINITY . If omitted all real roots will be returned. Result is a [*note LIST::.] of equations which represent the roots of the polynomial at the given accuracy. examples: ____________________________________________________________ realroots(x^5-2); {x=1.1487} realroots(x^3-104*x^2+403*x-300,2,infinity); {x=3.0,x=100.0} realroots(x^3-104*x^2+403*x-300,-infinity,2); {x=1} ____________________________________________________________ The minimal accuracy of the result values is controlled by [*note ROOTACC::.] . File: redhelp, Node: ROOTACC, Next: ROOTS, Prev: REALROOTS, Up: Roots Package section ROOTACC operator The operator ROOTACC allows you to set the accuracy up to which the roots package computes its results. syntax: ROOTACC (<n>) Here <n> is an integer value. The internal accuracy of the ROOTS package is adjusted to a value of MAX(6,N) . The default value is 6 . File: redhelp, Node: ROOTS, Next: ROOT_VAL, Prev: ROOTACC, Up: Roots Package section ROOTS operator The operator ROOTS is the main top level function of the roots package. It will find all roots, real and complex, of the polynomial p to an accuracy that is sufficient to separate them and which is a minimum of 6 decimal places. syntax: ROOTS (<p>) where <p> is a univariate polynomial. Result is a [*note LIST::.] of equations which represent the roots of the polynomial at the given accuracy. In addition, ROOTS stores separate lists of real roots and complex roots in the global variables [*note ROOTSREAL::.] and [*note ROOTSCOMPLEX::.] . examples: ____________________________________________________________ roots(x^5-2); {x=-0.929316 + 0.675188*i, x=-0.929316 - 0.675188*i, x=0.354967 + 1.09248*i, x=0.354967 - 1.09248*i, x=1.1487} ____________________________________________________________ The minimal accuracy of the result values is controlled by [*note ROOTACC::.] . File: redhelp, Node: ROOT_VAL, Next: ROOTSCOMPLEX, Prev: ROOTS, Up: Roots Package section ROOT_VAL operator The operator ROOT_VAL computes the roots of a univariate polynomial at system precision (or greater if required for root separation) and presents its result as a list of numbers. syntax: ROOTS (<p>) where <p> is a univariate polynomial. examples: ____________________________________________________________ root_val(x^5-2); {-0.929316490603 + 0.6751879524*i, -0.929316490603 - 0.6751879524*i, 0.354967313105 + 1.09247705578*i, 0.354967313105 - 1.09247705578*i, 1.148698355} ____________________________________________________________ File: redhelp, Node: ROOTSCOMPLEX, Next: ROOTSREAL, Prev: ROOT_VAL, Up: Roots Package section ROOTSCOMPLEX variable When the operator [*note ROOTS::.] is called the complex roots are collected in the global variable ROOTSCOMPLEX as [*note LIST::.] . File: redhelp, Node: ROOTSREAL, Prev: ROOTSCOMPLEX, Up: Roots Package section ROOTSREAL variable When the operator [*note ROOTS::.] is called the real roots are collected in the global variable ROOTREAL as [*note LIST::.] . File: redhelp, Node: Roots Package section, Next: Special Functions section, Prev: Numeric Package section, Up: Top Roots Package section * Menu: * Roots Package:: introduction * MKPOLY:: operator * NEARESTROOT:: operator * REALROOTS:: operator * ROOTACC:: operator * ROOTS:: operator * ROOT_VAL:: operator * ROOTSCOMPLEX:: variable * ROOTSREAL:: variable File: redhelp, Node: Special Function Package, Next: Constants, Up: Special Functions section SPECIAL FUNCTION PACKAGE introduction The REDUCE SPECIAL FUNCTION PACKAGE supplies extended algebraic and numeric support for a wide class of objects. This package was released together with REDUCE 3.5 (October 1993) for the first time, a major update is released with REDUCE 3.6. The functions included in this package are in most cases (unless otherwise stated) defined and named like in the book by Abramowitz and Stegun: Handbook of Mathematical Functions, Dover Publications. The aim is to collect as much information on the special functions and simplification capabilities as possible, i.e. algebraic simplifications and numeric (rounded mode) code, limits of the functions together with the definitions of the functions, which are in most cases a power series, a (definite) integral and/or a differential equation. What can be found: Some famous constants, a variety of Bessel functions, special polynomials, the Gamma function, the (Riemann) Zeta function, Elliptic Functions, Elliptic Integrals, 3J symbols (Clebsch-Gordan coefficients) and integral functions. What is missing: Mathieu functions, LerchPhi, etc.. The information about the special functions which solve certain differential equation is very limited. In several cases numerical approximation is restricted to real arguments or is missing completely. The implementation of this package uses REDUCE rule sets to a large extent, which guarantees a high 'readability' of the functions definitions in the source file directory. It makes extensions to the special functions code easy in most cases too. To look at these rules it may be convenient to use the showrules operator e.g. [*note SHOWRULES::.] Besseli; . Some evaluations are improved if the special function package is loaded, e.g. some (infinite) sums and products leading to expressions including special functions are known in this case. Note: The special function package has to be loaded explicitly by calling ____________________________________________________________ load_package specfn; ____________________________________________________________ The functions [*note MeijerG::.] and [*note HYPERGEOMETRIC::.] require additionally ____________________________________________________________ load_package specfn2; ____________________________________________________________ File: redhelp, Node: Constants, Next: Bernoulli Euler Zeta section, Prev: Special Function Package, Up: Special Functions section CONSTANTS There are a few constants known to the special function package, namely EULER CONSTANT (which can be computed as -[*note PSI::.] (1)) and KHINCHIN CONSTANT (which is defined in Khinchin's book "Continued Fractions") and GOLDEN_RATIO (which can be computed as (1 + sqrt 5)/2) and CATALAN CONSTANT (which is known as an infinite sum of reciprocal powers) examples: ____________________________________________________________ on rounded; Euler_Gamma; 0.577215664902 Khinchin; 2.68545200107 Catalan 0.915965594177 Golden_Ratio 1.61803398875 ____________________________________________________________ File: redhelp, Node: BERNOULLI, Next: BERNOULLIP, Up: Bernoulli Euler Zeta section BERNOULLI operator The BERNOULLI operator returns the nth Bernoulli number. syntax: BERNOULLI (<integer>) examples: ____________________________________________________________ bernoulli 20; - 174611 / 330 bernoulli 17; 0 ____________________________________________________________ All Bernoulli numbers with odd indices except for 1 are zero. File: redhelp, Node: BERNOULLIP, Next: EULER, Prev: BERNOULLI, Up: Bernoulli Euler Zeta section BERNOULLIP operator The BERNOULLIP operator returns the nth Bernoulli Polynomial evaluated at x. syntax: BERNOULLIP (<integer>,<expression>) examples: ____________________________________________________________ BernoulliP(3,z); 2 z*(2*z - 3*z + 1)/2 BernoulliP(10,3); 338585 / 66 ____________________________________________________________ The value of the nth Bernoulli Polynomial at 0 is the nth Bernoulli number. File: redhelp, Node: EULER, Next: EULERP, Prev: BERNOULLIP, Up: Bernoulli Euler Zeta section EULER operator The EULER operator returns the nth Euler number. syntax: EULER (<integer>) examples: ____________________________________________________________ Euler 20; 370371188237525 Euler 0; 1 ____________________________________________________________ The EULER numbers are evaluated by a recursive algorithm which makes it hard to compute Euler numbers above say 200. Euler numbers appear in the coefficients of the power series representation of 1/cos(z). File: redhelp, Node: EULERP, Next: ZETA, Prev: EULER, Up: Bernoulli Euler Zeta section EULERP operator The EULERP operator returns the nth Euler Polynomial. syntax: EULERP (<integer>,<expression>) examples: ____________________________________________________________ EulerP(2,xx); xx*(xx - 1) EulerP(10,3); 2046 ____________________________________________________________ The Euler numbers are the values of the Euler Polynomials at 1/2 multiplied by 2**n. File: redhelp, Node: ZETA, Prev: EULERP, Up: Bernoulli Euler Zeta section ZETA operator The ZETA operator returns Riemann's Zeta function, Zeta (z) := sum(1/(k**z),k,1,infinity) syntax: ZETA (<expression>) examples: ____________________________________________________________ Zeta(2); 2 pi / 6 on rounded; Zeta 1.01; 100.577943338 ____________________________________________________________ Numerical computation for the Zeta function for arguments close to 1 are tedious, because the series is converging very slowly. In this case a formula (e.g. found in Bender/Orzag: Advanced Mathematical Methods for Scientists and Engineers, McGraw-Hill) is used. No numerical approximation for complex arguments is done. File: redhelp, Node: Bernoulli Euler Zeta section, Next: Bessel Functions section, Prev: Constants, Up: Special Functions section Bernoulli Euler Zeta section * Menu: * BERNOULLI:: operator * BERNOULLIP:: operator * EULER:: operator * EULERP:: operator * ZETA:: operator File: redhelp, Node: BESSELJ, Next: BESSELY, Up: Bessel Functions section BESSELJ operator The BESSELJ operator returns the Bessel function of the first kind. syntax: BESSELJ (<order>,<argument>) examples: ____________________________________________________________ BesselJ(1/2,pi); 0 on rounded; BesselJ(0,1); 0.765197686558 ____________________________________________________________ File: redhelp, Node: BESSELY, Next: HANKEL1, Prev: BESSELJ, Up: Bessel Functions section BESSELY operator The BESSELY operator returns the Bessel function of the second kind. syntax: BESSELY (<order>,<argument>) examples: ____________________________________________________________ BesselY (1/2,pi); - sqrt(2) / pi on rounded; BesselY (1,3); 0.324674424792 ____________________________________________________________ The operator BESSELY is also called Weber's function. File: redhelp, Node: HANKEL1, Next: HANKEL2, Prev: BESSELY, Up: Bessel Functions section HANKEL1 operator The HANKEL1 operator returns the Hankel function of the first kind. syntax: HANKEL1 (<order>,<argument>) examples: ____________________________________________________________ on complex; Hankel1 (1/2,pi); - i * sqrt(2) / pi Hankel1 (1,pi); besselj(1,pi) + i*bessely(1,pi) ____________________________________________________________ The operator HANKEL1 is also called Bessel function of the third kind. There is currently no numeric evaluation of Hankel functions. File: redhelp, Node: HANKEL2, Next: BESSELI, Prev: HANKEL1, Up: Bessel Functions section HANKEL2 operator The HANKEL2 operator returns the Hankel function of the second kind. syntax: HANKEL2 (<order>,<argument>) examples: ____________________________________________________________ on complex; Hankel2 (1/2,pi); - i * sqrt(2) / pi Hankel2 (1,pi); besselj(1,pi) - i*bessely(1,pi) ____________________________________________________________ The operator HANKEL2 is also called Bessel function of the third kind. There is currently no numeric evaluation of Hankel functions. File: redhelp, Node: BESSELI, Next: BESSELK, Prev: HANKEL2, Up: Bessel Functions section BESSELI operator The BESSELI operator returns the modified Bessel function I. syntax: BESSELI (<order>,<argument>) examples: ____________________________________________________________ on rounded; Besseli (1,1); 0.565159103992 ____________________________________________________________ The knowledge about the operator BESSELI is currently fairly limited. File: redhelp, Node: BESSELK, Next: StruveH, Prev: BESSELI, Up: Bessel Functions section BESSELK operator The BESSELK operator returns the modified Bessel function K. syntax: BESSELK (<order>,<argument>) examples: ____________________________________________________________ df(besselk(0,x),x); - besselk(1,x) ____________________________________________________________ There is currently no numeric support for the operator BESSELK . File: redhelp, Node: StruveH, Next: StruveL, Prev: BESSELK, Up: Bessel Functions section STRUVEH operator The STRUVEH operator returns Struve's H function. syntax: STRUVEH (<order>,<argument>) examples: ____________________________________________________________ struveh(-3/2,x); - besselj(3/2,x) / i ____________________________________________________________ File: redhelp, Node: StruveL, Next: KummerM, Prev: StruveH, Up: Bessel Functions section STRUVEL operator The STRUVEL operator returns the modified Struve L function . syntax: STRUVEL (<order>,<argument>) examples: ____________________________________________________________ struvel(-3/2,x); besseli(3/2,x) ____________________________________________________________ File: redhelp, Node: KummerM, Next: KummerU, Prev: StruveL, Up: Bessel Functions section KUMMERM operator The KUMMERM operator returns Kummer's M function. syntax: KUMMERM (<parameter>,<parameter>,<argument>) examples: ____________________________________________________________ kummerm(1,1,x); x e on rounded; kummerm(1,3,1.3); 1.62046942914 ____________________________________________________________ Kummer's M function is one of the Confluent Hypergeometric functions. For reference see the [*note HYPERGEOMETRIC::.] operator. File: redhelp, Node: KummerU, Next: WhittakerW, Prev: KummerM, Up: Bessel Functions section KUMMERU operator The KUMMERU operator returns Kummer's U function. syntax: KUMMERU (<parameter>,<parameter>,<argument>) examples: ____________________________________________________________ df(kummeru(1,1,x),x) - kummeru(2,2,x) ____________________________________________________________ Kummer's U function is one of the Confluent Hypergeometric functions. For reference see the [*note HYPERGEOMETRIC::.] operator. File: redhelp, Node: WhittakerW, Prev: KummerU, Up: Bessel Functions section WHITTAKERW operator The WHITTAKERW operator returns Whittaker's W function. syntax: WHITTAKERW (<parameter>,<parameter>,<argument>) examples: ____________________________________________________________ WhittakerW(2,2,2); 1 4*sqrt(2)*kummeru(-,5,2) 2 ------------------------- e ____________________________________________________________ Whittaker's W function is one of the Confluent Hypergeometric functions. For reference see the [*note HYPERGEOMETRIC::.] operator. File: redhelp, Node: Bessel Functions section, Next: Airy Functions section, Prev: Bernoulli Euler Zeta section, Up: Special Functions section Bessel Functions section * Menu: * BESSELJ:: operator * BESSELY:: operator * HANKEL1:: operator * HANKEL2:: operator * BESSELI:: operator * BESSELK:: operator * StruveH:: operator * StruveL:: operator * KummerM:: operator * KummerU:: operator * WhittakerW:: operator File: redhelp, Node: Airy_Ai, Next: Airy_Bi, Up: Airy Functions section AIRY_AI operator The AIRY_AI operator returns the Airy Ai function for a given argument. syntax: AIRY_AI (<argument>) examples: ____________________________________________________________ on complex; on rounded; Airy_Ai(0); 0.355028053888 Airy_Ai(3.45 + 17.97i); - 5.5561528511e+9 - 8.80397899932e+9*i ____________________________________________________________ File: redhelp, Node: Airy_Bi, Next: Airy_Aiprime, Prev: Airy_Ai, Up: Airy Functions section AIRY_BI operator The AIRY_BI operator returns the Airy Bi function for a given argument. syntax: AIRY_BI (<argument>) examples: ____________________________________________________________ Airy_Bi(0); 0.614926627446 Airy_Bi(3.45 + 17.97i); 8.80397899932e+9 - 5.5561528511e+9*i ____________________________________________________________ File: redhelp, Node: Airy_Aiprime, Next: Airy_Biprime, Prev: Airy_Bi, Up: Airy Functions section AIRY_AIPRIME operator The AIRY_AIPRIME operator returns the Airy Aiprime function for a given argument. syntax: AIRY_AIPRIME (<argument>) examples: ____________________________________________________________ Airy_Aiprime(0); - 0.258819403793 Airy_Aiprime(3.45+17.97i); - 3.83386421824e+19 + 2.16608828136e+19*i ____________________________________________________________ File: redhelp, Node: Airy_Biprime, Prev: Airy_Aiprime, Up: Airy Functions section AIRY_BIPRIME operator The AIRY_BIPRIME operator returns the Airy Biprime function for a given argument. syntax: AIRY_BIPRIME (<argument>) examples: ____________________________________________________________ Airy_Biprime(0); Airy_Biprime(3.45 + 17.97i); 3.84251916792e+19 - 2.18006297399e+19*i ____________________________________________________________ File: redhelp, Node: Airy Functions section, Next: Jacobi Elliptic Functions and Elliptic Integrals section, Prev: Bessel Functions section, Up: Special Functions section Airy Functions section * Menu: * Airy_Ai:: operator * Airy_Bi:: operator * Airy_Aiprime:: operator * Airy_Biprime:: operator File: redhelp, Node: JacobiSN, Next: JacobiCN, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBISN operator The JACOBISN operator returns the Jacobi Elliptic function sn. syntax: JACOBISN (<expression>,<integer>) examples: ____________________________________________________________ Jacobisn(0.672, 0.36) 0.609519691792 Jacobisn(1,0.9) 0.770085724907881 ____________________________________________________________ File: redhelp, Node: JacobiCN, Next: JacobiDN, Prev: JacobiSN, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBICN operator The JACOBICN operator returns the Jacobi Elliptic function cn. syntax: JACOBICN (<expression>,<integer>) examples: ____________________________________________________________ Jacobicn(7.2, 0.6) 0.837288298482018 Jacobicn(0.11, 19) 0.994403862690043 - 1.6219006985556e-16*i ____________________________________________________________ File: redhelp, Node: JacobiDN, Next: JacobiCD, Prev: JacobiCN, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIDN operator The JACOBIDN operator returns the Jacobi Elliptic function dn. syntax: JACOBIDN (<expression>,<integer>) examples: ____________________________________________________________ Jacobidn(15, 0.683) 0.640574162024592 Jacobidn(0,0) 1 ____________________________________________________________ File: redhelp, Node: JacobiCD, Next: JacobiSD, Prev: JacobiDN, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBICD operator The JACOBICD operator returns the Jacobi Elliptic function cd. syntax: JACOBICD (<expression>,<integer>) examples: ____________________________________________________________ Jacobicd(1, 0.34) 0.657683337805273 Jacobicd(0.8,0.8) 0.925587311582301 ____________________________________________________________ File: redhelp, Node: JacobiSD, Next: JacobiND, Prev: JacobiCD, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBISD operator The JACOBISD operator returns the Jacobi Elliptic function sd. syntax: JACOBISD (<expression>,<integer>) examples: ____________________________________________________________ Jacobisd(12, 0.4) 0.357189729437272 Jacobisd(0.35,1) - 1.17713873203043 ____________________________________________________________ File: redhelp, Node: JacobiND, Next: JacobiDC, Prev: JacobiSD, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIND operator The JACOBIND operator returns the Jacobi Elliptic function nd. syntax: JACOBIND (<expression>,<integer>) examples: ____________________________________________________________ Jacobind(0.2, 17) 1.46553203037507 + 0.0000000000334032759313703*i Jacobind(30, 0.001) 1.00048958438 ____________________________________________________________ File: redhelp, Node: JacobiDC, Next: JacobiNC, Prev: JacobiND, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIDC operator The JACOBIDC operator returns the Jacobi Elliptic function dc. syntax: JACOBIDC (<expression>,<integer>) examples: ____________________________________________________________ Jacobidc(0.003,1) 1 Jacobidc(2, 0.75) 6.43472885111 ____________________________________________________________ File: redhelp, Node: JacobiNC, Next: JacobiSC, Prev: JacobiDC, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBINC operator The JACOBINC operator returns the Jacobi Elliptic function nc. syntax: JACOBINC (<expression>,<integer>) examples: ____________________________________________________________ Jacobinc(1,0) 1.85081571768093 Jacobinc(56, 0.4387) 39.304842663512 ____________________________________________________________ File: redhelp, Node: JacobiSC, Next: JacobiNS, Prev: JacobiNC, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBISC operator The JACOBISC operator returns the Jacobi Elliptic function sc. syntax: JACOBISC (<expression>,<integer>) examples: ____________________________________________________________ Jacobisc(9, 0.88) - 1.16417697982095 Jacobisc(0.34, 7) 0.305851938390775 - 9.8768100944891e-12*i ____________________________________________________________ File: redhelp, Node: JacobiNS, Next: JacobiDS, Prev: JacobiSC, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBINS operator The JACOBINS operator returns the Jacobi Elliptic function ns. syntax: JACOBINS (<expression>,<integer>) examples: ____________________________________________________________ Jacobins(3, 0.9) 1.00945801599785 Jacobins(0.887, 15) 0.683578280513975 - 0.85023411082469*i ____________________________________________________________ File: redhelp, Node: JacobiDS, Next: JacobiCS, Prev: JacobiNS, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIDS operator The JACOBISN operator returns the Jacobi Elliptic function ds. syntax: JACOBIDS (<expression>,<integer>) examples: ____________________________________________________________ Jacobids(98,0.223) - 1.061253961477 Jacobids(0.36,0.6) 2.76693172243692 ____________________________________________________________ File: redhelp, Node: JacobiCS, Next: JacobiAMPLITUDE, Prev: JacobiDS, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBICS operator The JACOBICS operator returns the Jacobi Elliptic function cs. syntax: JACOBICS (<expression>,<integer>) examples: ____________________________________________________________ Jacobics(0, 0.767) infinity Jacobics(1.43, 0) 0.141734127352112 ____________________________________________________________ File: redhelp, Node: JacobiAMPLITUDE, Next: AGM_FUNCTION, Prev: JacobiCS, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIAMPLITUDE operator The JACOBIAMPLITUDE operator returns the amplitude of u. syntax: JACOBIAMPLITUDE (<expression>,<integer>) examples: ____________________________________________________________ JacobiAmplitude(7.239, 0.427) 0.0520978301448978 JacobiAmplitude(0,0.1) 0 ____________________________________________________________ Amplitude u = asin(JACOBISN(U,M) ) File: redhelp, Node: AGM_FUNCTION, Next: LANDENTRANS, Prev: JacobiAMPLITUDE, Up: Jacobi Elliptic Functions and Elliptic Integrals section AGM_FUNCTION operator The AGM_FUNCTION operator returns a list of (N, AGM, list of aNtoa0, list of bNtob0, list of cNtoc0) where a0, b0 and c0 are the initial values; N is the index number of the last term used to generate the AGM. AGM is the Arithmetic Geometric Mean. syntax: AGM_FUNCTION (<integer>,<integer>,<integer>) examples: ____________________________________________________________ AGM_function(1,1,1) 1,1,1,1,1,1,0,1 AGM_function(1, 0.1, 1.3) {6, 2.27985615996629, {2.27985615996629, 2.27985615996629, 2.2798561599706, 2.2798624278857, 2.28742283656583, 2.55, 1}, {2.27985615996629, 2.27985615996629, 2.27985615996198, 2.2798498920555, 2.27230201920557, 2.02484567313166, 4.1}, {0, 4.30803136219904e-12, 0.0000062679151007581, 0.00756040868012758, 0.262577163434171, - 1.55, 5.9}} ____________________________________________________________ The other Jacobi functions use this function with initial values a0=1, b0=sqrt(1-m), c0=sqrt(m). File: redhelp, Node: LANDENTRANS, Next: EllipticF, Prev: AGM_FUNCTION, Up: Jacobi Elliptic Functions and Elliptic Integrals section LANDENTRANS operator The LANDENTRANS operator generates the descending landen transformation of the given imput values, returning a list of these values; initial to final in each case. syntax: LANDENTRANS (<expression>,<integer>) examples: ____________________________________________________________ landentrans(0,0.1) {{0,0,0,0,0},{0.1,0.0025041751943776, 0.00000156772498954046,6.1444078 9914461e-13,0}} ____________________________________________________________ The first list ascends in value, and the second descends in value. File: redhelp, Node: EllipticF, Next: EllipticK, Prev: LANDENTRANS, Up: Jacobi Elliptic Functions and Elliptic Integrals section ELLIPTICF operator The ELLIPTICF operator returns the Elliptic Integral of the First Kind. syntax: ELLITPICF (<expression>,<integer>) examples: ____________________________________________________________ EllipticF(0.3, 8.222) 0.3 EllipticF(7.396, 0.1) 7.58123216114307 ____________________________________________________________ The Complete Elliptic Integral of the First Kind can be found by putting the first argument to pi/2 or by using ELLIPTICK and the second argument. File: redhelp, Node: EllipticK, Next: EllipticKprime, Prev: EllipticF, Up: Jacobi Elliptic Functions and Elliptic Integrals section ELLIPTICK operator The ELLIPTICK operator returns the Elliptic value K. syntax: ELLIPTICK (<integer>) examples: ____________________________________________________________ EllipticK(0.2) 1.65962359861053 EllipticK(4.3) 0.808442364282734 - 1.05562492399206*i EllipticK(0.000481) 1.57098526617635 ____________________________________________________________ The ELLIPTICK function is the Complete Elliptic Integral of the First Kind. File: redhelp, Node: EllipticKprime, Next: EllipticE, Prev: EllipticK, Up: Jacobi Elliptic Functions and Elliptic Integrals section ELLIPTICKPRIME operator The ELLIPTICK' operator returns the Elliptic value K(m). syntax: ELLIPTICKPRIME (<integer>) examples: ____________________________________________________________ EllipticKprime(0.2) 2.25720532682085 EllipticKprime(4.3) 1.05562492399206 EllipticKprime(0.000481) 5.206621921966 ____________________________________________________________ The ELLIPTICKPRIME function is the Complete Elliptic Integral of the First Kind of (1-m). File: redhelp, Node: EllipticE, Next: EllipticTHETA, Prev: EllipticKprime, Up: Jacobi Elliptic Functions and Elliptic Integrals section ELLIPTICE operator The ELLIPTICE operator used with two arguments returns the Elliptic Integral of the Second Kind. syntax: ELLIPTICE (<expression>,<integer>) examples: ____________________________________________________________ EllipticE(1.2,0.22) 1.15094019180949 EllipticE(0,4.35) 0 EllipticE(9,0.00719) 8.98312465929145 ____________________________________________________________ The Complete Elliptic Integral of the Second Kind can be obtained by using just the second argument, or by using pi/2 as the first argument. The ELLIPTICE operator used with one argument returns the Elliptic value E. syntax: ELLIPTICE (<integer>) examples: ____________________________________________________________ EllipticE(0.22) 1.48046637439519 EllipticE(pi/2, 0.22) 1.48046637439519 ____________________________________________________________ File: redhelp, Node: EllipticTHETA, Next: JacobiZETA, Prev: EllipticE, Up: Jacobi Elliptic Functions and Elliptic Integrals section ELLIPTICTHETA operator The ELLIPTICTHETA operator returns one of the four Theta functions. It cannot except any number other than 1,2,3 or 4 as its first argument. syntax: ELLIPTICTHETA (<integer>,<expression>,<integer>) examples: ____________________________________________________________ EllipticTheta(1, 1.4, 0.72) 0.91634775373 EllipticTheta(2, 3.9, 6.1 ) -48.0202736969 + 20.9881034377 i EllipticTheta(3, 0.67, 0.2) 1.0083077448 EllipticTheta(4, 8, 0.75) 0.894963369304 EllipticTheta(5, 1, 0.1) ***** In EllipticTheta(a,u,m); a = 1,2,3 or 4. ____________________________________________________________ Theta functions are important because every one of the Jacobian Elliptic functions can be expressed as the ratio of two theta functions. File: redhelp, Node: JacobiZETA, Prev: EllipticTHETA, Up: Jacobi Elliptic Functions and Elliptic Integrals section JACOBIZETA operator The JACOBIZETA operator returns the Jacobian function Zeta. syntax: JACOBIZETA (<expression>,<integer>) examples: ____________________________________________________________ JacobiZeta(3.2, 0.8) - 0.254536403439 JacobiZeta(0.2, 1.6) 0.171766095970451 - 0.0717028569800147*i ____________________________________________________________ The Jacobian function Zeta is related to the Jacobian function Theta. But it is significantly different from Riemann's Zeta Function [*note ZETA::.] . File: redhelp, Node: Jacobi Elliptic Functions and Elliptic Integrals section, Next: Gamma and Related Functions section, Prev: Airy Functions section, Up: Special Functions section Jacobi Elliptic Functions and Elliptic Integrals section * Menu: * JacobiSN:: operator * JacobiCN:: operator * JacobiDN:: operator * JacobiCD:: operator * JacobiSD:: operator * JacobiND:: operator * JacobiDC:: operator * JacobiNC:: operator * JacobiSC:: operator * JacobiNS:: operator * JacobiDS:: operator * JacobiCS:: operator * JacobiAMPLITUDE:: operator * AGM_FUNCTION:: operator * LANDENTRANS:: operator * EllipticF:: operator * EllipticK:: operator * EllipticKprime:: operator * EllipticE:: operator * EllipticTHETA:: operator * JacobiZETA:: operator File: redhelp, Node: POCHHAMMER, Next: GAMMA, Up: Gamma and Related Functions section POCHHAMMER operator The POCHHAMMER operator implements the Pochhammer notation (shifted factorial). syntax: POCHHAMMER (<expression>,<expression>) examples: ____________________________________________________________ pochhammer(17,4); 116280 pochhammer(1/2,z); factorial(2*z) -------------------- 2*z (2 *factorial(z)) ____________________________________________________________ A number of complex rules for POCHHAMMER are inactive, because they cause a huge system load in algebraic mode. If one wants to use more rules for the simplification of Pochhammer's notation, one can do: let special!*pochhammer!*rules; File: redhelp, Node: GAMMA, Next: BETA, Prev: POCHHAMMER, Up: Gamma and Related Functions section GAMMA operator The GAMMA operator returns the Gamma function. syntax: GAMMA (<expression>) examples: ____________________________________________________________ gamma(10); 362880 gamma(1/2); sqrt(pi) ____________________________________________________________ File: redhelp, Node: BETA, Next: PSI, Prev: GAMMA, Up: Gamma and Related Functions section BETA operator The BETA operator returns the Beta function defined by Beta (z,w) := defint(t**(z-1)* (1 - t)**(w-1),t,0,1) . syntax: BETA (<expression>,<expression>) examples: ____________________________________________________________ Beta(2,2); 1 / 6 Beta(x,y); gamma(x)*gamma(y) / gamma(x + y) ____________________________________________________________ The operator BETA is simplified towards the [*note GAMMA::.] operator. File: redhelp, Node: PSI, Next: POLYGAMMA, Prev: BETA, Up: Gamma and Related Functions section PSI operator The PSI operator returns the Psi (or DiGamma) function. Psi(x) := df(Gamma(z),z)/ Gamma (z) syntax: GAMMA (<expression>) examples: ____________________________________________________________ Psi(3); (2*log(2) + psi(1/2) + psi(1) + 3)/2 on rounded; - Psi(1); 0.577215664902 ____________________________________________________________ Euler's constant can be found as - Psi(1). File: redhelp, Node: POLYGAMMA, Prev: PSI, Up: Gamma and Related Functions section POLYGAMMA operator The POLYGAMMA operator returns the Polygamma function. Polygamma(n,x) := df(Psi(z),z,n); syntax: POLYGAMMA (<integer>,<expression>) examples: ____________________________________________________________ Polygamma(1,2); 2 (pi - 6) / 6 on rounded; Polygamma(1,2.35); 0.52849689109 ____________________________________________________________ The Polygamma function is used for simplification of the [*note ZETA::.] function for some arguments. File: redhelp, Node: Gamma and Related Functions section, Next: Miscellaneous Functions section, Prev: Jacobi Elliptic Functions and Elliptic Integrals section, Up: Special Functions section Gamma and Related Functions section * Menu: * POCHHAMMER:: operator * GAMMA:: operator * BETA:: operator * PSI:: operator * POLYGAMMA:: operator File: redhelp, Node: DILOG extended, Next: Lambert_W function, Up: Miscellaneous Functions section DILOG EXTENDED operator The package SPECFN supplies an extended support for the [*note DILOG::.] operator which implements the DILOGARITHM FUNCTION . dilog(x) := - defint(log(t)/(t - 1),t,1,x); syntax: DILOG (<order>,<expression>) examples: ____________________________________________________________ defint(log(t)/(t - 1),t,1,x); - dilog (x) dilog 2; 2 - pi /12 on rounded; Dilog 20; - 5.92783972438 ____________________________________________________________ The operator DILOG is sometimes called Spence's Integral for n = 2. File: redhelp, Node: Lambert_W function, Prev: DILOG extended, Up: Miscellaneous Functions section LAMBERT_W FUNCTION operator Lambert's W function is the inverse of the function w * e^w. It is used in the [*note SOLVE::.] package for equations containing exponentials and logarithms. syntax: LAMBERT_W (<z>) examples: ____________________________________________________________ Lambert_W(-1/e); -1 solve(w + log(w),w); w=lambert_w(1) on rounded; Lambert_W(-0.05); - 0.0527059835515 ____________________________________________________________ The current implementation will compute the principal branch in rounded mode only. File: redhelp, Node: Miscellaneous Functions section, Next: Orthogonal Polynomials section, Prev: Gamma and Related Functions section, Up: Special Functions section Miscellaneous Functions section * Menu: * DILOG extended:: operator * Lambert_W function:: operator File: redhelp, Node: ChebyshevT, Next: ChebyshevU, Up: Orthogonal Polynomials section CHEBYSHEVT operator The CHEBYSHEVT operator computes the nth Chebyshev T Polynomial (of the first kind). syntax: CHEBYSHEVT (<integer>,<expression>) examples: ____________________________________________________________ ChebyshevT(3,xx); 2 xx*(4*xx - 3) ChebyshevT(3,4); 244 ____________________________________________________________ Chebyshev's T polynomials are computed using the recurrence relation: ChebyshevT(n,x) := 2x*ChebyshevT(n-1,x) - ChebyshevT(n-2,x) with ChebyshevT(0,x) := 0 and ChebyshevT(1,x) := x File: redhelp, Node: ChebyshevU, Next: HermiteP, Prev: ChebyshevT, Up: Orthogonal Polynomials section CHEBYSHEVU operator The CHEBYSHEVU operator returns the nth Chebyshev U Polynomial (of the second kind). syntax: CHEBYSHEVU (<integer>,<expression>) examples: ____________________________________________________________ ChebyshevU(3,xx); 2 4*x*(2*x - 1) ChebyshevU(3,4); 496 ____________________________________________________________ Chebyshev's U polynomials are computed using the recurrence relation: ChebyshevU(n,x) := 2x*ChebyshevU(n-1,x) - ChebyshevU(n-2,x) with ChebyshevU(0,x) := 0 and ChebyshevU(1,x) := 2x File: redhelp, Node: HermiteP, Next: LaguerreP, Prev: ChebyshevU, Up: Orthogonal Polynomials section HERMITEP operator The HERMITEP operator returns the nth Hermite Polynomial. syntax: HERMITEP (<integer>,<expression>) examples: ____________________________________________________________ HermiteP(3,xx); 2 4*xx*(2*xx - 3) HermiteP(3,4); 464 ____________________________________________________________ Hermite polynomials are computed using the recurrence relation: HermiteP(n,x) := 2x*HermiteP(n-1,x) - 2*(n-1)*HermiteP(n-2,x) with HermiteP(0,x) := 1 and HermiteP(1,x) := 2x File: redhelp, Node: LaguerreP, Next: LegendreP, Prev: HermiteP, Up: Orthogonal Polynomials section LAGUERREP operator The LAGUERREP operator computes the nth Laguerre Polynomial. The two argument call of LaguerreP is a (common) abbreviation of LaguerreP(n,0,x). syntax: LAGUERREP (<integer>,<expression>) or LAGUERREP (<integer>,<expression>,<expression>) examples: ____________________________________________________________ LaguerreP(3,xx); 3 2 (- xx + 9*xx - 18*xx + 6)/6 LaguerreP(2,3,4); -2 ____________________________________________________________ Laguerre polynomials are computed using the recurrence relation: LaguerreP(n,a,x) := (2n+a-1-x)/n*LaguerreP(n-1,a,x) - (n+a-1) * LaguerreP(n-2,a,x) with LaguerreP(0,a,x) := 1 and LaguerreP(2,a,x) := -x+1+a File: redhelp, Node: LegendreP, Next: JacobiP, Prev: LaguerreP, Up: Orthogonal Polynomials section LEGENDREP operator The binary LEGENDREP operator computes the nth Legendre Polynomial which is a special case of the nth Jacobi Polynomial with LegendreP(n,x) := JacobiP(n,0,0,x) The ternary form returns the associated Legendre Polynomial (see below). syntax: LEGENDREP (<integer>,<expression>) or LEGENDREP (<integer>,<expression>,<expression>) examples: ____________________________________________________________ LegendreP(3,xx); 2 xx*(5*xx - 3) ---------------- 2 LegendreP(3,2,xx); 2 15*xx*( - xx + 1) ____________________________________________________________ The ternary form of the operator LEGENDREP is the associated Legendre Polynomial defined as P(n,m,x) = (-1)**m * (1-x**2)**(m/2) * df(LegendreP(n,x),x,m) File: redhelp, Node: JacobiP, Next: GegenbauerP, Prev: LegendreP, Up: Orthogonal Polynomials section JACOBIP operator The JACOBIP operator computes the nth Jacobi Polynomial. syntax: JACOBIP (<integer>,<expression>,<expression>, <expression>) examples: ____________________________________________________________ JacobiP(3,4,5,xx); 3 2 7*(65*xx - 13*xx - 13*xx + 1) ---------------------------------- 8 JacobiP(3,4,5,6); 94465/8 ____________________________________________________________ File: redhelp, Node: GegenbauerP, Next: SolidHarmonicY, Prev: JacobiP, Up: Orthogonal Polynomials section GEGENBAUERP operator The GEGENBAUERP operator computes Gegenbauer's (ultraspherical) polynomials. syntax: GEGENBAUERP (<integer>,<expression>,<expression>) examples: ____________________________________________________________ GegenbauerP(3,2,xx); 2 4*xx*(8*xx - 3) GegenbauerP(3,2,4); 2000 ____________________________________________________________ File: redhelp, Node: SolidHarmonicY, Next: SphericalHarmonicY, Prev: GegenbauerP, Up: Orthogonal Polynomials section SOLIDHARMONICY operator The SOLIDHARMONICY operator computes Solid harmonic (Laplace) polynomials. syntax: SOLIDHARMONICY (<integer>,<integer>, <expression>,<expression>,<expression>,<expression>) examples: ____________________________________________________________ SolidHarmonicY(3,-2,x,y,z,r2); 2 2 sqrt(105)*z*(-2*i*x*y + x - y ) --------------------------------- 4*sqrt(pi)*sqrt(2) ____________________________________________________________ File: redhelp, Node: SphericalHarmonicY, Prev: SolidHarmonicY, Up: Orthogonal Polynomials section SPHERICALHARMONICY operator The SPHERICALHARMONICY operator computes Spherical harmonic (Laplace) polynomials. These are special cases of the solid harmonic polynomials, [*note SolidHarmonicY::.] . syntax: SPHERICALHARMONICY (<integer>,<integer>, <expression>,<expression>) examples: ____________________________________________________________ SphericalHarmonicY(3,2,theta,phi); 2 2 2 sqrt(105)*cos(theta)*sin(theta) *(cos(phi) +2*cos(phi)*sin(phi)*i-sin(phi) ) ----------------------------------------------------------------------------- 4*sqrt(pi)*sqrt(2) ____________________________________________________________ File: redhelp, Node: Orthogonal Polynomials section, Next: Integral Functions section, Prev: Miscellaneous Functions section, Up: Special Functions section Orthogonal Polynomials section * Menu: * ChebyshevT:: operator * ChebyshevU:: operator * HermiteP:: operator * LaguerreP:: operator * LegendreP:: operator * JacobiP:: operator * GegenbauerP:: operator * SolidHarmonicY:: operator * SphericalHarmonicY:: operator File: redhelp, Node: Si, Next: Shi, Up: Integral Functions section SI operator The SI operator returns the Sine Integral function. syntax: SI (<expression>) examples: ____________________________________________________________ limit(Si(x),x,infinity); pi / 2 on rounded; Si(0.35); 0.347626790989 ____________________________________________________________ The numeric values for the operator SI are computed via the power series representation, which limits the argument range. File: redhelp, Node: Shi, Next: s_i, Prev: Si, Up: Integral Functions section SHI operator The SHI operator returns the hyperbolic Sine Integral function. syntax: SHI (<expression>) examples: ____________________________________________________________ df(shi(x),x); sinh(x) / x on rounded; Shi(0.35); 0.352390716351 ____________________________________________________________ The numeric values for the operator SHI are computed via the power series representation, which limits the argument range. File: redhelp, Node: s_i, Next: Ci, Prev: Shi, Up: Integral Functions section S_I operator The S_I operator returns the Sine Integral function si. syntax: S_I (<expression>) examples: ____________________________________________________________ s_i(xx); (2*Si(xx) - pi) / 2 df(s_i(x),x); sin(x) / x ____________________________________________________________ The operator name S_I is simplified towards [*note Si::.] . Since REDUCE is not case sensitive by default the name "si" can't be used. File: redhelp, Node: Ci, Next: Chi, Prev: s_i, Up: Integral Functions section CI operator The CI operator returns the Cosine Integral function. syntax: CI (<expression>) examples: ____________________________________________________________ defint(cos(t)/t,t,x,infinity); - ci (x) on rounded; Ci(0.35); - 0.50307556932 ____________________________________________________________ The numeric values for the operator CI are computed via the power series representation, which limits the argument range. File: redhelp, Node: Chi, Next: ERF extended, Prev: Ci, Up: Integral Functions section CHI operator The CHI operator returns the Hyperbolic Cosine Integral function. syntax: CHI (<expression>) examples: ____________________________________________________________ defint((cosh(t)-1)/t,t,0,x); - log(x) + psi(1) + chi(x) on rounded; Chi(0.35); - 0.44182471827 ____________________________________________________________ The numeric values for the operator CHI are computed via the power series representation, which limits the argument range. File: redhelp, Node: ERF extended, Next: erfc, Prev: Chi, Up: Integral Functions section ERF EXTENDED operator The special function package supplies an extended support for the [*note ERF::.] operator which implements the ERROR FUNCTION defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi) . syntax: ERF (<expression>) examples: ____________________________________________________________ erf(-x); - erf(x) on rounded; erf(0.35); 0.379382053562 ____________________________________________________________ The numeric values for the operator ERF are computed via the power series representation, which limits the argument range. File: redhelp, Node: erfc, Next: Ei, Prev: ERF extended, Up: Integral Functions section ERFC operator The ERFC operator returns the complementary Error function 1 - defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi) . syntax: ERFC (<expression>) examples: ____________________________________________________________ erfc(xx); - erf(xx) + 1 ____________________________________________________________ The operator ERFC is simplified towards the [*note ERF::.] operator. File: redhelp, Node: Ei, Next: Fresnel_C, Prev: erfc, Up: Integral Functions section EI operator The EI operator returns the Exponential Integral function. syntax: EI (<expression>) examples: ____________________________________________________________ df(ei(x),x); x e --- x on rounded; Ei(0.35); - 0.0894340019184 ____________________________________________________________ The numeric values for the operator EI are computed via the power series representation, which limits the argument range. File: redhelp, Node: Fresnel_C, Next: Fresnel_S, Prev: Ei, Up: Integral Functions section FRESNEL_C operator The FRESNEL_C operator represents Fresnel's Cosine function. syntax: FRESNEL_C (<expression>) examples: ____________________________________________________________ int(cos(t^2*pi/2),t,0,x); fresnel_c(x) on rounded; fresnel_c(2.1); 0.581564135061 ____________________________________________________________ The operator FRESNEL_C has a limited numeric evaluation of large values of its argument. File: redhelp, Node: Fresnel_S, Prev: Fresnel_C, Up: Integral Functions section FRESNEL_S operator The FRESNEL_S operator represents Fresnel's Sine Integral function. syntax: FRESNEL_S (<expression>) examples: ____________________________________________________________ int(sin(t^2*pi/2),t,0,x); fresnel_s(x) on rounded; fresnel_s(2.1); 0.374273359378 ____________________________________________________________ The operator FRESNEL_S has a limited numeric evaluation of large values of its argument. File: redhelp, Node: Integral Functions section, Next: Combinatorial Operators section, Prev: Orthogonal Polynomials section, Up: Special Functions section Integral Functions section * Menu: * Si:: operator * Shi:: operator * s_i:: operator * Ci:: operator * Chi:: operator * ERF extended:: operator * erfc:: operator * Ei:: operator * Fresnel_C:: operator * Fresnel_S:: operator File: redhelp, Node: BINOMIAL, Next: STIRLING1, Up: Combinatorial Operators section BINOMIAL operator The BINOMIAL operator returns the Binomial coefficient if both parameter are integer and expressions involving the Gamma function otherwise. syntax: BINOMIAL (<integer>,<integer>) examples: ____________________________________________________________ Binomial(49,6); 13983816 Binomial(n,3); gamma(n + 1) --------------- 6*gamma(n - 2) ____________________________________________________________ The operator BINOMIAL evaluates the Binomial coefficients from the explicit form and therefore it is not the best algorithm if you want to compute many binomial coefficients with big indices in which case a recursive algorithm is preferable. File: redhelp, Node: STIRLING1, Next: STIRLING2, Prev: BINOMIAL, Up: Combinatorial Operators section STIRLING1 operator The STIRLING1 operator returns the Stirling Numbers S(n,m) of the first kind, i.e. the number of permutations of n symbols which have exactly m cycles (divided by (-1)**(n-m)). syntax: STIRLING1 (<integer>,<integer>) examples: ____________________________________________________________ Stirling1 (17,4); -87077748875904 Stirling1 (n,n-1); -gamma(n+1) ------------- 2*gamma(n-1) ____________________________________________________________ The operator STIRLING1 evaluates the Stirling numbers of the first kind by rulesets for special cases or by a computing the closed form, which is a series involving the operators [*note BINOMIAL::.] and [*note STIRLING2::.] . File: redhelp, Node: STIRLING2, Prev: STIRLING1, Up: Combinatorial Operators section STIRLING2 operator The STIRLING1 operator returns the Stirling Numbers S(n,m) of the second kind, i.e. the number of ways of partitioning a set of n elements into m non-empty subsets. syntax: STIRLING2 (<integer>,<integer>) examples: ____________________________________________________________ Stirling2 (17,4); 694337290 Stirling2 (n,n-1); gamma(n+1) ------------- 2*gamma(n-1) ____________________________________________________________ The operator STIRLING2 evaluates the Stirling numbers of the second kind by rulesets for special cases or by a computing the closed form. File: redhelp, Node: Combinatorial Operators section, Next: 3j and 6j symbols section, Prev: Integral Functions section, Up: Special Functions section Combinatorial Operators section * Menu: * BINOMIAL:: operator * STIRLING1:: operator * STIRLING2:: operator File: redhelp, Node: ThreejSymbol, Next: Clebsch_Gordan, Up: 3j and 6j symbols section THREEJSYMBOL operator The THREEJSYMBOL operator implements the 3j symbol. syntax: THREEJSYMBOL (<list of j1,m1>,<list of j2,m2>, <list of j3,m3>) examples: ____________________________________________________________ ThreejSymbol({j+1,m},{j+1,-m},{1,0}); j ( - 1) *(abs(j - m + 1) - abs(j + m + 1)) ------------------------------------------- 3 2 m 2*sqrt(2*j + 9*j + 13*j + 6)*( - 1) ____________________________________________________________ File: redhelp, Node: Clebsch_Gordan, Next: SixjSymbol, Prev: ThreejSymbol, Up: 3j and 6j symbols section CLEBSCH_GORDAN operator The CLEBSCH_GORDAN operator implements the Clebsch_Gordan coefficients. This is closely related to the [*note ThreejSymbol::.] . syntax: CLEBSCH_GORDAN (<list of j1,m1>,<list of j2,m2>, <list of j3,m3>) examples: ____________________________________________________________ Clebsch_Gordan({2,0},{2,0},{2,0}); -2 --------- sqrt(14) ____________________________________________________________ File: redhelp, Node: SixjSymbol, Prev: Clebsch_Gordan, Up: 3j and 6j symbols section SIXJSYMBOL operator The SIXJSYMBOL operator implements the 6j symbol. syntax: SIXJSYMBOL (<list of j1,j2,j3>,<list of l1,l2,l3>) examples: ____________________________________________________________ SixjSymbol({7,6,3},{2,4,6}); 1 ------------- 14*sqrt(858) ____________________________________________________________ The operator SIXJSYMBOL uses the [*note INEQ::.] package in order to find minima and maxima for the summation index. File: redhelp, Node: 3j and 6j symbols section, Next: Miscellaneous section, Prev: Combinatorial Operators section, Up: Special Functions section 3j and 6j symbols section * Menu: * ThreejSymbol:: operator * Clebsch_Gordan:: operator * SixjSymbol:: operator File: redhelp, Node: HYPERGEOMETRIC, Next: MeijerG, Up: Miscellaneous section HYPERGEOMETRIC operator The HYPERGEOMETRIC operator provides simplifications for the generalized hypergeometric functions. The HYPERGEOMETRIC operator is included in the package specfn2. syntax: HYPERGEOMETRIC (<list of parameters>,<list of parameters>, <argument>) examples: ____________________________________________________________ load specfn2; hypergeometric ({1/2,1},{3/2},-x^2); atan(x) -------- x hypergeometric ({},{},z); z e ____________________________________________________________ The special case where the length of the first list is equal to 2 and the length of the second list is equal to 1 is often called "the hypergeometric function" (notated as 2F1(a1,a2,b;x)). File: redhelp, Node: MeijerG, Next: Heaviside, Prev: HYPERGEOMETRIC, Up: Miscellaneous section MEIJERG operator The MEIJERG operator provides simplifications for Meijer's G function. The simplifications are performed towards polynomials, elementary or special functions or (generalized) [*note HYPERGEOMETRIC::.] functions. The MEIJERG operator is included in the package specfn2. syntax: MEIJERG (<list of parameters>,<list of parameters>, <argument>) The first element of the lists has to be the list containing the first group (mostly called "m" and "n") of parameters. This passes the four parameters of a Meijer's G function implicitly via the length of the lists. examples: ____________________________________________________________ load specfn2; MeijerG({{},1},{{0}},x); heaviside(-x+1) MeijerG({{}},{{1+1/4},1-1/4},(x^2)/4) * sqrt pi; 2 sqrt(2)*sin(x)*x ------------------ 4*sqrt(x) ____________________________________________________________ Many well-known functions can be written as G functions, e.g. exponentials, logarithms, trigonometric functions, Bessel functions and hypergeometric functions. The formulae can be found e.g. in A.P.Prudnikov, Yu.A.Brychkov, O.I.Marichev: Integrals and Series, Volume 3: More special functions, Gordon and Breach Science Publishers (1990). File: redhelp, Node: Heaviside, Next: erfi, Prev: MeijerG, Up: Miscellaneous section HEAVISIDE operator The HEAVISIDE operator returns the Heaviside function. Heaviside(~w) => if (w < 0) then 0 else 1 when numberp w; syntax: HEAVISIDE (<argument>) This operator is often included in the result of the simplification of a generalized [*note HYPERGEOMETRIC::.] function or a [*note MeijerG::.] function. No simplification is done for this function. File: redhelp, Node: erfi, Prev: Heaviside, Up: Miscellaneous section ERFI operator The ERFI operator returns the error function of an imaginary argument. erfi(~x) => 2/sqrt(pi) * defint(e**(t**2),t,0,x); syntax: ERFI (<argument>) This operator is sometimes included in the result of the simplification of a generalized [*note HYPERGEOMETRIC::.] function or a [*note MeijerG::.] function. No simplification is done for this function. File: redhelp, Node: Miscellaneous section, Prev: 3j and 6j symbols section, Up: Special Functions section Miscellaneous section * Menu: * HYPERGEOMETRIC:: operator * MeijerG:: operator * Heaviside:: operator * erfi:: operator File: redhelp, Node: Special Functions section, Next: Taylor series section, Prev: Roots Package section, Up: Top Special Functions section * Menu: * Special Function Package::introduction * Constants:: concept * Bernoulli Euler Zeta section:: * Bessel Functions section:: * Airy Functions section:: * Jacobi Elliptic Functions and Elliptic Integrals section:: * Gamma and Related Functions section:: * Miscellaneous Functions section:: * Orthogonal Polynomials section:: * Integral Functions section:: * Combinatorial Operators section:: * 3j and 6j symbols section:: * Miscellaneous section:: File: redhelp, Node: TAYLOR introduction, Next: taylor, Up: Taylor series section TAYLOR introduction This short note describes a package of REDUCE procedures that allow Taylor expansion in one or more variables and efficient manipulation of the resulting Taylor series. Capabilities include basic operations (addition, subtraction, multiplication and division) and also application of certain algebraic and transcendental functions. To a certain extent, Laurent expansion can be performed as well. File: redhelp, Node: taylor, Next: taylorautocombine, Prev: TAYLOR introduction, Up: Taylor series section TAYLOR operator The TAYLOR operator is used for expanding an expression into a Taylor series. syntax: TAYLOR (<expression> , <var>, <expression>, <number> , <var>, <expression>, <number>*) <expression> can be any valid REDUCE algebraic expression. <var> must be a [*note KERNEL::.] , and is the expansion variable. The <expression> following it denotes the point about which the expansion is to take place. <number> must be a non-negative integer and denotes the maximum expansion order. If more than one triple is specified TAYLOR will expand its first argument independently with respect to all the variables. Note that once the expansion has been done it is not possible to calculate higher orders. Instead of a [*note KERNEL::.] , <var> may also be a list of kernels. In this case expansion will take place in a way so that the sum/ of the degrees of the kernels does not exceed the maximum expansion order. If the expansion point evaluates to the special identifier INFINITY , TAYLOR tries to expand in a series in 1/<var>. The expansion is performed variable per variable, i.e. in the example above by first expanding exp(x^2+y^2) with respect to X and then expanding every coefficient with respect to Y . examples: ____________________________________________________________ taylor(e^(x^2+y^2),x,0,2,y,0,2); 2 2 2 2 2 2 1 + Y + X + Y *X + O(X ,Y ) taylor(e^(x^2+y^2),{x,y},0,2); 2 2 2 2 1 + Y + X + O({X ,Y }) ____________________________________________________________ The following example shows the case of a non-analytical function. ____________________________________________________________ taylor(x*y/(x+y),x,0,2,y,0,2); ***** Not a unit in argument to QUOTTAYLOR ____________________________________________________________ Note that it is not generally possible to apply the standard reduce operators to a Taylor kernel. For example, [*note PART::.] , [*note COEFF::.] , or [*note COEFFN::.] cannot be used. Instead, the expression at hand has to be converted to standard form first using the [*note taylortostandard::.] operator. Differentiation of a Taylor expression is possible. If you differentiate with respect to one of the Taylor variables the order will decrease by one. Substitution is a bit restricted: Taylor variables can only be replaced by other kernels. There is one exception to this rule: you can always substitute a Taylor variable by an expression that evaluates to a constant. Note that REDUCE will not always be able to determine that an expression is constant: an example is sin(acos(4)). Only simple taylor kernels can be integrated. More complicated expressions that contain Taylor kernels as parts of themselves are automatically converted into a standard representation by means of the [*note taylortostandard::.] operator. In this case a suitable warning is printed. File: redhelp, Node: taylorautocombine, Next: taylorautoexpand, Prev: taylor, Up: Taylor series section TAYLORAUTOCOMBINE switch If you set TAYLORAUTOCOMBINE to ON , REDUCE automatically combines Taylor expressions during the simplification process. This is equivalent to applying [*note taylorcombine::.] to every expression that contains Taylor kernels. Default is ON . File: redhelp, Node: taylorautoexpand, Next: taylorcombine, Prev: taylorautocombine, Up: Taylor series section TAYLORAUTOEXPAND switch TAYLORAUTOEXPAND makes Taylor expressions "contagious" in the sense that [*note taylorcombine::.] tries to Taylor expand all non-Taylor subexpressions and to combine the result with the rest. Default is OFF . File: redhelp, Node: taylorcombine, Next: taylorkeeporiginal, Prev: taylorautoexpand, Up: Taylor series section TAYLORCOMBINE operator This operator tries to combine all Taylor kernels found in its argument into one. Operations currently possible are: Addition, subtraction, multiplication, and division. Roots, exponentials, and logarithms. Trigonometric and hyperbolic functions and their inverses. examples: ____________________________________________________________ hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 taylorcombine log hugo; 3 X + O(X ) taylorcombine(hugo + x); 1 2 3 (1 + X + -*X + O(X )) + X 2 on taylorautoexpand; taylorcombine(hugo + x); 1 2 3 1 + 2*X + -*X + O(X ) 2 ____________________________________________________________ Application of unary operators like LOG and ATAN will nearly always succeed. For binary operations their arguments have to be Taylor kernels with the same template. This means that the expansion variable and the expansion point must match. Expansion order is not so important, different order usually means that one of them is truncated before doing the operation. If [*note taylorkeeporiginal::.] is set to ON and if all Taylor kernels in its argument have their original expressions kept TAYLORCOMBINE will also combine these and store the result as the original expression of the resulting Taylor kernel. There is also the switch [*note taylorautoexpand::.] . There are a few restrictions to avoid mathematically undefined expressions: it is not possible to take the logarithm of a Taylor kernel which has no terms (i.e. is zero), or to divide by such a beast. There are some provisions made to detect singularities during expansion: poles that arise because the denominator has zeros at the expansion point are detected and properly treated, i.e. the Taylor kernel will start with a negative power. (This is accomplished by expanding numerator and denominator separately and combining the results.) Essential singularities of the known functions (see above) are handled correctly. File: redhelp, Node: taylorkeeporiginal, Next: taylororiginal, Prev: taylorcombine, Up: Taylor series section TAYLORKEEPORIGINAL switch TAYLORKEEPORIGINAL , if set to ON , forces the [*note taylor::.] and all Taylor kernel manipulation operators to keep the original expression, i.e. the expression that was Taylor expanded. All operations performed on the Taylor kernels are also applied to this expression which can be recovered using the operator [*note taylororiginal::.] . Default is OFF . File: redhelp, Node: taylororiginal, Next: taylorprintorder, Prev: taylorkeeporiginal, Up: Taylor series section TAYLORORIGINAL operator Recovers the original expression (the one that was expanded) from the Taylor kernel that is given as its argument. syntax: TAYLORORIGINAL (<expression>) or TAYLORORIGINAL <simple_expression> examples: ____________________________________________________________ hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 taylororiginal hugo; ***** Taylor kernel doesn't have an original part in TAYLORORIGINAL on taylorkeeporiginal; hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 taylororiginal hugo; X E ____________________________________________________________ An error is signalled if the argument is not a Taylor kernel or if the original expression was not kept, i.e. if [*note taylorkeeporiginal::.] was set OFF during expansion. File: redhelp, Node: taylorprintorder, Next: taylorprintterms, Prev: taylororiginal, Up: Taylor series section TAYLORPRINTORDER switch TAYLORPRINTORDER , if set to ON , causes the remainder to be printed in big-O notation. Otherwise, three dots are printed. Default is ON . File: redhelp, Node: taylorprintterms, Next: taylorrevert, Prev: taylorprintorder, Up: Taylor series section TAYLORPRINTTERMS variable Only a certain number of (non-zero) coefficients are printed. If there are more, an expression of the form N TERMS is printed to indicate how many non-zero terms have been suppressed. The number of terms printed is given by the value of the shared algebraic variable TAYLORPRINTTERMS . Allowed values are integers and the special identifier ALL . The latter setting specifies that all terms are to be printed. The default setting is 5. examples: ____________________________________________________________ taylor(e^(x^2+y^2),x,0,4,y,0,4); 2 1 4 2 2 2 5 5 1 + Y + -*Y + X + Y *X + (4 terms) + O(X ,Y ) 2 taylorprintterms := all; TAYLORPRINTTERMS := ALL taylor(e^(x^2+y^2),x,0,4,y,0,4); 2 1 4 2 2 2 1 4 2 1 4 1 2 4 1 + Y + -*Y + X + Y *X + -*Y *X + -*X + -*Y *X 2 2 2 2 1 4 4 5 5 + -*Y *X + O(X ,Y ) 4 ____________________________________________________________ File: redhelp, Node: taylorrevert, Next: taylorseriesp, Prev: taylorprintterms, Up: Taylor series section TAYLORREVERT operator TAYLORREVERT allows reversion of a Taylor series of a function f, i.e., to compute the first terms of the expansion of the inverse of f from the expansion of f. syntax: TAYLORREVERT (<expression>, <var>, <var>) The first argument must evaluate to a Taylor kernel with the second argument being one of its expansion variables. examples: ____________________________________________________________ taylor(u - u**2,u,0,5); 2 6 U - U + O(U ) taylorrevert (ws,u,x); 2 3 4 5 6 X + X + 2*X + 5*X + 14*X + O(X ) ____________________________________________________________ File: redhelp, Node: taylorseriesp, Next: taylortemplate, Prev: taylorrevert, Up: Taylor series section TAYLORSERIESP operator This operator may be used to determine if its argument is a Taylor kernel. syntax: TAYLORSERIESP (<expression>) or TAYLORSERIESP <simple_expression> examples: ____________________________________________________________ hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 if taylorseriesp hugo then OK; OK if taylorseriesp(hugo + y) then OK else NO; NO ____________________________________________________________ Note that this operator is subject to the same restrictions as, e.g., ORDP or NUMBERP , i.e. it may only be used in boolean expressions in IF or LET statements. File: redhelp, Node: taylortemplate, Next: taylortostandard, Prev: taylorseriesp, Up: Taylor series section TAYLORTEMPLATE operator The template of a Taylor kernel, i.e. the list of all variables with respect to which expansion took place together with expansion point and order can be extracted using syntax: TAYLORTEMPLATE (<expression>) or TAYLORTEMPLATE <simple_expression> This returns a list of lists with the three elements (VAR,VAR0,ORDER). An error is signalled if the argument is not a Taylor kernel. examples: ____________________________________________________________ hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 taylortemplate hugo; {{X,0,2}} ____________________________________________________________ File: redhelp, Node: taylortostandard, Prev: taylortemplate, Up: Taylor series section TAYLORTOSTANDARD operator This operator converts all Taylor kernels in its argument into standard form and resimplifies the result. syntax: TAYLORTOSTANDARD (<expression>) or TAYLORTOSTANDARD <simple_expression> examples: ____________________________________________________________ hugo := taylor(exp(x),x,0,2); 1 2 3 HUGO := 1 + X + -*X + O(X ) 2 taylortostandard hugo; 2 X + 2*X + 2 ------------ 2 ____________________________________________________________ File: redhelp, Node: Taylor series section, Next: Gnuplot package section, Prev: Special Functions section, Up: Top Taylor series section * Menu: * TAYLOR introduction:: introduction * taylor:: operator * taylorautocombine:: switch * taylorautoexpand:: switch * taylorcombine:: operator * taylorkeeporiginal:: switch * taylororiginal:: operator * taylorprintorder:: switch * taylorprintterms:: variable * taylorrevert:: operator * taylorseriesp:: operator * taylortemplate:: operator * taylortostandard:: operator File: redhelp, Node: GNUPLOT and REDUCE, Next: Axes names, Up: Gnuplot package section GNUPLOT AND REDUCE introduction The GNUPLOT system provides easy to use graphics output for curves or surfaces which are defined by formulas and/or data sets. GNUPLOT supports a great variety of output devices such as X-windows, VGA screen, postscript, picTeX. The REDUCE GNUPLOT package lets one use the GNUPLOT graphical output directly from inside REDUCE, either for the interactive display of curves/surfaces or for the production of pictures on paper. Note that this package may not be supported on all system platforms. For a detailed description you should read the GNUPLOT system documentation, available together with the GNUPLOT installation material from several servers by anonymous FTP. The REDUCE developers thank the GNUPLOT people for their permission to distribute GNUPLOT together with REDUCE. File: redhelp, Node: Axes names, Next: Pointset, Prev: GNUPLOT and REDUCE, Up: Gnuplot package section AXES NAMES Inside REDUCE the choice of variable names for a graph is completely free. For referring to the GNUPLOT axes the names X and Y for 2 dimensions, X,Y and Z for 3 dimensions are used in the usual schoolbook sense independent from the variables of the REDUCE expression. examples: ____________________________________________________________ ____________________________________________________________ File: redhelp, Node: Pointset, Next: PLOT, Prev: Axes names, Up: Gnuplot package section POINTSET type A curve can be give as set of precomputed points (a polygon) in 2 or 3 dimensions. Such a point set is a [*note LIST::.] of points, where each point is a [*note LIST::.] 2 (or 3) numbers. These numbers are interpreted as (X,Y) (or X,Y,Z ) coordinates. All points of one set must have the same dimension. examples: ____________________________________________________________ ____________________________________________________________ Also a surface in 3d can be given by precomputed points, but only on a logically orthogonal mesh: the surface is defined by a list of curves (in 3d) which must have a uniform length. GNUPLOT then will draw an orthogonal mesh by first drawing the given lines, and second connecting the 1st point of the 1st curve with the 1st point of the 2nd curve, that one with the 1st point of the 3rd curve and so on for all curves and for all indexes. File: redhelp, Node: PLOT, Next: PLOTRESET, Prev: Pointset, Up: Gnuplot package section PLOT command The command PLOT is the main entry for drawing a picture from inside REDUCE. syntax: PLOT (<spec>,<spec>,...) where <spec> is a <function>, a <range> or an <option>. <function>: - an expression depending on one unknown (e.g. SIN(X) or two unknowns (e.g. SIN(X+Y) , - an equation with a function on its right-hand side and a single name on its left-hand side (e.g. Z=SIN(X+Y) where the name on the left-hand side specifies the dependent variable. - a list of functions: if in 2 dimensions the picture should have more than one curve the expressions can be given as list (e.g. [SIN(X),COS(X)] ). - an equation with zero left or right hand side describing an implicit curve in two dimensions (e.g. X**3+X*Y**3-9X=0 ). - a point set: the graph can be given as point set in 2 dimensions or a [*note Pointset::.] or pointset list in 3 dimensions. <range>: Each dependent and independent variable can be limited to an interval by an equation where the left-hand side specifies the variable and the right-hand side defines the [*note Interval::.] , e.g. X=( -3 .. 5) . If omitted the independent variables range from -10 to 10 and the dependent variable is limited only by the precision of the IEEE floating point arithmetic. <option>: An option can be an equation equating a variable and a value (in general a string), or a keyword(GNUPLOT switch). These have to be included in the gnuplot command arguments directly. Strings have to be enclosed in string quotes (see [*note STRING::.] ). Available options are: [*note title::.] : assign a heading (default: empty) [*note xlabel::.] : set label for the x axis [*note ylabel::.] : set label for the y axis [*note zlabel::.] : set label for the z axis [*note terminal::.] : select an output device [*note size::.] : rescale the picture [*note view::.] : set a viewpoint (NO) [*note contour::.] : 3d: add contour lines (NO) [*note surface::.] : 3d: draw surface (default: yes) (NO) [*note hidden3d::.] : 3d: remove hidden lines (default: no) examples: ____________________________________________________________ plot(cos x); plot(s=sin phi,phi=(-3 .. 3)); plot(sin phi,cos phi,phi=(-3 .. 3)); plot (cos sqrt(x**2 + y**2),x=(-3 .. 3),y=(-3 .. 3),hidden3d); plot {{0,0},{0,1},{1,1},{0,0},{1,0},{0,1},{0.5,1.5},{1,1},{1,0}}; on rounded; w:=for j:=1:200 collect {1/j*sin j,1/j*cos j,j/200}$ plot w; ____________________________________________________________ Additional control of the PLOT operation: [*note PLOTREFINE::.] , [*note plot_xmesh::.] , [*note plot_ymesh::.] , [*note TRPLOT::.] , [*note PLOTKEEP::.] , [*note SHOW_GRID::.] . File: redhelp, Node: PLOTRESET, Next: title, Prev: PLOT, Up: Gnuplot package section PLOTRESET command The command PLOTRESET closes the current GNUPLOT windows. The next call to [*note PLOT::.] will create a new one. PLOTRESET can also be used to reset the system status after technical problems. syntax: PLOTRESET ; File: redhelp, Node: title, Next: xlabel, Prev: PLOTRESET, Up: Gnuplot package section TITLE variable [*note PLOT::.] option: Assign a title to the GNUPLOT graph. syntax: TITLE = <string> examples: ____________________________________________________________ title="annual revenue in 1993" ____________________________________________________________ File: redhelp, Node: xlabel, Next: ylabel, Prev: title, Up: Gnuplot package section XLABEL variable [*note PLOT::.] option: Assign a name to to the x axis (see [*note Axes names::.] ). syntax: XLABEL = <string> examples: ____________________________________________________________ xlabel="month" ____________________________________________________________ File: redhelp, Node: ylabel, Next: zlabel, Prev: xlabel, Up: Gnuplot package section YLABEL variable [*note PLOT::.] option: Assign a name to to the x axis (see [*note Axes names::.] ). syntax: YLABEL = <string> examples: ____________________________________________________________ ylabel="million forint" ____________________________________________________________ File: redhelp, Node: zlabel, Next: terminal, Prev: ylabel, Up: Gnuplot package section ZLABEL variable [*note PLOT::.] option: Assign a name to to the z axis (see [*note Axes names::.] ). syntax: ZLABEL = <string> examples: ____________________________________________________________ zlabel="local weight" ____________________________________________________________ File: redhelp, Node: terminal, Next: size, Prev: zlabel, Up: Gnuplot package section TERMINAL variable [*note PLOT::.] option: Select a different output device. The possible values here depend highly on the facilities installed for your GNUPLOT software. syntax: TERMINAL = <string> examples: ____________________________________________________________ terminal="x11" ____________________________________________________________ File: redhelp, Node: size, Next: view, Prev: terminal, Up: Gnuplot package section SIZE variable [*note PLOT::.] option: Rescale the graph (not the window!) in x and y direction. Default is 1.0 (no rescaling). syntax: SIZE = "<sx>,<sy>" where <sx>,<sy> are floating point number not too far from 1.0. examples: ____________________________________________________________ size="0.7,1" ____________________________________________________________ File: redhelp, Node: view, Next: contour, Prev: size, Up: Gnuplot package section VIEW variable [*note PLOT::.] option: Set a new viewpoint by turning the object around the x and then around the z axis (see [*note Axes names::.] ). syntax: VIEW = "<sx>,<sz>" where <sx>,<sz> are floating point number representing angles in degrees. examples: ____________________________________________________________ view="30,130" ____________________________________________________________ File: redhelp, Node: contour, Next: surface, Prev: view, Up: Gnuplot package section CONTOUR switch [*note PLOT::.] option: If CONTOUR is member of the options for a 3d [*note PLOT::.] contour lines are projected to the z=0 plane (see [*note Axes names::.] ). The absence of contour lines can be selected explicitly by including NOCONTOUR . Default is NOCONTOUR . File: redhelp, Node: surface, Next: hidden3d, Prev: contour, Up: Gnuplot package section SURFACE switch [*note PLOT::.] option: If SURFACE is member of the options for a 3d [*note PLOT::.] the surface is drawn. The absence of the surface plotting can be selected by including NOSURFACE , e.g. if only the [*note contour::.] should be visualized. Default is SURFACE . File: redhelp, Node: hidden3d, Next: PLOTKEEP, Prev: surface, Up: Gnuplot package section HIDDEN3D switch [*note PLOT::.] option: If HIDDEN3D is member of the options for a 3d [*note PLOT::.] hidden lines are removed from the picture. Otherwise a surface is drawn as transparent object. Default is NOHIDDEN3D . Selecting HIDDEN3D increases the computing time substantially. File: redhelp, Node: PLOTKEEP, Next: PLOTREFINE, Prev: hidden3d, Up: Gnuplot package section PLOTKEEP switch Normally all intermediate data sets are deleted after terminating a plot session. If the switch PLOTKEEP is set [*note ON::.] , the data sets are kept for eventual post processing independent of REDUCE. File: redhelp, Node: PLOTREFINE, Next: plot_xmesh, Prev: PLOTKEEP, Up: Gnuplot package section PLOTREFINE switch In general [*note PLOT::.] tries to generate smooth pictures by evaluating the functions at interior points until the distances are fine enough. This can require a lot of computing time if the single function evaluation is expensive. The refinement is controlled by the switch PLOTREFINE which is [*note ON::.] by default. When you turn it [*note OFF::.] the functions will be evaluated only at the basic points (see [*note plot_xmesh::.] , [*note plot_ymesh::.] ). File: redhelp, Node: plot_xmesh, Next: plot_ymesh, Prev: PLOTREFINE, Up: Gnuplot package section PLOT_XMESH variable The integer value of the global variable PLOT_XMESH defines the number of initial function evaluations in x direction (see [*note Axes names::.] ) for [*note PLOT::.] . For 2d graphs additional points will be used as long as [*note PLOTREFINE::.] is ON . For 3d graphs this number defines also the number of mesh lines orthogonal to the x axis. File: redhelp, Node: plot_ymesh, Next: SHOW_GRID, Prev: plot_xmesh, Up: Gnuplot package section PLOT_YMESH variable The integer value of the global variable PLOT_YMESH defines for 3d [*note PLOT::.] calls the number of function evaluations in y direction (see [*note Axes names::.] ) and the number of mesh lines orthogonal to the y axis. File: redhelp, Node: SHOW_GRID, Next: TRPLOT, Prev: plot_ymesh, Up: Gnuplot package section SHOW_GRID switch The grid for localizing an implicitly defined curve in [*note PLOT::.] consists of triangles. These are computed initially equally distributed over the x-y plane controlled by [*note plot_xmesh::.] . The grid is refined adaptively in several levels. The final grid can be visualized by setting on the switch SHOW_GRID . File: redhelp, Node: TRPLOT, Prev: SHOW_GRID, Up: Gnuplot package section TRPLOT switch In general the interaction between REDUCE and GNUPLOT is performed as silently as possible. However, sometimes it might be useful to see the GNUPLOT commands generated by REDUCE, e.g. for a postprocessing of generated data sets independent of REDUCE. When the switch TRPLOT is set on all GNUPLOT commands will be printed to the standard output additionally. File: redhelp, Node: Gnuplot package section, Next: Linear Algebra package section, Prev: Taylor series section, Up: Top Gnuplot package section * Menu: * GNUPLOT and REDUCE:: introduction * Axes names:: concept * Pointset:: type * PLOT:: command * PLOTRESET:: command * title:: variable * xlabel:: variable * ylabel:: variable * zlabel:: variable * terminal:: variable * size:: variable * view:: variable * contour:: switch * surface:: switch * hidden3d:: switch * PLOTKEEP:: switch * PLOTREFINE:: switch * plot_xmesh:: variable * plot_ymesh:: variable * SHOW_GRID:: switch * TRPLOT:: switch File: redhelp, Node: Linear Algebra package, Next: fast_la, Up: Linear Algebra package section LINEAR ALGEBRA PACKAGE introduction This section briefly describes what's available in the Linear Algebra package. Note on examples: In the examples throughout this document, the matrix A will be ____________________________________________________________ [1 2 3] [4 5 6] [7 8 9]. ____________________________________________________________ The functions can be divided into four categories: Basic matrix handling [*note add_columns::.] , [*note add_rows::.] , [*note add_to_columns::.] , [*note add_to_rows::.] , [*note augment_columns::.] , [*note char_poly::.] , [*note column_dim::.] , [*note copy_into::.] , [*note diagonal::.] , [*note extend::.] , [*note find_companion::.] , [*note get_columns::.] , [*note get_rows::.] , [*note hermitian_tp::.] , [*note matrix_augment::.] , [*note matrix_stack::.] , [*note minor::.] , [*note mult_columns::.] , [*note mult_rows::.] , [*note pivot::.] , [*note remove_columns::.] , [*note remove_rows::.] , [*note row_dim::.] , [*note rows_pivot::.] , [*note stack_rows::.] , [*note sub_matrix::.] , [*note swap_columns::.] , [*note swap_entries::.] , [*note swap_rows::.] . Constructors - functions that create matrices [*note band_matrix::.] , [*note block_matrix::.] , [*note char_matrix::.] , [*note coeff_matrix::.] , [*note companion::.] , [*note hessian::.] , [*note hilbert::.] , [*note jacobian::.] , [*note jordan_block::.] , [*note make_identity::.] , [*note random_matrix::.] , [*note toeplitz::.] , [*note vandermonde::.] . High level algorithms [*note char_poly::.] , [*note cholesky::.] , [*note gram_schmidt::.] , [*note lu_decom::.] , [*note pseudo_inverse::.] , [*note simplex::.] , [*note svd::.] . Normal Forms There is a separate package, NORMFORM, for computing the following matrix normal forms in REDUCE: [*note Smithex::.] , [*note Smithex_int::.] , [*note Frobenius::.] , [*note Ratjordan::.] , [*note Jordansymbolic::.] , [*note Jordan::.] . Predicates [*note matrixp::.] , [*note squarep::.] , [*note symmetricp::.] . File: redhelp, Node: fast_la, Next: add_columns, Prev: Linear Algebra package, Up: Linear Algebra package section FAST_LA switch By turning the FAST_LA switch on, the speed of the following functions will be increased: [*note add_columns::.] , [*note add_rows::.] , [*note augment_columns::.] , [*note column_dim::.] , [*note copy_into::.] , [*note make_identity::.] , [*note matrix_augment::.] , [*note matrix_stack::.] , [*note minor::.] , [*note mult_columns::.] , [*note mult_rows::.] , [*note pivot::.] , [*note remove_columns::.] , [*note remove_rows::.] , [*note rows_pivot::.] , [*note squarep::.] , [*note stack_rows::.] , [*note sub_matrix::.] , [*note swap_columns::.] , [*note swap_entries::.] , [*note swap_rows::.] , [*note symmetricp::.] . The increase in speed will be negligible unless you are making a significant number (i.e. thousands) of calls. When using this switch, error checking is minimized. This means that illegal input may give strange error messages. Beware. File: redhelp, Node: add_columns, Next: add_rows, Prev: fast_la, Up: Linear Algebra package section ADD_COLUMNS operator Add columns, add rows: syntax: ADD_COLUMNS (<matrix>,<c1>,<c2>,<expr>) <matrix> :- a [*note MATRIX::.] . <c1>,<c2> :- positive integers. <expr> :- a scalar expression. The Operator ADD_COLUMNS replaces column <metac2> of <matrix> by <expr> * column(<matrix>,<c1>) + column(<matrix>,<c2>). ADD_ROWS performs the equivalent task on the rows of <matrix>. examples: ____________________________________________________________ add_columns(A,1,2,x); [1 x + 2 3] [ ] [4 4*x + 5 6] [ ] [7 7*x + 8 9] add_rows(A,2,3,5); [1 2 3 ] [ ] [4 5 6 ] [ ] [27 33 39] ____________________________________________________________ Related functions: [*note add_to_columns::.] , [*note add_to_rows::.] , [*note mult_columns::.] , [*note mult_rows::.] . File: redhelp, Node: add_rows, Next: add_to_columns, Prev: add_columns, Up: Linear Algebra package section ADD_ROWS operator see: [*note add_columns::.] . File: redhelp, Node: add_to_columns, Next: add_to_rows, Prev: add_rows, Up: Linear Algebra package section ADD_TO_COLUMNS operator Add to columns, add to rows: syntax: ADD_TO_COLUMNS (<matrix>,<column_list>,<expr>) <matrix> :- a matrix. <column_list> :- a positive integer or a list of positive integers. <expr> :- a scalar expression. ADD_TO_COLUMNS adds <expr> to each column specified in <column_list> of <matrix>. ADD_TO_ROWS performs the equivalent task on the rows of <matrix>. examples: ____________________________________________________________ add_to_columns(A,{1,2},10); [11 12 3] [ ] [14 15 6] [ ] [17 18 9] add_to_rows(A,2,-x) [ 1 2 3 ] [ ] [ - x + 4 - x + 5 - x + 6] [ ] [ 7 8 9 ] ____________________________________________________________ Related functions: [*note add_columns::.] , [*note add_rows::.] , [*note mult_rows::.] , [*note mult_columns::.] . File: redhelp, Node: add_to_rows, Next: augment_columns, Prev: add_to_columns, Up: Linear Algebra package section ADD_TO_ROWS operator see: [*note add_to_columns::.] . File: redhelp, Node: augment_columns, Next: band_matrix, Prev: add_to_rows, Up: Linear Algebra package section AUGMENT_COLUMNS operator Augment columns, stack rows: syntax: AUGMENT_COLUMNS (<matrix>,<column_list>) <matrix> :- a matrix. <column_list> :- either a positive integer or a list of positive integers. AUGMENT_COLUMNS gets hold of the columns of <matrix> specified in COLUMN_LIST and sticks them together. STACK_ROWS performs the same task on rows of <matrix>. examples: ____________________________________________________________ augment_columns(A,{1,2}) [1 2] [ ] [4 5] [ ] [7 8] stack_rows(A,{1,3}) [1 2 3] [ ] [7 8 9] ____________________________________________________________ Related functions: [*note get_columns::.] , [*note get_rows::.] , [*note sub_matrix::.] . File: redhelp, Node: band_matrix, Next: block_matrix, Prev: augment_columns, Up: Linear Algebra package section BAND_MATRIX operator syntax: BAND_MATRIX (<expr_list>,<square_size>) <expr_list> :- either a single scalar expression or a list of an odd number of scalar expressions. <square_size> :- a positive integer. BAND_MATRIX creates a square matrix of dimension <square_size>. The diagonal consists of the middle expression of the <expr_list>. The expressions to the left of this fill the required number of sub_diagonals and the expressions to the right the super_diagonals. examples: ____________________________________________________________ band_matrix({x,y,z},6) [y z 0 0 0 0] [ ] [x y z 0 0 0] [ ] [0 x y z 0 0] [ ] [0 0 x y z 0] [ ] [0 0 0 x y z] [ ] [0 0 0 0 x y] ____________________________________________________________ Related functions: [*note diagonal::.] . File: redhelp, Node: block_matrix, Next: char_matrix, Prev: band_matrix, Up: Linear Algebra package section BLOCK_MATRIX operator syntax: BLOCK_MATRIX (<r>,<c>,<matrix_list>) <r>,<c> :- positive integers. <matrix_list> :- a list of matrices. BLOCK_MATRIX creates a matrix that consists of <r> by <c> matrices filled from the <matrix_list> row wise. examples: ____________________________________________________________ B := make_identity(2); [1 0] b := [ ] [0 1] C := mat((5),(5)); [5] c := [ ] [5] D := mat((22,33),(44,55)); [22 33] d := [ ] [44 55] block_matrix(2,3,{B,C,D,D,C,B}); [1 0 5 22 33] [ ] [0 1 5 44 55] [ ] [22 33 5 1 0 ] [ ] [44 55 5 0 1 ] ____________________________________________________________ File: redhelp, Node: char_matrix, Next: char_poly, Prev: block_matrix, Up: Linear Algebra package section CHAR_MATRIX operator syntax: CHAR_MATRIX (<matrix>,<lambda>) <matrix> :- a square matrix. <lambda> :- a symbol or algebraic expression. <char_matrix> creates the characteristic matrix C of <matrix>. This is C = <lambda> * Id - A. Id is the identity matrix. examples: ____________________________________________________________ char_matrix(A,x); [x - 1 -2 -3 ] [ ] [ -4 x - 5 -6 ] [ ] [ -7 -8 x - 9] ____________________________________________________________ Related functions: [*note char_poly::.] . File: redhelp, Node: char_poly, Next: cholesky, Prev: char_matrix, Up: Linear Algebra package section CHAR_POLY operator syntax: CHAR_POLY (<matrix>,<lambda>) <matrix> :- a square matrix. <lambda> :- a symbol or algebraic expression. CHAR_POLY finds the characteristic polynomial of <matrix>. This is the determinant of <lambda> * Id - A. Id is the identity matrix. examples: ____________________________________________________________ char_poly(A,x); 3 2 x -15*x -18*x ____________________________________________________________ Related functions: [*note char_matrix::.] . File: redhelp, Node: cholesky, Next: coeff_matrix, Prev: char_poly, Up: Linear Algebra package section CHOLESKY operator syntax: CHOLESKY (<matrix>) <matrix> :- a positive definite matrix containing numeric entries. CHOLESKY computes the cholesky decomposition of <matrix>. It returns L,U where L is a lower matrix, U is an upper matrix, A = LU, and U = L^T. examples: ____________________________________________________________ F := mat((1,1,0),(1,3,1),(0,1,1)); [1 1 0] [ ] f := [1 3 1] [ ] [0 1 1] on rounded; cholesky(F); { [1 0 0 ] [ ] [1 1.41421356237 0 ] [ ] [0 0.707106781187 0.707106781187] , [1 1 0 ] [ ] [0 1.41421356237 0.707106781187] [ ] [0 0 0.707106781187] } ____________________________________________________________ Related functions: [*note lu_decom::.] . File: redhelp, Node: coeff_matrix, Next: column_dim, Prev: cholesky, Up: Linear Algebra package section COEFF_MATRIX operator syntax: COEFF_MATRIX (<lineq_list>) (If you are feeling lazy then the braces can be omitted.) <lineq_list> :- linear equations. Can be of the form equation = number or just equation. COEFF_MATRIX creates the coefficient matrix C of the linear equations. It returns C,X,B such that CX = B. examples: ____________________________________________________________ coeff_matrix({x+y+4*z=10,y+x-z=20,x+y+4}); { [4 1 1] [ ] [-1 1 1] [ ] [0 1 1] , [z] [ ] [y] [ ] [x] , [10] [ ] [20] [ ] [-4] } ____________________________________________________________ File: redhelp, Node: column_dim, Next: companion, Prev: coeff_matrix, Up: Linear Algebra package section COLUMN_DIM operator Column dimension, row dimension: syntax: COLUMN_DIM (<matrix>) <matrix> :- a matrix. COLUMN_DIM finds the column dimension of <matrix>. ROW_DIM finds the row dimension of <matrix>. examples: ____________________________________________________________ column_dim(A); 3 row_dim(A); 3 ____________________________________________________________ File: redhelp, Node: companion, Next: copy_into, Prev: column_dim, Up: Linear Algebra package section COMPANION operator syntax: COMPANION (<poly>,<x>) <poly> :- a monic univariate polynomial in <x>. <x> :- the variable. COMPANION creates the companion matrix C of <poly>. This is the square matrix of dimension n, where n is the degree of <poly> w.r.t. <x>. The entries of C are: C(i,n) = -coeffn(<poly>,<x>,i-1) for i = 1 ... n, C(i,i-1) = 1 for i = 2 ... n and the rest are 0. examples: ____________________________________________________________ companion(x^4+17*x^3-9*x^2+11,x); [0 0 0 -11] [ ] [1 0 0 0 ] [ ] [0 1 0 9 ] [ ] [0 0 1 -17] ____________________________________________________________ Related functions: [*note find_companion::.] . File: redhelp, Node: copy_into, Next: diagonal, Prev: companion, Up: Linear Algebra package section COPY_INTO operator syntax: COPY_INTO (<A>,<B>,<r>,<c>) <A>,<B> :- matrices. <r>,<c> :- positive integers. COPY_INTO copies matrix <matrix> into <B> with <matrix>(1,1) at <B>(<r>,<c>). examples: ____________________________________________________________ G := mat((0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0)); [0 0 0 0 0] [ ] [0 0 0 0 0] [ ] g := [0 0 0 0 0] [ ] [0 0 0 0 0] [ ] [0 0 0 0 0] copy_into(A,G,1,2); [0 1 2 3 0] [ ] [0 4 5 6 0] [ ] [0 7 8 9 0] [ ] [0 0 0 0 0] [ ] [0 0 0 0 0] ____________________________________________________________ Related functions: [*note augment_columns::.] , [*note extend::.] , [*note matrix_augment::.] , [*note matrix_stack::.] , [*note stack_rows::.] , [*note sub_matrix::.] . File: redhelp, Node: diagonal, Next: extend, Prev: copy_into, Up: Linear Algebra package section DIAGONAL operator syntax: DIAGONAL (<mat_list>) (If you are feeling lazy then the braces can be omitted.) <mat_list> :- each can be either a scalar expression or a square [*note MATRIX::.] . DIAGONAL creates a matrix that contains the input on the diagonal. examples: ____________________________________________________________ H := mat((66,77),(88,99)); [66 77] h := [ ] [88 99] diagonal({A,x,H}); [1 2 3 0 0 0 ] [ ] [4 5 6 0 0 0 ] [ ] [7 8 9 0 0 0 ] [ ] [0 0 0 x 0 0 ] [ ] [0 0 0 0 66 77] [ ] [0 0 0 0 88 99] ____________________________________________________________ Related functions: [*note jordan_block::.] . File: redhelp, Node: extend, Next: find_companion, Prev: diagonal, Up: Linear Algebra package section EXTEND operator syntax: EXTEND (<matrix>,<r>,<c>,<expr>) <matrix> :- a [*note MATRIX::.] . <r>,<c> :- positive integers. <expr> :- algebraic expression or symbol. EXTEND returns a copy of <matrix> that has been extended by <r> rows and <c> columns. The new entries are made equal to <expr>. examples: ____________________________________________________________ extend(A,1,2,x); [1 2 3 x x] [ ] [4 5 6 x x] [ ] [7 8 9 x x] [ ] [x x x x x] ____________________________________________________________ Related functions: [*note copy_into::.] , [*note matrix_augment::.] , [*note matrix_stack::.] , [*note remove_columns::.] , [*note remove_rows::.] . File: redhelp, Node: find_companion, Next: get_columns, Prev: extend, Up: Linear Algebra package section FIND_COMPANION operator syntax: FIND_COMPANION (<matrix>,<x>) <matrix> :- a [*note MATRIX::.] . <x> :- the variable. Given a companion matrix, FIND_COMPANION finds the polynomial from which it was made. examples: ____________________________________________________________ C := companion(x^4+17*x^3-9*x^2+11,x); [0 0 0 -11] [ ] [1 0 0 0 ] c := [ ] [0 1 0 9 ] [ ] [0 0 1 -17] find_companion(C,x); 4 3 2 x +17*x -9*x +11 ____________________________________________________________ Related functions: [*note companion::.] . File: redhelp, Node: get_columns, Next: get_rows, Prev: find_companion, Up: Linear Algebra package section GET_COLUMNS operator Get columns, get rows: syntax: GET_COLUMNS (<matrix>,<column_list>) <matrix> :- a [*note MATRIX::.] . <c> :- either a positive integer or a list of positive integers. GET_COLUMNS removes the columns of <matrix> specified in <column_list> and returns them as a list of column matrices. GET_ROWS performs the same task on the rows of <matrix>. examples: ____________________________________________________________ get_columns(A,{1,3}); { [1] [ ] [4] [ ] [7] , [3] [ ] [6] [ ] [9] } get_rows(A,2); { [4 5 6] } ____________________________________________________________ Related functions: [*note augment_columns::.] , [*note stack_rows::.] , [*note sub_matrix::.] . File: redhelp, Node: get_rows, Next: gram_schmidt, Prev: get_columns, Up: Linear Algebra package section GET_ROWS operator see: [*note get_columns::.] . File: redhelp, Node: gram_schmidt, Next: hermitian_tp, Prev: get_rows, Up: Linear Algebra package section GRAM_SCHMIDT operator syntax: GRAM_SCHMIDT (<vec_list>) (If you are feeling lazy then the braces can be omitted.) <vec_list> :- linearly independent vectors. Each vector must be written as a list, eg:1,0,0. GRAM_SCHMIDT performs the gram_schmidt orthonormalization on the input vectors. It returns a list of orthogonal normalized vectors. examples: ____________________________________________________________ gram_schmidt({{1,0,0},{1,1,0},{1,1,1}}); {{1,0,0},{0,1,0},{0,0,1}} gram_schmidt({{1,2},{3,4}}); 1 2 2*sqrt(5) -sqrt(5) {{ ------- , ------- },{ --------- , -------- }} sqrt(5) sqrt(5) 5 5 ____________________________________________________________ File: redhelp, Node: hermitian_tp, Next: hessian, Prev: gram_schmidt, Up: Linear Algebra package section HERMITIAN_TP operator syntax: HERMITIAN_TP (<matrix>) <matrix> :- a [*note MATRIX::.] . HERMITIAN_TP computes the hermitian transpose of <matrix>. This is a [*note MATRIX::.] in which the (i,j)'th entry is the conjugate of the (j,i)'th entry of <matrix>. examples: ____________________________________________________________ J := mat((i+1,i+2,i+3),(4,5,2),(1,i,0)); [i + 1 i + 2 i + 3] [ ] j := [ 4 5 2 ] [ ] [ 1 i 0 ] hermitian_tp(j); [ - i + 1 4 1 ] [ ] [ - i + 2 5 - i] [ ] [ - i + 3 2 0 ] ____________________________________________________________ Related functions: [*note TP::.] . File: redhelp, Node: hessian, Next: hilbert, Prev: hermitian_tp, Up: Linear Algebra package section HESSIAN operator syntax: HESSIAN (<expr>,<variable_list>) <expr> :- a scalar expression. <variable_list> :- either a single variable or a list of variables. HESSIAN computes the hessian matrix of <expr> w.r.t. the variables in <variable_list>. This is an n by n matrix where n is the number of variables and the (i,j)'th entry is [*note DF::.] (<expr>,<variable_list>(i), <variable_list>(j)). examples: ____________________________________________________________ hessian(x*y*z+x^2,{w,x,y,z}); [0 0 0 0] [ ] [0 2 z y] [ ] [0 z 0 x] [ ] [0 y x 0] ____________________________________________________________ Related functions: [*note DF::.] . File: redhelp, Node: hilbert, Next: jacobian, Prev: hessian, Up: Linear Algebra package section HILBERT operator syntax: HILBERT (<square_size>,<expr>) <square_size> :- a positive integer. <expr> :- an algebraic expression. HILBERT computes the square hilbert matrix of dimension <square_size>. This is the symmetric matrix in which the (i,j)'th entry is 1/(i+j-<expr>). examples: ____________________________________________________________ hilbert(3,y+x); [ - 1 - 1 - 1 ] [----------- ----------- -----------] [ x + y - 2 x + y - 3 x + y - 4 ] [ ] [ - 1 - 1 - 1 ] [----------- ----------- -----------] [ x + y - 3 x + y - 4 x + y - 5 ] [ ] [ - 1 - 1 - 1 ] [----------- ----------- -----------] [ x + y - 4 x + y - 5 x + y - 6 ] ____________________________________________________________ File: redhelp, Node: jacobian, Next: jordan_block, Prev: hilbert, Up: Linear Algebra package section JACOBIAN operator syntax: JACOBIAN (<expr_list>,<variable_list>) <expr_list> :- either a single algebraic expression or a list of algebraic expressions. <variable_list> :- either a single variable or a list of variables. JACOBIAN computes the jacobian matrix of <expr_list> w.r.t. <variable_list>. This is a matrix whose (i,j)'th entry is [*note DF::.] (<expr_list> (i),<variable_list>(j)). The matrix is n by m where n is the number of variables and m the number of expressions. examples: ____________________________________________________________ jacobian({x^4,x*y^2,x*y*z^3},{w,x,y,z}); [ 3 ] [0 4*x 0 0 ] [ ] [ 2 ] [0 y 2*x*y 0 ] [ ] [ 3 3 2] [0 y*z x*z 3*x*y*z ] ____________________________________________________________ Related functions: [*note hessian::.] , [*note DF::.] . File: redhelp, Node: jordan_block, Next: lu_decom, Prev: jacobian, Up: Linear Algebra package section JORDAN_BLOCK operator syntax: JORDAN_BLOCK (<expr>,<square_size>) <expr> :- an algebraic expression or symbol. <square_size> :- a positive integer. JORDAN_BLOCK computes the square jordan block matrix J of dimension <square_size>. The entries of J are: J(i,i) = <expr> for i=1 ... n, J(i,i+1) = 1 for i=1 ... n-1, and all other entries are 0. examples: ____________________________________________________________ jordan_block(x,5); [x 1 0 0 0] [ ] [0 x 1 0 0] [ ] [0 0 x 1 0] [ ] [0 0 0 x 1] [ ] [0 0 0 0 x] ____________________________________________________________ Related functions: [*note diagonal::.] , [*note companion::.] . File: redhelp, Node: lu_decom, Next: make_identity, Prev: jordan_block, Up: Linear Algebra package section LU_DECOM operator syntax: LU_DECOM (<matrix>) <matrix> :- a [*note MATRIX::.] containing either numeric entries or imaginary entries with numeric coefficients. LU_DECOM performs LU decomposition on <matrix>, ie: it returns L,U where L is a lower diagonal [*note MATRIX::.] , U an upper diagonal [*note MATRIX::.] and A = LU. Caution: The algorithm used can swap the rows of <matrix> during the calculation. This means that LU does not equal <matrix> but a row equivalent of it. Due to this, LU_DECOM returns L,U,vec. The call CONVERT(META[MATRIX ,vec) will return the matrix that has been decomposed, i.e: LU = convert(<matrix>,vec). examples: ____________________________________________________________ K := mat((1,3,5),(-4,3,7),(8,6,4)); [1 3 5] [ ] k := [-4 3 7] [ ] [8 6 4] on rounded; lu := lu_decom(K); lu := { [8 0 0 ] [ ] [-4 6.0 0 ] [ ] [1 2.25 1.125] , [1 0.75 0.5] [ ] [0 1 1.5] [ ] [0 0 1 ] , [3 2 3]} first lu * second lu; [8 6.0 4.0] [ ] [-4 3.0 7.0] [ ] [1 3.0 5.0] convert(K,third lu); P := mat((i+1,i+2,i+3),(4,5,2),(1,i,0)); [i + 1 i + 2 i + 3] [ ] p := [ 4 5 2 ] [ ] [ 1 i 0 ] lu := lu_decom(P); lu := { [ 1 0 0 ] [ ] [ 4 - 4*i + 5 0 ] [ ] [i + 1 3 0.414634146341*i + 2.26829268293] , [1 i 0 ] [ ] [0 1 0.19512195122*i + 0.243902439024] [ ] [0 0 1 ] , [3 2 3]} first lu * second lu; [ 1 i 0 ] [ ] [ 4 5 2.0 ] [ ] [i + 1 i + 2 i + 3.0] convert(P,third lu); [ 1 i 0 ] [ ] [ 4 5 2 ] [ ] [i + 1 i + 2 i + 3] ____________________________________________________________ Related functions: [*note cholesky::.] . File: redhelp, Node: make_identity, Next: matrix_augment, Prev: lu_decom, Up: Linear Algebra package section MAKE_IDENTITY operator syntax: MAKE_IDENTITY (<square_size>) <square_size> :- a positive integer. MAKE_IDENTITY creates the identity matrix of dimension <square_size>. examples: ____________________________________________________________ make_identity(4); [1 0 0 0] [ ] [0 1 0 0] [ ] [0 0 1 0] [ ] [0 0 0 1] ____________________________________________________________ Related functions: [*note diagonal::.] . File: redhelp, Node: matrix_augment, Next: matrixp, Prev: make_identity, Up: Linear Algebra package section 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_AUGMENT sticks the matrices in <matrix_list> together horizontally. MATRIX_STACK sticks 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: [*note augment_columns::.] , [*note stack_rows::.] , [*note sub_matrix::.] . File: redhelp, Node: matrixp, Next: matrix_stack, Prev: matrix_augment, Up: Linear Algebra package section MATRIXP operator syntax: MATRIXP (<test_input>) <test_input> :- anything you like. MATRIXP is a boolean function that returns t if the input is a matrix and nil otherwise. examples: ____________________________________________________________ matrixp A; t matrixp(doodlesackbanana); nil ____________________________________________________________ Related functions: [*note squarep::.] , [*note symmetricp::.] . File: redhelp, Node: matrix_stack, Next: minor, Prev: matrixp, Up: Linear Algebra package section MATRIX_STACK operator see: [*note matrix_augment::.] . File: redhelp, Node: minor, Next: mult_columns, Prev: matrix_stack, Up: Linear Algebra package section MINOR operator syntax: MINOR (<matrix>,<r>,<c>) <matrix> :- a [*note 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>. examples: ____________________________________________________________ minor(A,1,3); [4 5] [ ] [7 8] ____________________________________________________________ Related functions: [*note remove_columns::.] , [*note remove_rows::.] . File: redhelp, Node: mult_columns, Next: mult_rows, Prev: minor, Up: Linear Algebra package section MULT_COLUMNS operator Mult columns, mult rows: syntax: MULT_COLUMNS (<matrix>,<column_list>,<expr>) <matrix> :- a [*note 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>. 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: [*note add_to_columns::.] , [*note add_to_rows::.] . File: redhelp, Node: mult_rows, Next: pivot, Prev: mult_columns, Up: Linear Algebra package section MULT_ROWS operator see: [*note mult_columns::.] . File: redhelp, Node: pivot, Next: pseudo_inverse, Prev: mult_rows, Up: Linear Algebra package section PIVOT operator syntax: PIVOT (<matrix>,<r>,<c>) <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. examples: ____________________________________________________________ pivot(A,2,3); [ - 1 ] [-1 ------ 0] [ 2 ] [ ] [4 5 6] [ ] [ 1 ] [1 --- 0] [ 2 ] ____________________________________________________________ Related functions: [*note rows_pivot::.] . File: redhelp, Node: pseudo_inverse, Next: random_matrix, Prev: pivot, Up: Linear Algebra package section PSEUDO_INVERSE operator syntax: PSEUDO_INVERSE (<matrix>) <matrix> :- a [*note 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: [*note svd::.] . File: redhelp, Node: random_matrix, Next: remove_columns, Prev: pseudo_inverse, Up: Linear Algebra package section RANDOM_MATRIX operator syntax: RANDOM_MATRIX (<r>,<c>,<limit>) <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 imaginary 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 ] ____________________________________________________________ File: redhelp, Node: remove_columns, Next: remove_rows, Prev: random_matrix, Up: Linear Algebra package section REMOVE_COLUMNS operator Remove columns, remove rows: syntax: REMOVE_COLUMNS (<matrix>,<column_list>) <matrix> :- a [*note 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>. examples: ____________________________________________________________ remove_columns(A,2); [1 3] [ ] [4 6] [ ] [7 9] remove_rows(A,{1,3}); [4 5 6] ____________________________________________________________ Related functions: [*note minor::.] . File: redhelp, Node: remove_rows, Next: row_dim, Prev: remove_columns, Up: Linear Algebra package section REMOVE_ROWS operator see: [*note remove_columns::.] . File: redhelp, Node: row_dim, Next: rows_pivot, Prev: remove_rows, Up: Linear Algebra package section ROW_DIM operator see: [*note column_dim::.] . File: redhelp, Node: rows_pivot, Next: simplex, Prev: row_dim, Up: Linear Algebra package section 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_PIVOT performs 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: [*note pivot::.] . File: redhelp, Node: simplex, Next: squarep, Prev: rows_pivot, Up: Linear Algebra package section 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. 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. 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}} ____________________________________________________________ File: redhelp, Node: squarep, Next: stack_rows, Prev: simplex, Up: Linear Algebra package section SQUAREP operator syntax: SQUAREP (<matrix>) <matrix> :- a [*note MATRIX::.] . SQUAREP is 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: [*note matrixp::.] , [*note symmetricp::.] . File: redhelp, Node: stack_rows, Next: sub_matrix, Prev: squarep, Up: Linear Algebra package section STACK_ROWS operator see: [*note augment_columns::.] . File: redhelp, Node: sub_matrix, Next: svd, Prev: stack_rows, Up: Linear Algebra package section 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: [*note augment_columns::.] , [*note stack_rows::.] . File: redhelp, Node: svd, Next: swap_columns, Prev: sub_matrix, Up: Linear Algebra package section SVD operator Singular value decomposition: syntax: SVD (<matrix>) <matrix> :- a [*note 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. 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] } ____________________________________________________________ File: redhelp, Node: swap_columns, Next: swap_entries, Prev: svd, Up: Linear Algebra package section SWAP_COLUMNS operator Swap columns, swap rows: syntax: SWAP_COLUMNS (<matrix>,<c1>,<c2>) <matrix> :- a [*note 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>. 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: [*note swap_entries::.] . File: redhelp, Node: swap_entries, Next: swap_rows, Prev: swap_columns, Up: Linear Algebra package section SWAP_ENTRIES operator syntax: SWAP_ENTRIES (<matrix>,<r1>,<c1>,<r2>, <c2>) <matrix> :- a [*note MATRIX::.] . <r1>,<c1>,<r2>,<c2> :- positive integers. SWAP_ENTRIES swaps <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: [*note swap_columns::.] , [*note swap_rows::.] . File: redhelp, Node: swap_rows, Next: symmetricp, Prev: swap_entries, Up: Linear Algebra package section SWAP_ROWS operator see: [*note swap_columns::.] . File: redhelp, Node: symmetricp, Next: toeplitz, Prev: swap_rows, Up: Linear Algebra package section SYMMETRICP operator syntax: SYMMETRICP (<matrix>) <matrix> :- a [*note MATRIX::.] . SYMMETRICP is a predicate that returns t if the matrix is symmetric and nil otherwise. examples: ____________________________________________________________ symmetricp(make_identity(11)); t symmetricp(A); nil ____________________________________________________________ Related functions: [*note matrixp::.] , [*note squarep::.] . File: redhelp, Node: toeplitz, Next: vandermonde, Prev: symmetricp, Up: Linear Algebra package section TOEPLITZ operator syntax: TOEPLITZ (<expr_list>) (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. examples: ____________________________________________________________ toeplitz({w,x,y,z}); [w x y z] [ ] [x w x y] [ ] [y x w x] [ ] [z y x w] ____________________________________________________________ File: redhelp, Node: vandermonde, Prev: toeplitz, Up: Linear Algebra package section VANDERMONDE operator syntax: VANDERMONDE (<expr_list>) (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. examples: ____________________________________________________________ vandermonde({x,2*y,3*z}); [ 2 ] [1 x x ] [ ] [ 2] [1 2*y 4*y ] [ ] [ 2] [1 3*z 9*z ] ____________________________________________________________ File: redhelp, Node: Linear Algebra package section, Next: Matrix Normal Forms section, Prev: Gnuplot package section, Up: Top Linear Algebra package section * Menu: * 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 File: redhelp, Node: Smithex, Next: Smithex_int, Up: Matrix Normal Forms section SMITHEX operator The operator SMITHEX computes the Smith normal form S of a [*note MATRIX::.] A (say). It returns S,P,P^-1 where P*S*P^-1 = A. syntax: SMITHEX (<matrix>,<variable>) <matrix> :- a rectangular [*note 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 ] ____________________________________________________________ File: redhelp, Node: Smithex_int, Next: Frobenius, Prev: Smithex, Up: Matrix Normal Forms section 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 [*note MATRIX::.] (A say), and P*S*P^-1 = A. syntax: SMITHEX_INT (<matrix>) <matrix> :- a rectangular [*note 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 ] ____________________________________________________________ File: redhelp, Node: Frobenius, Next: Ratjordan, Prev: Smithex_int, Up: Matrix Normal Forms section FROBENIUS operator The operator FROBENIUS computes the FROBENIUS normal form F of a [*note MATRIX::.] (A say). It returns F,P,P^-1 where P*F*P^-1 = A. syntax: FROBENIUS (<matrix>) <matrix> :- a square [*note MATRIX::.] . Field Extensions: By default, calculations are performed in the rational numbers. To extend this field the [*note 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 [*note 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 ] ____________________________________________________________ File: redhelp, Node: Ratjordan, Next: Jordansymbolic, Prev: Frobenius, Up: Matrix Normal Forms section RATJORDAN operator The operator RATJORDAN computes the rational Jordan normal form R of a [*note MATRIX::.] (A say). It returns R,P,P^-1 where P*R*P^-1 = A. syntax: RATJORDAN (<matrix>) <matrix> :- a square [*note 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 [*note 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. 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 ] ____________________________________________________________ File: redhelp, Node: Jordansymbolic, Next: Jordan, Prev: Ratjordan, Up: Matrix Normal Forms section JORDANSYMBOLIC operator The operator JORDANSYMBOLIC computes the Jordan normal form J of a [*note 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 [*note MATRIX::.] . Field Extensions: By default, calculations are performed in the rational numbers. To extend this field the [*note 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 [*note 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 [*note 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) ] } ____________________________________________________________ File: redhelp, Node: Jordan, Prev: Jordansymbolic, Up: Matrix Normal Forms section JORDAN operator The operator JORDAN computes the Jordan normal form J of a [*note MATRIX::.] (A say). It returns J,P,P^-1 where P*J*P^-1 = A. syntax: JORDAN (<matrix>) <matrix> :- a square [*note 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 [*note 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 [*note 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] } ____________________________________________________________ File: redhelp, Node: Matrix Normal Forms section, Next: Miscellaneous Packages section, Prev: Linear Algebra package section, Up: Top Matrix Normal Forms section * Menu: * Smithex:: operator * Smithex_int:: operator * Frobenius:: operator * Ratjordan:: operator * Jordansymbolic:: operator * Jordan:: operator File: redhelp, Node: Miscellaneous Packages, Next: ALGINT package, Up: Miscellaneous Packages section 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 [*note 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. File: redhelp, Node: ALGINT package, Next: APPLYSYM, Prev: Miscellaneous Packages, Up: Miscellaneous Packages section 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 [*note 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 [*note ALGINT::.] off. An error message is given if you try to turn the [*note ALGINT::.] switch on when its package is not loaded. File: redhelp, Node: APPLYSYM, Next: ARNUM, Prev: ALGINT package, Up: Miscellaneous Packages section APPLYSYM package Author: Thomas Wolf This package provides programs APPLYSYM, QUASILINPDE and DETRAFO for computing with infinitesimal symmetries of differential equations. File: redhelp, Node: ARNUM, Next: ASSIST, Prev: APPLYSYM, Up: Miscellaneous Packages section 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. File: redhelp, Node: ASSIST, Next: AVECTOR, Prev: ARNUM, Up: Miscellaneous Packages section 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. File: redhelp, Node: AVECTOR, Next: BOOLEAN, Prev: ASSIST, Up: Miscellaneous Packages section 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. File: redhelp, Node: BOOLEAN, Next: CALI, Prev: AVECTOR, Up: Miscellaneous Packages section 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. File: redhelp, Node: CALI, Next: CAMAL, Prev: BOOLEAN, Up: Miscellaneous Packages section 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. File: redhelp, Node: CAMAL, Next: CHANGEVR, Prev: CALI, Up: Miscellaneous Packages section CAMAL package Author: John P. Fitch This packages implements in REDUCE the Fourier transform procedures of the CAMAL package for celestial mechanics. File: redhelp, Node: CHANGEVR, Next: COMPACT, Prev: CAMAL, Up: Miscellaneous Packages section 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. File: redhelp, Node: COMPACT, Next: CONTFR, Prev: CHANGEVR, Up: Miscellaneous Packages section 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. File: redhelp, Node: CONTFR, Next: CRACK, Prev: COMPACT, Up: Miscellaneous Packages section CONTFR package Author: Herbert Melenk This package provides for the simultaneous approximation of a real number by a continued fraction and a rational number with optional user controlled precision (an upper bound for the denominator). To use this package, the MISC package should be loaded. One can then use the operator CONTINUED_FRACTION to approximate the real number by a continued fraction. This operator has one or two arguments, the number to be converted and an optional precision. The result is a list of two elements: the first is the rational value of the approximation and the second the list of terms of the continued fraction that represent the same value according to the definition t0 +1/(t1 + 1/(t2 + ...)). The second optional parameter SIZE is an upper bound on the absolute value of the result denominator. If omitted, the approximation is performed up to the current system precision. examples: ____________________________________________________________ continued_fraction pi; 1146408 {---------,{3,7,15,1,292,1,1,1,2,1}} 364913 continued_fraction(pi,100); 22 {----,{3,7}} 7 ____________________________________________________________ File: redhelp, Node: CRACK, Next: CVIT, Prev: CONTFR, Up: Miscellaneous Packages section 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. File: redhelp, Node: CVIT, Next: DEFINT, Prev: CRACK, Up: Miscellaneous Packages section 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. File: redhelp, Node: DEFINT, Next: DESIR, Prev: CVIT, Up: Miscellaneous Packages section 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. File: redhelp, Node: DESIR, Next: DFPART, Prev: DEFINT, Up: Miscellaneous Packages section 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). File: redhelp, Node: DFPART, Next: DUMMY, Prev: DESIR, Up: Miscellaneous Packages section 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. File: redhelp, Node: DUMMY, Next: EXCALC, Prev: DFPART, Up: Miscellaneous Packages section 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. File: redhelp, Node: EXCALC, Next: FPS, Prev: DUMMY, Up: Miscellaneous Packages section 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. File: redhelp, Node: FPS, Next: FIDE, Prev: EXCALC, Up: Miscellaneous Packages section FPS package Authors: Wolfram Koepf, Winfried Neun This package can expand a specific class of functions into their corresponding Laurent-Puiseux series. File: redhelp, Node: FIDE, Next: GENTRAN, Prev: FPS, Up: Miscellaneous Packages section FIDE package Author: Richard Liska This package performs automation of the process of numerically solving partial differential equations systems (PDES) by means of computer algebra. For PDES solving, the finite difference method is applied. The computer algebra system REDUCE and the numerical programming language FORTRAN are used in the presented methodology. The main aim of this methodology is to speed up the process of preparing numerical programs for solving PDES. This process is quite often, especially for complicated systems, a tedious and time consuming task. File: redhelp, Node: GENTRAN, Next: IDEALS, Prev: FIDE, Up: Miscellaneous Packages section GENTRAN package Author: Barbara L. Gates This package is an automatic code GENerator and TRANslator. It constructs complete numerical programs based on sets of algorithmic specifications and symbolic expressions. Formatted FORTRAN, RATFOR or C code can be generated through a series of interactive commands or under the control of a template processing routine. Large expressions can be automatically segmented into subexpressions of manageable size, and a special file-handling mechanism maintains stacks of open I/O channels to allow output to be sent to any number of files simultaneously and to facilitate recursive invocation of the whole code generation process. File: redhelp, Node: IDEALS, Next: INEQ, Prev: GENTRAN, Up: Miscellaneous Packages section IDEALS package Author: Herbert Melenk This package implements the basic arithmetic for polynomial ideals by exploiting the Groebner bases package of REDUCE. In order to save computing time all intermediate Groebner bases are stored internally such that time consuming repetitions are inhibited. File: redhelp, Node: INEQ, Next: INVBASE, Prev: IDEALS, Up: Miscellaneous Packages section INEQ package Author: Herbert Melenk This package supports the operator INEQ_SOLVE that tries to solves single inequalities and sets of coupled inequalities. File: redhelp, Node: INVBASE, Next: LAPLACE, Prev: INEQ, Up: Miscellaneous Packages section INVBASE package Authors: A.Yu. Zharkov and Yu.A. Blinkov Involutive bases are a new tool for solving problems in connection with multivariate polynomials, such as solving systems of polynomial equations and analyzing polynomial ideals. An involutive basis of polynomial ideal is nothing but a special form of a redundant Groebner basis. The construction of involutive bases reduces the problem of solving polynomial systems to simple linear algebra. File: redhelp, Node: LAPLACE, Next: LIE, Prev: INVBASE, Up: Miscellaneous Packages section LAPLACE package Authors: C. Kazasov, M. Spiridonova, V. Tomov This package can calculate ordinary and inverse Laplace transforms of expressions. Documentation is in plain text. File: redhelp, Node: LIE, Next: MODSR, Prev: LAPLACE, Up: Miscellaneous Packages section LIE package Authors: Carsten and Franziska Sch"obel LIE is a package of functions for the classification of real n-dimensional Lie algebras. It consists of two modules: LIENDMC1 and LIE1234 . With the help of the functions in the LIENDMCL module, real n-dimensional Lie algebras L with a derived algebra L^(1) of dimension 1 can be classified. File: redhelp, Node: MODSR, Next: NCPOLY, Prev: LIE, Up: Miscellaneous Packages section MODSR package Author: Herbert Melenk This package supports solve (M_SOLVE) and roots (M_ROOTS) operators for modular polynomials and modular polynomial systems. The moduli need not be primes. M_SOLVE requires a modulus to be set. M_ROOTS takes the modulus as a second argument. For example: ____________________________________________________________ on modular; setmod 8; m_solve(2x=4); -> {{X=2},{X=6}} m_solve({x^2-y^3=3}); -> {{X=0,Y=5}, {X=2,Y=1}, {X=4,Y=5}, {X=6,Y=1}} m_solve({x=2,x^2-y^3=3}); -> {{X=2,Y=1}} off modular; m_roots(x^2-1,8); -> {1,3,5,7} m_roots(x^3-x,7); -> {0,1,6} ____________________________________________________________ File: redhelp, Node: NCPOLY, Next: ORTHOVEC, Prev: MODSR, Up: Miscellaneous Packages section NCPOLY package Authors: Herbert Melenk, Joachim Apel This package allows the user to set up automatically a consistent environment for computing in an algebra where the non-commutativity is defined by Lie-bracket commutators. The package uses the REDUCE NONCOM mechanism for elementary polynomial arithmetic; the commutator rules are automatically computed from the Lie brackets. File: redhelp, Node: ORTHOVEC, Next: PHYSOP, Prev: NCPOLY, Up: Miscellaneous Packages section ORTHOVEC package Author: James W. Eastwood ORTHOVEC is a collection of REDUCE procedures and operations which provide a simple-to-use environment for the manipulation of scalars and vectors. Operations include addition, subtraction, dot and cross products, division, modulus, div, grad, curl, laplacian, differentiation, integration, and Taylor expansion. File: redhelp, Node: PHYSOP, Next: PM, Prev: ORTHOVEC, Up: Miscellaneous Packages section PHYSOP package Author: Mathias Warns This package has been designed to meet the requirements of theoretical physicists looking for a computer algebra tool to perform complicated calculations in quantum theory with expressions containing operators. These operations consist mainly of the calculation of commutators between operator expressions and in the evaluations of operator matrix elements in some abstract space. File: redhelp, Node: PM, Next: RANDPOLY, Prev: PHYSOP, Up: Miscellaneous Packages section PM package Author: Kevin McIsaac PM is a general pattern matcher similar in style to those found in systems such as SMP and Mathematica, and is based on the pattern matcher described in Kevin McIsaac, "Pattern Matching Algebraic Identities", SIGSAM Bulletin, 19 (1985), 4-13. File: redhelp, Node: RANDPOLY, Next: REACTEQN, Prev: PM, Up: Miscellaneous Packages section RANDPOLY package Author: Francis J. Wright This package is based on a port of the Maple random polynomial generator together with some support facilities for the generation of random numbers and anonymous procedures. File: redhelp, Node: REACTEQN, Next: RESET, Prev: RANDPOLY, Up: Miscellaneous Packages section REACTEQN package Author: Herbert Melenk This package allows a user to transform chemical reaction systems into ordinary differential equation systems (ODE) corresponding to the laws of pure mass action. File: redhelp, Node: RESET, Next: RESIDUE, Prev: REACTEQN, Up: Miscellaneous Packages section RESET package Author: John Fitch This package defines a command command RESETREDUCE that works through the history of previous commands, and clears any values which have been assigned, plus any rules, arrays and the like. It also sets the various switches to their initial values. It is not complete, but does work for most things that cause a gradual loss of space. It would be relatively easy to make it interactive, so allowing for selective resetting. File: redhelp, Node: RESIDUE, Next: RLFI, Prev: RESET, Up: Miscellaneous Packages section RESIDUE package Author: Wolfram Koepf This package supports the calculation of residues of arbitrary expressions. File: redhelp, Node: RLFI, Next: SCOPE, Prev: RESIDUE, Up: Miscellaneous Packages section RLFI package Author: Richard Liska This package adds LaTeX syntax to REDUCE. Text generated by REDUCE in this mode can be directly used in LaTeX source documents. Various mathematical constructions are supported by the interface including subscripts, superscripts, font changing, Greek letters, divide-bars, integral and sum signs, derivatives, and so on. File: redhelp, Node: SCOPE, Next: SETS, Prev: RLFI, Up: Miscellaneous Packages section SCOPE package Author: J.A. van Hulzen SCOPE is a package for the production of an optimized form of a set of expressions. It applies an heuristic search for common (sub)expressions to almost any set of proper REDUCE assignment statements. The output is obtained as a sequence of assignment statements. GENTRAN is used to facilitate expression output. File: redhelp, Node: SETS, Next: SPDE, Prev: SCOPE, Up: Miscellaneous Packages section SETS package Author: Francis J. Wright The SETS package provides algebraic-mode support for set operations on lists regarded as sets (or representing explicit sets) and on implicit sets represented by identifiers. File: redhelp, Node: SPDE, Next: SYMMETRY, Prev: SETS, Up: Miscellaneous Packages section SPDE package Author: Fritz Schwartz The package SPDE provides a set of functions which may be used to determine the symmetry group of Lie- or point-symmetries of a given system of partial differential equations. In many cases the determining system is solved completely automatically. In other cases the user has to provide additional input information for the solution algorithm to terminate. File: redhelp, Node: SYMMETRY, Next: TPS, Prev: SPDE, Up: Miscellaneous Packages section SYMMETRY package Author: Karin Gatermann This package computes symmetry-adapted bases and block diagonal forms of matrices which have the symmetry of a group. The package is the implementation of the theory of linear representations for small finite groups such as the dihedral groups. File: redhelp, Node: TPS, Next: TRI, Prev: SYMMETRY, Up: Miscellaneous Packages section TPS package Authors: Alan Barnes, Julian Padget This package implements formal Laurent series expansions in one variable using the domain mechanism of REDUCE. This means that power series objects can be added, multiplied, differentiated etc., like other first class objects in the system. A lazy evaluation scheme is used and thus terms of the series are not evaluated until they are required for printing or for use in calculating terms in other power series. The series are extendible giving the user the impression that the full infinite series is being manipulated. The errors that can sometimes occur using series that are truncated at some fixed depth (for example when a term in the required series depends on terms of an intermediate series beyond the truncation depth) are thus avoided. File: redhelp, Node: TRI, Next: TRIGSIMP, Prev: TPS, Up: Miscellaneous Packages section TRI package Author: Werner Antweiler This package provides facilities written in REDUCE-Lisp for typesetting REDUCE formulas using TeX. The TeX-REDUCE-Interface incorporates three levels of TeX output: without line breaking, with line breaking, and with line breaking plus indentation. File: redhelp, Node: TRIGSIMP, Next: XCOLOR, Prev: TRI, Up: Miscellaneous Packages section TRIGSIMP package Author: Wolfram Koepf TRIGSIMP is a useful tool for all kinds of trigonometric and hyperbolic simplification and factorization. There are three procedures included in TRIGSIMP: TRIGSIMP , TRIGFACTORIZE and TRIGGCD . The first is for finding simplifications of trigonometric or hyperbolic expressions with many options, the second for factorizing them and the third for finding the greatest common divisor of two trigonometric or hyperbolic polynomials. File: redhelp, Node: XCOLOR, Next: XIDEAL, Prev: TRIGSIMP, Up: Miscellaneous Packages section XCOLOR package Author: A. Kryukov This package calculates the color factor in non-abelian gauge field theories using an algorithm due to Cvitanovich. File: redhelp, Node: XIDEAL, Next: WU, Prev: XCOLOR, Up: Miscellaneous Packages section XIDEAL package Author: David Hartley XIDEAL constructs Groebner bases for solving the left ideal membership problem: Groebner left ideal bases or GLIBs. For graded ideals, where each form is homogeneous in degree, the distinction between left and right ideals vanishes. Furthermore, if the generating forms are all homogeneous, then the Groebner bases for the non-graded and graded ideals are identical. In this case, XIDEAL is able to save time by truncating the Groebner basis at some maximum degree if desired. File: redhelp, Node: WU, Next: ZEILBERG, Prev: XIDEAL, Up: Miscellaneous Packages section WU package Author: Russell Bradford This is a simple implementation of the Wu algorithm implemented in REDUCE working directly from "A Zero Structure Theorem for Polynomial-Equations-Solving," Wu Wen-tsun, Institute of Systems Science, Academia Sinica, Beijing. File: redhelp, Node: ZEILBERG, Next: ZTRANS, Prev: WU, Up: Miscellaneous Packages section ZEILBERG package Authors: Gregor St"olting and Wolfram Koepf This package is a careful implementation of the Gosper and Zeilberger algorithms for indefinite and definite summation of hypergeometric terms, respectively. Extensions of these algorithms are also included that are valid for ratios of products of powers, factorials, gamma function terms, binomial coefficients, and shifted factorials that are rational-linear in their arguments. File: redhelp, Node: ZTRANS, Prev: ZEILBERG, Up: Miscellaneous Packages section ZTRANS package Authors: Wolfram Koepf, Lisa Temme This package is an implementation of the Z-transform of a sequence. This is the discrete analogue of the Laplace Transform. File: redhelp, Node: Miscellaneous Packages section, Next: Outmoded Operations section, Prev: Matrix Normal Forms section, Up: Top Miscellaneous Packages section * Menu: * Miscellaneous Packages:: introduction * ALGINT package:: package * APPLYSYM:: package * ARNUM:: package * ASSIST:: package * AVECTOR:: package * BOOLEAN:: package * CALI:: package * CAMAL:: package * CHANGEVR:: package * COMPACT:: package * CONTFR:: package * CRACK:: package * CVIT:: package * DEFINT:: package * DESIR:: package * DFPART:: package * DUMMY:: package * EXCALC:: package * FPS:: package * FIDE:: package * GENTRAN:: package * IDEALS:: package * INEQ:: package * INVBASE:: package * LAPLACE:: package * LIE:: package * MODSR:: package * NCPOLY:: package * ORTHOVEC:: package * PHYSOP:: package * PM:: package * RANDPOLY:: package * REACTEQN:: package * RESET:: package * RESIDUE:: package * RLFI:: package * SCOPE:: package * SETS:: package * SPDE:: package * SYMMETRY:: package * TPS:: package * TRI:: package * TRIGSIMP:: package * XCOLOR:: package * XIDEAL:: package * WU:: package * ZEILBERG:: package * ZTRANS:: package File: redhelp, Node: ED, Next: EDITDEF, Up: Outmoded Operations section ED command The ED command invokes a simple line editor for REDUCE input statements. syntax: ED <integer> or ED ED called with no argument edits the last input statement. If <integer> is greater than or equal to the current line number, an error message is printed. Reenter a proper ED command or return to the top level with a semicolon. The editor formats REDUCE's version of the desired input statement, dividing it into lines at semicolons and dollar signs. The statement is printed at the beginning of the edit session. The editor works on one line at a time, and has a pointer (shown by ^ ) to the current character of that line. When the session begins, the pointer is at the left hand side of the first line. The editing prompt is > . The following commands are available. They may be entered in either upper or lower case. All commands are activated by the carriage return, which also prints out the current line after changes. Several commands can be placed on a single line, except that commands terminated by an ESC must be the last command before the carriage return. b Move pointer to beginning of current line. d<digit> Delete current character and next (digit-1) characters. An error message is printed if anything other than a single digit follows d. If there are fewer than <digit> characters left on the line, all but the final dollar sign or semicolon is removed. To delete a line completely, use the k command. e End the current session, causing the edited expression to be reparsed by REDUCE. f<char> Find the next occurrence of the character <char> to the right of the pointer on the current line and move the pointer to it. If the character is not found, an error message is printed and the pointer remains in its original position. Other lines are not searched. The f command is not case-sensitive. i<string>ESC Insert <string> in front of pointer. The ESC key is your delimiter for the input string. No other command may follow this one on the same line. k Kill rest of the current line, including the semicolon or dollar sign terminator. If there are characters remaining on the current line, and it is the last line of the input statement, a semicolon is added to the line as a terminator for REDUCE. If the current line is now empty, one of the following actions is performed: If there is a following line, it becomes the current line and the pointer is placed at its first character. If the current line was the final line of the statement, and there is a previous line, the previous line becomes the current line. If the current line was the only line of the statement, and it is empty, a single semicolon is inserted for REDUCE to parse. l Finish editing this line and move to the last previous line. An error message is printed if there is no previous line. n Finish editing this line and move to the next line. An error message is printed if there is no next line. p Print out all the lines of the statement. Then a dotted line is printed, and the current line is reprinted, with the pointer under it. q Quit the editing session without saving the changes. If a semicolon is entered after q, a new line prompt is given, otherwise REDUCE prompts you for another command. Whatever you type in to the prompt appearing after the q is entered is stored as the input for the line number in which you called the edit. Thus if you enter a semicolon, neither [*note INPUT::.] ED will find anything under the current number. r<char> Replace the character at the pointer by <char>. s<string>ESC Search for the first occurrence of <string> to the right of the pointer on the current line and move the pointer to its first character. The ESC key is your delimiter for the input string. The s function does not search other lines of the statement. If the string is not found, an error message is printed and the pointer remains in its original position. The s command is not case-sensitive. No other command may follow this one on the same line. x <or space> Move the pointer one character to the right. If the pointer is already at the end of the line, an error message is printed. - <(minus)> Move the pointer one character to the left. If the pointer is already at the beginning of the line, an error message is printed. ? Display the Help menu, showing the commands and their actions. examples: ____________________________________________________________ ____________________________________________________________ (Line numbers are shown in the following examples) ____________________________________________________________ 2: >>x**2 + y; X^{2} + Y 3: >>ed 2; X**2 + Y; ^ For help, type '?' ?- (Enter three spaces and (Key){Return}) X**2 + Y; ^ ?- r5 X**5 + Y; ^ ?- fY X**5 + Y; ^ ?- iabc (Terminate with (Key){ESC} and (Key){Return}) X**5 + abcY; ^ ?- ---- X**5 + abcY; ^ ?- fbd2 X**5 + aY; ^ ?- b X**5 + aY; ^ ?- e AY + X^{5} 4: >>procedure dumb(a); >>write a; DUMB 5: >>dumb(17); 17 6: >>ed 4; PROCEDURE DUMB (A); ^ WRITE A; ?- fArBn WRITE A; ^ ?- ibegin scalar a; a := b + 10; (Type a space, (Key){ESC}, and (Key){Return}) begin scalar a; a := b + 10; WRITE A; ?- f;i end (Key){ESC}, (Key){Return} begin scalar b; b := a + 10; WRITE A end; ^ ?- p PROCEDURE DUMB (B); begin scalar b; b := a + 10; WRITE A end; - - - - - - - - - - begin scalar b; b := a + 10; WRITE A end; ^ ?- e DUMB 7: >>dumb(17); 27 8: >> ____________________________________________________________ Note that REDUCE reparsed the procedure DUMB and updated the definition. Since REDUCE divides the expression to be edited into lines at semicolons or dollar sign terminators, some lines may occupy more than one line of screen space. If the pointer is directly beneath the last line of text, it refers to the top line of text. If there is a blank line between the last line of text and the pointer, it refers to the second line of text, and likewise for cases of greater than two lines of text. In other words, the entire REDUCE statement up to the next terminator is printed, even if it runs to several lines, then the pointer line is printed. You can insert new statements which contain semicolons of their own into the current line. They are run into the current line where you placed them until you edit the statement again. REDUCE will understand the set of statements if the syntax is correct. If you leave out needed closing brackets when you exit the editor, a message is printed allowing you to redo the edit (you can edit the previous line number and return to where you were). If you leave out a closing double-quotation mark, an error message is printed, and the editing must be redone from the original version; the edited version has been destroyed. Most syntax errors which you inadvertently leave in an edited statement are caught as usual by the REDUCE parser, and you will be able to re-edit the statement. When the editor processes a previous statement for your editing, escape characters are removed. Most special characters that you may use in identifiers are printed in legal fashion, prefixed by the exclamation point. Be sure to treat the special character and its escape as a pair in your editing. The characters ( ) # ; ' are different. Since they have special meaning in Lisp, they are double-escaped in the editor. It is unwise to use these characters inside identifiers anyway, due to the probability of confusion. If you see a Lisp error message during editing, the edit has been aborted. Enter a semicolon and you will see a new line prompt. Since the editor has no dependence on any window system, it can be used if you are running REDUCE without windows. File: redhelp, Node: EDITDEF, Prev: ED, Up: Outmoded Operations section EDITDEF command The interactive editor [*note ED::.] may be used to edit a user-defined procedure that has not been compiled. syntax: EDITDEF (IDENTIFIER ) where IDENTIFIER is the name of the procedure. When EDITDEF is invoked, the procedure definition will be displayed in editing mode, and may then be edited and redefined on exiting from the editor using standard [*note ED::.] commands. File: redhelp, Node: Outmoded Operations section, Prev: Miscellaneous Packages section, Up: Top Outmoded Operations section * Menu: * ED:: command * EDITDEF:: command File: redhelp, Node: Top, Up: (dir) Top * Menu: * Concepts section:: * Variables section:: * Syntax section:: * Arithmetic Operations section:: * Boolean Operators section:: * General Commands section:: * Algebraic Operators section:: * Declarations section:: * Input and Output section:: * Elementary Functions section:: * General Switches section:: * Matrix Operations section:: * Groebner package section:: * High Energy Physics section:: * Numeric Package section:: * Roots Package section:: * Special Functions section:: * Taylor series section:: * Gnuplot package section:: * Linear Algebra package section:: * Matrix Normal Forms section:: * Miscellaneous Packages section:: * Outmoded Operations section:: Tag Table: Node: IDENTIFIER89 Node: KERNEL2324 Node: STRING3392 Node: Concepts section3968 Node: assumptions4176 Node: CARD_NO4826 Node: E5867 Node: EVAL_MODE6482 Node: FORT_WIDTH6999 Node: HIGH_POW7815 Node: I8845 Node: INFINITY9764 Node: LOW_POW10098 Node: NIL10948 Node: PI11255 Node: requirements11766 Node: ROOT_MULTIPLICITIES12497 Node: T12952 Node: Variables section13268 Node: semicolon13737 Node: dollar15078 Node: percent16681 Node: dot17543 Node: assign18702 Node: equalsign21581 Node: replace22690 Node: plussign23164 Node: minussign23972 Node: asterisk24929 Node: slash26263 Node: power27815 Node: caret29236 Node: geqsign30594 Node: greater31612 Node: leqsign32756 Node: less33720 Node: tilde34705 Node: group35013 Node: AND36337 Node: BEGIN37441 Node: block39104 Node: COMMENT39416 Node: CONS40186 Node: END41485 Node: EQUATION42355 Node: FIRST44096 Node: FOR44791 Node: FOREACH49527 Node: GEQ50216 Node: GOTO51311 Node: GREATERP52299 Node: IF53401 Node: LIST55938 Node: OR57485 Node: PROCEDURE58633 Node: REPEAT64274 Node: REST65495 Node: RETURN66354 Node: REVERSE68550 Node: RULE69700 Node: Free Variable71388 Node: Optional Free Variable71963 Node: SECOND72895 Node: SET73615 Node: SETQ74805 Node: THIRD76899 Node: WHEN77657 Node: Syntax section77939 Node: ARITHMETIC_OPERATIONS79927 Node: ABS80256 Node: ADJPREC81171 Node: ARG82070 Node: CEILING82722 Node: CHOOSE83550 Node: DEG2DMS84254 Node: DEG2RAD85082 Node: DIFFERENCE85822 Node: DILOG86780 Node: DMS2DEG87560 Node: DMS2RAD88337 Node: FACTORIAL89119 Node: FIX89844 Node: FIXP90758 Node: FLOOR91726 Node: EXPT92537 Node: GCD93564 Node: LN94527 Node: LOG95533 Node: LOGB96404 Node: MAX97393 Node: MIN98071 Node: MINUS98747 Node: NEXTPRIME99421 Node: NOCONVERT100086 Node: NORM100684 Node: PERM101514 Node: PLUS102277 Node: QUOTIENT103281 Node: RAD2DEG105295 Node: RAD2DMS106032 Node: RECIP106813 Node: REMAINDER107352 Node: ROUND108400 Node: SETMOD109013 Node: SIGN110331 Node: SQRT111038 Node: TIMES112284 Node: Arithmetic Operations section113292 Node: boolean value114899 Node: EQUAL115270 Node: EVENP116460 Node: false117495 Node: FREEOF117929 Node: LEQ119109 Node: LESSP120184 Node: MEMBER121267 Node: NEQ122259 Node: NOT123321 Node: NUMBERP124252 Node: ORDP125124 Node: PRIMEP126108 Node: TRUE126817 Node: Boolean Operators section127468 Node: BYE128155 Node: CONT128479 Node: DISPLAY129810 Node: LOAD_PACKAGE130698 Node: PAUSE131120 Node: QUIT133498 Node: RECLAIM133854 Node: REDERR134624 Node: RETRY136051 Node: SAVEAS136864 Node: SHOWTIME137941 Node: WRITE138900 Node: General Commands section140314 Node: APPEND140915 Node: ARBINT142112 Node: ARBCOMPLEX142691 Node: ARGLENGTH143426 Node: COEFF144430 Node: COEFFN146529 Node: CONJ148282 Node: CONTINUED_FRACTION148988 Node: DECOMPOSE150170 Node: DEG151372 Node: DEN152265 Node: DF153556 Node: EXPAND_CASES155315 Node: EXPREAD155717 Node: FACTORIZE156181 Node: HYPOT158549 Node: IMPART159304 Node: INT159962 Node: INTERPOL162378 Node: LCOF163485 Node: LENGTH164427 Node: LHS166191 Node: LIMIT167142 Node: LPOWER168490 Node: LTERM169374 Node: MAINVAR170276 Node: MAP171659 Node: MKID173750 Node: NPRIMITIVE175154 Node: NUM175818 Node: ODESOLVE176735 Node: ONE_OF178657 Node: PART179513 Node: PF182236 Node: PROD183671 Node: REDUCT184488 Node: REPART185425 Node: RESULTANT186085 Node: RHS189206 Node: ROOT_OF190743 Node: SELECT192288 Node: SHOWRULES194229 Node: SOLVE195198 Node: SORT199963 Node: STRUCTR201553 Node: SUB203206 Node: SUM204090 Node: WS204980 Node: Algebraic Operators section207213 Node: ALGEBRAIC209148 Node: ANTISYMMETRIC210018 Node: ARRAY211451 Node: CLEAR213785 Node: CLEARRULES216469 Node: DEFINE217452 Node: DEPEND218597 Node: EVEN220376 Node: FACTOR declaration221072 Node: FORALL222812 Node: INFIX226022 Node: INTEGER227489 Node: KORDER228738 Node: LET229826 Node: LINEAR236743 Node: LINELENGTH238745 Node: LISP239329 Node: LISTARGP240065 Node: NODEPEND241096 Node: MATCH242025 Node: NONCOM244113 Node: NONZERO245295 Node: ODD245921 Node: OFF246789 Node: ON247135 Node: OPERATOR247481 Node: ORDER249906 Node: PRECEDENCE251577 Node: PRECISION253394 Node: PRINT_PRECISION254691 Node: REAL255423 Node: REMFAC256682 Node: SCALAR257115 Node: SCIENTIFIC_NOTATION258361 Node: SHARE260002 Node: SYMBOLIC261388 Node: SYMMETRIC262089 Node: TR263079 Node: UNTR264936 Node: VARNAME265457 Node: WEIGHT266580 Node: WHERE268523 Node: WHILE270660 Node: WTLEVEL271677 Node: Declarations section273547 Node: IN275406 Node: INPUT276695 Node: OUT277761 Node: SHUT279884 Node: Input and Output section280522 Node: ACOS280831 Node: ACOSH281948 Node: ACOT283503 Node: ACOTH284179 Node: ACSC284873 Node: ACSCH285982 Node: ASEC287063 Node: ASECH288166 Node: ASIN289722 Node: ASINH290921 Node: ATAN292288 Node: ATANH293398 Node: ATAN2294729 Node: COS295822 Node: COSH296806 Node: COT297907 Node: COTH298861 Node: CSC299847 Node: CSCH300810 Node: ERF301845 Node: EXP302900 Node: SEC303800 Node: SECH304779 Node: SIN305770 Node: SINH306690 Node: TAN307906 Node: TANH309170 Node: Elementary Functions section310361 Node: SWITCHES311533 Node: ALGINT311863 Node: ALLBRANCH312323 Node: ALLFAC313235 Node: ARBVARS314014 Node: BALANCED_MOD315284 Node: BFSPACE315913 Node: COMBINEEXPT316764 Node: COMBINELOGS317373 Node: COMP318497 Node: COMPLEX320746 Node: CREF322013 Node: CRAMER322996 Node: DEFN324840 Node: DEMO327109 Node: DFPRINT327783 Node: DIV328646 Node: ECHO329642 Node: ERRCONT330544 Node: EVALLHSEQP331390 Node: EXP switch331806 Node: EXPANDLOGS332868 Node: EZGCD334015 Node: FACTOR334675 Node: FAILHARD336733 Node: FORT337352 Node: FORTUPPER338441 Node: FULLPREC338993 Node: FULLROOTS339871 Node: GC340337 Node: GCD switch340790 Node: HORNER342289 Node: IFACTOR343154 Node: INT switch344254 Node: INTSTR344850 Node: LCM345382 Node: LESSSPACE347295 Node: LIMITEDFACTORS347523 Node: LIST switch348554 Node: LISTARGS349286 Node: MCD350236 Node: MODULAR351538 Node: MSG352700 Node: MULTIPLICITIES353071 Node: NAT353944 Node: NERO354875 Node: NOARG355998 Node: NOLNR356780 Node: NOSPLIT357401 Node: NUMVAL357864 Node: OUTPUT358505 Node: OVERVIEW359028 Node: PERIOD359297 Node: PRECISE359598 Node: PRET360665 Node: PRI361866 Node: RAISE362515 Node: RAT362916 Node: RATARG364097 Node: RATIONAL365134 Node: RATIONALIZE366197 Node: RATPRI367221 Node: REVPRI367933 Node: RLISP88368755 Node: ROUNDALL369567 Node: ROUNDBF370120 Node: ROUNDED371242 Node: SAVESTRUCTR372139 Node: SOLVESINGULAR373555 Node: TIME374845 Node: TRALLFAC376006 Node: TRFAC376588 Node: TRIGFORM377258 Node: TRINT377638 Node: TRNONLNR377954 Node: VAROPT378423 Node: General Switches section379601 Node: COFACTOR382436 Node: DET383169 Node: MAT384245 Node: MATEIGEN385699 Node: MATRIX387719 Node: NULLSPACE390705 Node: RANK392342 Node: TP393100 Node: TRACE393981 Node: Matrix Operations section394720 Node: Groebner bases395223 Node: Ideal Parameters396187 Node: Term order398597 Node: TORDER399066 Node: torder_compile400779 Node: lex term order401427 Node: gradlex term order402005 Node: revgradlex term order402378 Node: gradlexgradlex term order402902 Node: gradlexrevgradlex term order403607 Node: lexgradlex term order403903 Node: lexrevgradlex term order404183 Node: weighted term order404512 Node: graded term order404985 Node: matrix term order405546 Node: Term order section406324 Node: GVARS406978 Node: GROEBNER407363 Node: groebopt408718 Node: gvarslast409456 Node: groebprereduce409833 Node: groebfullreduction410374 Node: gltbasis410791 Node: gltb411194 Node: glterms411361 Node: groebstat411868 Node: trgroeb412245 Node: trgroebs412517 Node: gzerodim?412797 Node: gdimension413269 Node: gindependent_sets413841 Node: dd_groebner414594 Node: glexconvert415413 Node: greduce416562 Node: preduce416974 Node: idealquotient417506 Node: hilbertpolynomial418023 Node: Basic Groebner operators section418581 Node: groebnerf419549 Node: groebmonfac421407 Node: groebresmax422135 Node: groebrestriction422509 Node: Factorizing Groebner bases section423215 Node: groebprot423583 Node: groebprotfile423918 Node: groebnert424113 Node: preducet425027 Node: Tracing Groebner bases section425790 Node: Module426154 Node: gmodule426794 Node: Groebner Bases for Modules section427867 Node: gsort428175 Node: gsplit428743 Node: gspoly429465 Node: Computing with distributive polynomials section429927 Node: Groebner package section430247 Node: HEPHYS430718 Node: HE-dot431337 Node: EPS432894 Node: G434219 Node: INDEX437082 Node: MASS438095 Node: MSHELL439171 Node: NOSPUR440103 Node: REMIND440920 Node: SPUR441348 Node: VECDIM441761 Node: VECTOR442422 Node: High Energy Physics section444808 Node: Numeric Package445443 Node: Interval445897 Node: numeric accuracy446575 Node: TRNUMERIC447056 Node: num_min447418 Node: num_solve448929 Node: num_int450805 Node: num_odesolve452388 Node: bounds454414 Node: Chebyshev fit456117 Node: num_fit458351 Node: Numeric Package section459797 Node: Roots Package460363 Node: MKPOLY461107 Node: NEARESTROOT461856 Node: REALROOTS462498 Node: ROOTACC463726 Node: ROOTS464133 Node: ROOT_VAL465238 Node: ROOTSCOMPLEX465999 Node: ROOTSREAL466283 Node: Roots Package section466540 Node: Special Function Package467035 Node: Constants469568 Node: BERNOULLI470479 Node: BERNOULLIP471020 Node: EULER471669 Node: EULERP472345 Node: ZETA472918 Node: Bernoulli Euler Zeta section473773 Node: BESSELJ474138 Node: BESSELY474647 Node: HANKEL1475245 Node: HANKEL2475944 Node: BESSELI476644 Node: BESSELK477187 Node: StruveH477707 Node: StruveL478151 Node: KummerM478601 Node: KummerU479267 Node: WhittakerW479861 Node: Bessel Functions section480568 Node: Airy_Ai481164 Node: Airy_Bi481726 Node: Airy_Aiprime482267 Node: Airy_Biprime482848 Node: Airy Functions section483383 Node: JacobiSN483746 Node: JacobiCN484290 Node: JacobiDN484878 Node: JacobiCD485422 Node: JacobiSD485984 Node: JacobiND486546 Node: JacobiDC487137 Node: JacobiNC487679 Node: JacobiSC488237 Node: JacobiNS488824 Node: JacobiDS489407 Node: JacobiCS489969 Node: JacobiAMPLITUDE490530 Node: AGM_FUNCTION491151 Node: LANDENTRANS492433 Node: EllipticF493215 Node: EllipticK493936 Node: EllipticKprime494645 Node: EllipticE495373 Node: EllipticTHETA496571 Node: JacobiZETA497654 Node: Jacobi Elliptic Functions and Elliptic Integrals section498389 Node: POCHHAMMER499426 Node: GAMMA500279 Node: BETA500750 Node: PSI501388 Node: POLYGAMMA502003 Node: Gamma and Related Functions section502688 Node: DILOG extended503121 Node: Lambert_W function503928 Node: Miscellaneous Functions section504711 Node: ChebyshevT505003 Node: ChebyshevU505750 Node: HermiteP506515 Node: LaguerreP507234 Node: LegendreP508163 Node: JacobiP509180 Node: GegenbauerP509846 Node: SolidHarmonicY510440 Node: SphericalHarmonicY511150 Node: Orthogonal Polynomials section512075 Node: Si512616 Node: Shi513220 Node: s_i513846 Node: Ci514456 Node: Chi515083 Node: ERF extended515751 Node: erfc516507 Node: Ei517064 Node: Fresnel_C517710 Node: Fresnel_S518341 Node: Integral Functions section518968 Node: BINOMIAL519542 Node: STIRLING1520416 Node: STIRLING2521331 Node: Combinatorial Operators section522123 Node: ThreejSymbol522438 Node: Clebsch_Gordan523139 Node: SixjSymbol523765 Node: 3j and 6j symbols section524394 Node: HYPERGEOMETRIC524699 Node: MeijerG525620 Node: Heaviside527105 Node: erfi527608 Node: Miscellaneous section528093 Node: Special Functions section528390 Node: TAYLOR introduction529012 Node: taylor529544 Node: taylorautocombine532768 Node: taylorautoexpand533178 Node: taylorcombine533560 Node: taylorkeeporiginal535999 Node: taylororiginal536533 Node: taylorprintorder537756 Node: taylorprintterms538067 Node: taylorrevert539443 Node: taylorseriesp540318 Node: taylortemplate541251 Node: taylortostandard542168 Node: Taylor series section542917 Node: GNUPLOT and REDUCE543553 Node: Axes names544498 Node: Pointset545039 Node: PLOT546068 Node: PLOTRESET548993 Node: title549350 Node: xlabel549764 Node: ylabel550185 Node: zlabel550616 Node: terminal551047 Node: size551540 Node: view552054 Node: contour552600 Node: surface552999 Node: hidden3d553401 Node: PLOTKEEP553810 Node: PLOTREFINE554156 Node: plot_xmesh554769 Node: plot_ymesh555266 Node: SHOW_GRID555639 Node: TRPLOT556102 Node: Gnuplot package section556582 Node: Linear Algebra package557508 Node: fast_la559943 Node: add_columns561059 Node: add_rows562173 Node: add_to_columns562362 Node: add_to_rows563565 Node: augment_columns563767 Node: band_matrix564759 Node: block_matrix565913 Node: char_matrix567028 Node: char_poly567821 Node: cholesky568503 Node: coeff_matrix569799 Node: column_dim570745 Node: companion571343 Node: copy_into572301 Node: diagonal573563 Node: extend574632 Node: find_companion575579 Node: get_columns576481 Node: get_rows577529 Node: gram_schmidt577716 Node: hermitian_tp578687 Node: hessian579703 Node: hilbert580629 Node: jacobian581757 Node: jordan_block582946 Node: lu_decom583914 Node: make_identity587087 Node: matrix_augment587782 Node: matrixp588927 Node: matrix_stack589570 Node: minor589757 Node: mult_columns590452 Node: mult_rows591553 Node: pivot591737 Node: pseudo_inverse592686 Node: random_matrix593975 Node: remove_columns595845 Node: remove_rows596730 Node: row_dim596924 Node: rows_pivot597106 Node: simplex598365 Node: squarep599641 Node: stack_rows600247 Node: sub_matrix600436 Node: svd601225 Node: swap_columns602677 Node: swap_entries603566 Node: swap_rows604294 Node: symmetricp604483 Node: toeplitz605124 Node: vandermonde606050 Node: Linear Algebra package section606924 Node: Smithex609066 Node: Smithex_int610006 Node: Frobenius611213 Node: Ratjordan613674 Node: Jordansymbolic615984 Node: Jordan618450 Node: Matrix Normal Forms section620245 Node: Miscellaneous Packages620649 Node: ALGINT package622010 Node: APPLYSYM622798 Node: ARNUM623110 Node: ASSIST623589 Node: AVECTOR623980 Node: BOOLEAN624536 Node: CALI625093 Node: CAMAL625626 Node: CHANGEVR625905 Node: COMPACT626223 Node: CONTFR627731 Node: CRACK629139 Node: CVIT629610 Node: DEFINT629971 Node: DESIR630368 Node: DFPART630817 Node: DUMMY631182 Node: EXCALC631684 Node: FPS632358 Node: FIDE632636 Node: GENTRAN633335 Node: IDEALS634133 Node: INEQ634557 Node: INVBASE634843 Node: LAPLACE635423 Node: LIE635729 Node: MODSR636200 Node: NCPOLY637070 Node: ORTHOVEC637581 Node: PHYSOP638069 Node: PM638616 Node: RANDPOLY639020 Node: REACTEQN639367 Node: RESET639703 Node: RESIDUE640291 Node: RLFI640533 Node: SCOPE641017 Node: SETS641493 Node: SPDE641832 Node: SYMMETRY642354 Node: TPS642767 Node: TRI643689 Node: TRIGSIMP644101 Node: XCOLOR644700 Node: XIDEAL644982 Node: WU645622 Node: ZEILBERG646012 Node: ZTRANS646582 Node: Miscellaneous Packages section646873 Node: ED648825 Node: EDITDEF657488 Node: Outmoded Operations section657993 Node: Top658209 End Tag Table