1\documentstyle{article} 2\author{} 3\date{} 4\title{REDUCE: Overview} 5\begin{document} 6\sloppy 7\maketitle 8 9\section*{Introduction} 10The first version of {\small REDUCE} was developed and published by 11Anthony C. Hearn about 25 years ago. The starting point was a class of 12formal computations for problems in high energy physics (Feynman diagrams, 13cross sections etc.), which are hard and time consuming if done by hand. 14Although the facilities of the current {\small REDUCE} are much more 15advanced than those of the early versions, the direction towards big 16formal computations in applied mathematics, physics and engineering has 17been stable over the years, but with a much broader set of applications. 18 19Like symbolic computation in general, {\small REDUCE} has profited by the 20increasing power of computer architectures and by the information exchange 21made available by recent network developments. Spearheaded by A.C. 22Hearn, several groups in different countries take part in the {\small 23REDUCE} development, and the contributions of users have significantly 24widened the application field. 25 26Today {\small REDUCE} can be used with a variety of hardware platforms 27from the {\small DOS}-based personal computer up to the Cray 28supercomputer. However, the primary vehicle is the class of advanced UNIX 29workstations. 30 31Although {\small REDUCE} is a mature program system, it is extended and 32updated on a continuous basis. Since the establishment of the {\small 33REDUCE} Network Library in 1989, users take part in the development, thus 34reducing the incompatibilities encountered with new system releases. 35 36In July 1995 version 3.6 of {\small REDUCE} was released. Information 37regarding the available implementations can be obtained by electronic 38mail: submit `send info-package' to `reduce-netlib@rand.org', 39`reduce-netlib@can.nl' or 40`reduce-netlib@pi.cc.u-tokyo.ac.jp'. 41The same information is available from an Internet gopher server with 42the address info.rand.org. The network library files are in a ``REDUCE 43Library'' directory under the directory ``Publicly Available Software''. 44The relevant URL is gopher://info.rand.org/11/software/reduce . Finally, 45a World Wide Web {\REDUCE} server with URL http://www.rrz.uni-koeln.de/REDUCE/ 46is also supported. In addition to general information about {\REDUCE}, this 47server has pointers to the network library, the demonstration versions, 48examples of {\REDUCE} programming, a set of manuals, and the {\REDUCE} online 49help system. 50 51\section{Problem solving} 52 53The primary domain of {\small REDUCE} is the solution of large scale 54formal problems in mathematics, science and engineering. {\small REDUCE} 55offers a number of powerful operators which often give an immediate answer 56to a given problem, e.g. solving a linear equation system or computing a 57determinant (with symbolic entries, of course). More typical however are 58relatively complicated applications where only the combination of several 59evaluation steps leads to the desired result. Consequently the 60development of {\small REDUCE} primarily is oriented towards a collection 61of powerful tools, which enable problem solving by combination. 62 63In some cases even complete new algorithmic bases will be required for 64problem solving. {\small REDUCE} supports this by various interfaces to 65all levels of symbolic evaluation, and the modules of {\small REDUCE} and 66of the {\small REDUCE} Network Library demonstrate by example how this 67technique is to be used. 68\section{Data Types, Structures} 69 70\subsection{Elementary Expressions} 71 72The central object of {\small REDUCE} is the formal expression, which is 73built with respect to the common mathematical rules. Elementary items are 74 75\begin{itemize} 76\item numbers (integers, rationals, rounded fractionals, real or 77complex); the domain can be selected dynamically, 78\item symbols (names with or without indices) 79\item functional expressions (names followed by a parameter list) 80\item operator symbols {\bf +,-,*,/,**} 81\item parentheses for precedence control. 82\end{itemize} 83 84A symbol here can play the role of an unknown in the mathematical sense, 85as well as a placeholder for a value. An expression can be assigned to a 86symbol as a value such that later all references to the symbol are 87replaced by the assigned value. 88 89 90Examples of elementary expressions: 91 92\begin{verbatim} 93 3.1415928 % fraction 94 a % simple variable 95 (x+y)**2 / 2 % quadratic expression 96 log(u)+log(v) % function 97\end{verbatim} 98 99\subsection{Aggregates} 100 101There are data structures that collect a number of formal expressions: 102 103\begin{itemize} 104\item An {\tt equation} is an object where the operator {\bf =} takes 105highest precedence, with two slots for expressions, the {\bf lhs} and 106{\bf rhs}: 107\begin{verbatim} 108 p=u**2 109\end{verbatim} 110 111\item A {\tt list} is a linear sequence of expressions, where each of the 112members is elementary or itself an aggregate. There are operations for 113construction, join, decomposition and reordering of lists: 114\begin{verbatim} 115 {2,3,5,7,11,13,17,19} 116\end{verbatim} 117 118\item An {\tt array} is a rectangular multidimensional structure; the 119elements are identified by integer indices. Elements always have a value, 120which defaults to zero. 121 122\begin{verbatim} 123 array primes(10); 124 primes(0):=2; 125 for i:=1: 10 do 126 primes(i):=nextprime(primes(i-1)); 127\end{verbatim} 128 129\item A {\tt matrix} is a named structure of rows and columns, whose 130elements are identified by two positive integers. For matrices with 131compatible dimensions and for matrices and scalars there are operations 132corresponding to the laws of linear algebra. 133E.g. using the derivative operator {\bf df} to construct 134a Jacobian 135\begin{verbatim} 136 matrix jac(n,n); 137 for i:=1:n do for j:=1:n do 138 jac(i,j):=df(f(i),x(j)); 139\end{verbatim} 140 141\end{itemize} 142 143\section{Programming Paradigms} 144 145For specifying symbolic tasks and algorithms {\small REDUCE} offers a set 146of different programming paradigms: 147 148 \subsection{Algebraic Desk Calculator} 149 150Using {\small REDUCE} as a desk calculator for symbolic and numeric 151expressions is the simplest approach. Formulas can be entered, combined, 152stored and processed by a set of powerful operators like differentiation, 153integration, polynomial GCD, factorization etc. Any formula will be 154processed immediately with the objective of finding its most complete 155simplification, and the result will be presented on the screen as soon as 156available. 157 158Example: Taylor polynomial for {\bf x*sin(x)} 159 160\begin{verbatim} 161for i:=0:5 sum 162 sub(x=0,df(x*sin(x),x,i)) * x**i 163 / factorial(i); 164 165 1 4 2 166 - ---*X + X 167 6 168\end{verbatim} 169 170 171\subsection{Imperative Algebraic Programming} 172 173Evaluation of a single formula with the immediate output of the result is 174a special case of a statement of the {\small REDUCE} programming language, 175which, from a syntactical standpoint, is part of the ALGOL family. This 176programming language allows the user to code complicated evaluation 177sequences such as conditionals, groups, blocks, iterations controlled by 178counters or list structures, and the definition of complete parameterized 179procedures with local variables. 180 181Example: definition of a procedure for expanding a function to a Taylor 182polynomial: 183 184\begin{verbatim} 185procedure tay(u,x,n); 186 begin scalar ser,fac; 187 ser:=sub(x=0,u);fac:=1; 188 for i:=1:n do 189 <<u:=df(u,x); fac:=fac*i; 190 ser:=ser+sub(x=0,u)*x**i/fac >>; 191 return(ser); 192 end; 193\end{verbatim} 194 195A call to this procedure: 196\begin{verbatim} 197tay(x*sin(x),x,5); 198\end{verbatim} 199yields 200\begin{verbatim} 201 1 4 2 202 - ---*X + X 203 6 204\end{verbatim} 205 206Example: a recursive program for collecting a basis of Legendre 207polynomials from the recurrence relation: 208 209\begin{verbatim} 210 P{n+1,x) = ((2n+1)*x*P(n,x) - n*P(n-1,x))/(n+1) 211\end{verbatim} 212 213 214The infix operator "." adds a new element to the head of a list. 215 216\begin{verbatim} 217procedure Legendre_basis(m,x); 218 % Start with basis of order 1 219 Legendre_basis_aux(m,x,1,{x,1}); 220 221procedure Legendre_basis_aux(m,x,n,ls); 222 % ls contains polynomials n, n-1, n-2 ... 223 if n>=m then ls % done 224 else Legendre_basis_aux(m,x,n+1, 225 (((2n+1)*x*first ls - n*second ls)/(n+1)) 226 . ls); 227\end{verbatim} 228 229A call to this procedure 230\begin{verbatim} 231Legendre_basis(3,z); 232\end{verbatim} 233yields 234\begin{verbatim} 235 5 3 3 236{---*Z - ---*Z, 237 2 2 238 239 3 2 1 240 ---*Z - ---, 241 2 2 242 243 Z, 1} 244\end{verbatim} 245 246\subsection{Rule Oriented Programming} 247 248In {\small REDUCE}, global algebraic relations can be formulated with 249rules. A rule links an algebraic search pattern to a replacement pattern, 250sometimes controlled by additional conditions. Rules can be activated 251(and deactivated) globally, or they can be invoked with a limited scope 252for single evaluations. So the user has an arbitrary precise control over 253the algebraic simplification. 254 255Example: Expanding trigonometric functions for combined arguments; the 256tilde symbol represents an implicit for--all. 257 258\begin{verbatim} 259Sin_Cos_rules:= 260{sin(~x+~y)=>sin(x)*cos(y) + cos(x)*sin(y), 261 cos(~x+~y)=>cos(x)*cos(y) - sin(x)*sin(y)}; 262\end{verbatim} 263 264Global activation is achieved by 265\begin{verbatim} 266let Sin_Cos_rules; 267\end{verbatim} 268 269Note: {\small REDUCE} has no predefined "knowledge" about these 270relations for trigonometric functions, as they can be used as production 271rules in either form depending on whether expansion or collection is 272required; only the user can define which mode is adequate for his problem. 273 274Using rules, a complete calculus can be implemented; the rule syntax here 275is very close to the mathematical notation for multistep cases. 276 277Example: Definition of Hermite polynomials: 278 279\begin{verbatim} 280operator Hermite; 281Hermite_rules:= 282{Hermite(0,~x) => 1, 283 Hermite(1,~x) => 2*x, 284 Hermite(~n,~x) => 2*x*Hermite(n-1,x) 285 -2*(n-1)*Hermite(n-2,x) 286 when n>1}; 287 288let Hermite_rules; 289\end{verbatim} 290 291Generation of a Hermite polynomial: 292 293\begin{verbatim} 294Hermite(4,z); 295 296 4 2 29716*Z - 48*Z + 12 298\end{verbatim} 299 300\subsection{Symbolic Imperative Programming} 301 302The paradigms described so far give access to the {\small REDUCE} 303facilities at the top level. They enable a compact programming close to 304the application problem. No knowledge about the internal data structures 305is necessary, since {\small REDUCE} converts data automatically to the 306formats needed locally for each evaluation step. On the other hand, such 307frequent conversions are time consuming and so for very large problems it 308might be desirable to keep intermediate results in the internal form in 309order to avoid the conversion overhead. Here the ``symbolic'' mode of 310{\small REDUCE} can be used, which allows the access to internal data 311structures and procedures directly with the same syntax as in top level 312programming. 313 314Of course, this level of programming requires some knowledge about {\small 315LISP} and about internal {\small REDUCE} structures. However, it enables 316the implementation of algorithms with the highest possible efficiency. 317 318\section{Algebraic Evaluation} 319 320The evaluation of expressions is the heart of {\small REDUCE}. Because of 321its great complexity, it is only briefly touched on here. One central 322problem in automatic formula manipulation is the detection of identity 323between objects, e.g. the confirmation 324 {\bf a + b = b + a } 325under the assumption of commutative addition. 326 327It is well known that this problem is equivalent to the problem of 328recognizing that an expression is zero, in other words to the existence of 329an algorithm for the transformation of a formula into an equivalent 330canonical normal form. Unfortunately there is no universal canonical 331form; only for subcases, for example polynomials, rationals, and ideals, 332are canonical forms known. Therefore {\small REDUCE} evaluation is based 333on a canonical form for rational functions (i.e., quotients of 334multivariate polynomials), where symbols or function expressions play the 335role of variables ({\small REDUCE}: kernels). {\small REDUCE} attempts to 336tranform as many functions as possible into the canonical form by applying 337additional heuristic rules. 338 339A coarse sketch of evaluation is as follows: 340 341\begin{itemize} 342\item a symbol with an assigned value is 343replaced by the value, 344\item a call for a known procedure is 345replaced by the value produced by the procedure invocation, 346\item matching rules are applied, 347\item polynomials are expanded recursively using a lexicographic 348order of variables (kernels): a multivariate polynomial is a 349polynomial in its highest variable with decreasing exponents, 350where the coefficients are polynomials in the remaining 351variables, 352\item a rational function is converted into a form with common 353denominator (i.e., a quotient of two polynomials). 354\end{itemize} 355 356This is, of course, a highly recursive process, which is applied until no 357more transformations are possible. 358\section{Approximations} 359 360In the domain of symbolic computation, mostly exact arithmetic is used, 361especially with algorithms from the classical Computer Algebra. That 362aspect is supported by {\small REDUCE} with arbitrarily long integer 363arithmetic and, built on top of that, rational and modular (p-adic) 364numbers. 365 366The values of transcendental functions with general numeric arguments do 367not fall into these domains, even if symbols like {\bf pi}, {\bf e}, {\bf i} 368are attached. Nevertheless symbolic computation can be used for fields beyond 369classical algebra, for example in the domain of analytic approximations in 370numerical mathematics. 371 372\subsection{Power Series} 373 374Power series are a valuable tool for the formal approximation of 375functions, e.g. in the area of differential equations. {\small REDUCE} 376supports several types of power series, among them univariate Taylor 377series with variable order and multivariate Taylor series with fixed 378order. 379 380\subsection{Rounded Numbers} 381 382For several decades, floating point numbers have been recognized as a 383useful tool for numerical computations, although they do not possess most 384of the algebraic properties of numbers. In {\small REDUCE} they are 385incorporated as "rounded numbers" which, when compared to classical 386floating point numbers (e.g. in the IEEE view) they offer interesting 387additional properties: 388 389\begin{itemize} 390\item the mantissa length can be selected 391arbitrarily (i.e., selected as a number of decimal digits), 392\item there is no limit for the exponent and so no 393upper or lower limit for the magnitude of a number. 394\end{itemize} 395 396Technically, this arithmetic is implemented by an embedding of the 397standard (hardware) floating point operations in a software package, which 398tries to execute as much as possible in fast hardware and which converts 399to software emulation as soon as the hardware limits are passed. Based on 400this number domain, attractive algorithms can be implemented, which start 401with coarse approximations and then refine the overall precision in an 402adaptive style when approaching the desired solution. 403 404\subsection{Interface for Numerical Programs} 405 406A field of growing importance for symbolic computation is the use of 407algorithms of mixed symbolic-numeric type, when for example a symbolic 408calculation carries out formal transformations on an equation system for 409control or conditioning of a numerical solver. Examples are the automatic 410programming of Jacobians for ODE solvers, or the reduction of the order of 411a system by exploiting formal symmetries. By the cooperation of symbolic 412and numeric components, {\small REDUCE} offers several facilities for the 413generation of partial or complete programs in languages such as FORTRAN or 414C. As automatically generated programs tend to flood the target 415compilers, {\small REDUCE} also provides for the optimization of the 416numeric code. 417\section{I/O} 418 419In interactive mode, {\small REDUCE} normally prints results in a two 420dimensional ``mathematical'' form, where exponents are raised, quotients 421are printed with denominator below numerator, and matrices are represented 422as rectangular blocks. The output can be influenced by a variety of 423switches, e.g. for reordering or collecting of terms. 424 425For special purposes, additional output forms are available: 426 427\begin{itemize} 428\item linear form: the data can be re-used for later 429input in {\small REDUCE} or another system, 430\item foreign syntax: the expressions are printed in 431the syntax of FORTRAN, C or another programming language 432for the direct insertion in numeric codes, 433\item TeX: indirect formatting as input for the TeX 434layout program to be inserted into a publication. 435\end{itemize} 436 437Examples for {\bf q:=(x+y)**3}: 438 439natural (default) output: 440\begin{verbatim} 441 3 2 2 3 442Q := X + 3*X *Y + 3*X*Y + Y 443\end{verbatim} 444for later re--use: 445\begin{verbatim} 446Q := X**3 + 3*X**2*Y + 3*X*Y**2 + Y**3$ 447\end{verbatim} 448as contribution to a FORTRAN source: 449\begin{verbatim} 450 Q=X**3+3.*X**2*Y+3.*X*Y**2+Y**3 451\end{verbatim} 452for a LaTeX document: 453\begin{verbatim} 454\begin{displaymath} 455q=x^{3}+3 x^{2} y+3 x y^{2}+y^{3} 456\end{displaymath} 457\end{verbatim} 458 459In addition to direct terminal access, I/O can also be redirected to 460files. 461\section{Open System} 462 463In contrast to most other symbolic math systems, {\small REDUCE} 464traditionally is completely open: 465 466\begin{itemize} 467\item {\small REDUCE} is written in a language {\small RLISP}, which 468incorporates the functionality of {\small LISP} in a user friendly syntax. 469At the same time {\small RLISP} is the language of application. 470 471\item Traditionally {\small REDUCE} is delivered with all sources. So the 472algorithmic basis is visible to any user. Even the {\small REDUCE} 473translator (compiling {\small RLISP} to {\small LISP}) is delivered as 474source code. 475 476\item Any internal {\small REDUCE} function and data structure can be 477accessed by the user directly (in symbolic style programming). Most of 478the {\small REDUCE} implementations contain a {\small LISP} compiler, such 479that the user can produce very efficient modules. {\small REDUCE} can be 480integrated into other ({\small LISP}-) packages as an algebraic engine. 481 482\item {\small REDUCE} inherits automatically from {\small LISP} the 483facility of dynamic loading of modules, of incremental compilation and 484dynamic function redefinition. Even the kernel of {\small REDUCE} is open 485for local modification. Obviously this is a dangerous feature where 486system integrity is concerned, but, on the other hand, an innovative user 487finds a rich testbed here. 488\end{itemize} 489 490One effect of the liberality of {\small REDUCE} is the large number of 491application packages written by users. Many of these packages now are now 492included in {\small REDUCE} or in the {\small REDUCE} Network Library. 493\renewcommand{\thesection}{Appendix \Alph{section}} 494\setcounter{section}{0} 495 496\section{REDUCE Packages} 497 498State: late 1993. 499 500\begin{itemize} 501\item ALGINT integration for functions involving roots 502(James H. Davenport) 503 504\item ARNUM algebraic numbers (Eberhard Schr\"ufer) 505 506\item ASSIST useful utilities for various applications (Hubert Caprasse) 507 508\item AVECTOR vector algebra (David Harper) 509 510\item CALI computational commutative algebra (Hans-Gert Graebe) 511 512\item CAMAL calculations in celestial mechanics (John Fitch) 513 514\item CHANGEVAR transformation of variables in differential equations 515(G. \"{U}\c{c}oluk) 516 517\item COMPACT condensing of expressions with polynomial side relations 518 (Anthony C. Hearn) 519 520\item CRACK solving overdetermined systems of PDEs or ODEs 521(Andreas Brand, Thomas Wolf) 522 523\item CVIT Dirac gamma matrices (V.Ilyin, A.Kryukov, A.Rodionov, 524 A.Taranov) 525 526\item DESIR differential equations and singularities 527(C. Dicrescenzo, F. Richard-Jung, E. Tournier) 528 529\item EXCALC calculus for differential geometry (Eberhard Schr\"ufer) 530 531\item FIDE code generation for finite difference schemes 532(Richard Liska) 533 534\item GENTRAN code generation in FORTRAN, RATFOR, C (Barbara Gates) 535 536\item GNUPLOT display of functions and surfaces (Herbert Melenk) 537 538\item GROEBNER computation in multivariate polynomial ideals 539 (Herbert Melenk, H.Michael M\"oller, Winfried Neun) 540 541\item HEPHYS high energy physics (Anthony C. Hearn) 542 543\item IDEALS arithmetic for polynomial ideals (Herbert Melenk) 544 545\item INVSYS involutive polynomial systems (Alexey Zharkov) 546 547\item LAPLACE Laplace and inverse Laplace transform (C. Kazasov et al.) 548 549\item LIE functions for the classification of real n-dimensional Lie 550algebras (Carsten, Franziska Sch\"obel) 551 552\item LIMITS finding limits (Stanley L. Kameny) 553 554\item LININEQ linear inequalities and linear programming (Herbert Melenk) 555 556\item NUMERIC solving numerical problems using rounded mode (Herbert Melenk) 557 558\item ODESOLVE ordinary differential equations (Malcolm MacCallum et al.) 559 560\item ORTHOVEC calculus for scalar and vector quantities 561 (J.W. Eastwood) 562 563\item PHYSOP additional support for non-commuting quantities (Mathias Warns) 564 565\item PM general algebraic pattern matcher (Kevin McIsaac) 566 567\item REACTEQN manipulation of chemical reaction systems (Herbert Melenk) 568 569\item RLFI, TRI TeX and LaTeX output (Richard Liska, Ladislav Drska, 570Werner Antweiler) 571 572\item ROOTS roots of polynomials (Stanley L. Kameny) 573 574\item SCOPE optimization of numerical programs (J. A. van Hulzen) 575 576\item SPDE symmetry analysis for partial differential equations 577 (Fritz Schwarz) 578 579\item SPECFN special functions (Chris Cannam et al.) 580 581\item SPECFN2 special special functions (Victor Adamchik, 582Winfried Neun) 583 584\item SUM sum and product of series (Fuji Kako) 585 586\item SYMMETRY symmetry-adapted bases and block diagonal forms of 587symmetric matrices (Karin Gatermann) 588 589\item TAYLOR multivariate Taylor series (Rainer Sch\"opf) 590 591\item TPS univariate Taylor series with indefinite order 592 (Alan Barnes, Julian Padget) 593 594\item WU Wu algorithm for polynomial systems (Russell Bradford) 595\end{itemize} 596\section{Examples} 597 598Polynomials, rational functions: 599 600\begin{verbatim} 601coeff(X**3 + 3*X**2*Y + 3*X*Y**2 + Y**3,x); 602 603 3 2 604{Y ,3*Y ,3*Y,1} 605 606gcd(X**2 + 4*X + 3,X**2 - 2*X - 3); 607 608X + 1 609 610resultant(X**2 + 4*X + 3,X**2 - 2*X - 3,x); 611 6120 613 614decompose(x**6+6x**4+x**3+9x**2+3x-5); 615 616 2 3 617{U + U - 5,U=X + 3*X} 618 619factorize(x**6+6x**4+x**3+9x**2+3x); 620 621 2 3 622{X,X + 3,X + 3*X + 1} 623 624roots(x**6+6x**4+x**3+9x**2+3x-5); 625 626{X=0.543562, X=-0.775167, X=-0.27178+1.79488*I, 627 X=-0.27178-1.79488*I, X=0.38758+1.8576*I, 628 X=0.38758-1.8576*I} 629 630interpol({0,7,26,63},z,{1,2,3,4}); 631 632 3 633Z - 1 634 635\end{verbatim} 636partial fraction decomposition: 637\begin{verbatim} 638pf(2/((x+1)^2*(x+2)),x); 639 640 2 - 2 2 641{-------,-------,----------} 642 X + 2 X + 1 2 643 (X + 1) 644 645\end{verbatim} 646Matrices: 647\begin{verbatim} 648 m:=mat((1,x),(2,y)); 649 650 [1 X] 651M := [ ] 652 [2 Y] 653 654 655 1/m; 656 657[ - Y X ] 658[--------- ---------] 659[ 2*X - Y 2*X - Y ] 660[ ] 661[ 2 - 1 ] 662[--------- ---------] 663[ 2*X - Y 2*X - Y ] 664 665 det m; 666 667 - 2*X + Y 668 669\end{verbatim} 670Ordinary differential equations: 671\begin{verbatim} 672odesolve(df(y,x)=y+x**2+2,y,x); 673 674 X 2 675{Y=E *ARBCONST(1) - X - 2*X - 4} 676 677\end{verbatim} 678Linear system (hidden): 679\begin{verbatim} 680 solve({(a*x+y)/(z-1)-3,y+b+z,x-y}, 681 {x,y,z}); 682 683 - 3*(B + 1) 684{{X=--------------, 685 A + 4 686 687 - 3*(B + 1) 688 Y=--------------, 689 A + 4 690 691 - A*B - B + 3 692 Z=----------------}} 693 A + 4 694 695\end{verbatim} 696Transcendental equations: 697\begin{verbatim} 698 solve(a**(2*x)-3*a**x+2,x); 699 700 2*ARBINT(2)*I*PI 701{X=------------------, 702 LOG(A) 703 704 LOG(2) + 2*ARBINT(3)*I*PI 705 X=---------------------------} 706 LOG(A) 707 708\end{verbatim} 709Polynomial systems: 710\begin{verbatim} 711 712solve( 713 { a*c1 - b*c1**2 - g*c1*c2 + e*c3, 714 -g*c1*c2 + (e+t)*c3 -k*c2, 715 g*c1*c2 + k*c2 - (e+t) * c3}, 716 {c3,c2,c1}); 717 718{{C1=ARBCOMPLEX(2), 719 720 C1*(-C1*B*E-C1*B*T+A*E+A*T) 721C2=---------------------------, 722 C1*G*T-E*K 723 724 2 725 C1*(-C1 *B*G+C1*A*G-C1*B*K+A*K) 726C3=-------------------------------}} 727 C1*G*T-E*K 728 729 730\end{verbatim} 731Structural analysis: 732\begin{verbatim} 733compact(s*(1-(sin x**2)) 734 +c*(1-(cos x)**2) 735 +(sin x)**2+(cos x)**2, 736 {cos x^2+sin x^2=1}); 737 738 2 2 739SIN(X) *C + COS(X) *S + 1 740 741\end{verbatim} 742Calculus: 743\begin{verbatim} 744 745 df(exp(x**2)/x,x,2); 746 747 2 748 X 4 2 749 2*E *(2*X - X + 1) 750----------------------- 751 3 752 X 753 754 int(x^3*exp(2x),x); 755 756 2*X 3 2 757 E *(4*X - 6*X + 6*X - 3) 758------------------------------ 759 8 760 761 limit(x*sin(1/x),x,infinity); 762 7631 764\end{verbatim} 765Series: 766\begin{verbatim} 767on rounded; taylor(sin(x+1),x,0,4); 768 7690.8414709848079 + 0.5403023058681*X 770 3 771- 0.420735492404*X - 0.09005038431136*X 772 4 773+ 0.03506129103366*X + ... 774 775sum(n,n); 776 777 N*(N + 1) 778----------- 779 2 780 781prod(n/(n+2),n); 782 783 1 784-------------- 785 2 786 N + 3*N + 2 787\end{verbatim} 788Complex numbers: 789\begin{verbatim} 790 791 w:=(x+3*i)**2; 792 793 2 794W := X + (6*I)*X - 9 795\end{verbatim} 796Rounded numbers: 797\begin{verbatim} 798precision 25; pi**2; 799 8009.869 60440 10893 58618 83449 1 801\end{verbatim} 802Modular numbers: 803\begin{verbatim} 804on modular; setmod 17; (x-1)**2; 805 806 2 807X + 15*X + 1 808 809factorize ws; 810 811{X + 16,X + 16} 812\end{verbatim} 813\begin{thebibliography}{9} 814 815\item F. Brackx, D. Constales: Computer Algebra with 816{\small LISP} and {\small REDUCE}, Kluwer, 1991 817 818\item J.H. Davenport, Y. Siret, E. Tournier: Computer Algebra, 819second printing, Academic Press, London, 1989 820 821\item Anthony C. Hearn: {\small REDUCE} User's Manual, Version 3.6, 822The Rand Corporation, Santa Monica (CA), 1995 823 824\item F. W. Hehl, V. Winkelmann, H. Meyer: 825{\small REDUCE}, ein Kompaktkurs \"uber die Anwendung von Computer-Algebra, 826(in German), Springer 1993 827 828\item Malcolm MacCallum, Francis Wright: 829Algebraic Computing with {\small REDUCE}, 830Oxford University Press, 1991 831 832\item Norman MacDonald: {\small REDUCE} for physicists, 833Institute of Physics Publishing, Bristol, UK, 1994 834 835\item Gerhard Rayna, {\small REDUCE}, Software for Algebraic Computation, 836Springer, New York, 1987 837 838\item D.Stauffer, F.W.Hehl, N.Ito, V.Winkelmann, J.G.Zabolitzky: 839 Computer Simulation and Computer Algebra, Lectures for Beginners, 840 third enlarged edition, Springer 1993 841 842\bibitem W.-H. Steeb. D. Lewien: Algorithms and Computation with 843{\small REDUCE}, BI Wissenschaftsverlag, 1992 844 845\item J. Ueberberg: Einf\"uhrung in die Computeralgebra 846mit {\small REDUCE}(in German), BI Wissenschaftsverlag, 1992 847 848\item {\small REDUCE} Network Library, Bibliography, 849reduce-library@rand.org, permanently updated 850\end{thebibliography} 851This document was produced by: 852\vspace*{-5mm} 853\begin{verbatim} 854Konrad-Zuse-Zentrum fuer Informationstechnik 855 - Symbolik 856Heilbronner Str 10 857D 10711 Berlin Wilmersdorf 858Germany 859\end{verbatim} 860\end{document} 861