updatesv53
New features that have been added to Maple V for Release 3 ----------------------------------------------------------Development of Improved User Interfaces=======================================Most of the improvements and work done for this release has been to make theuser interfaces consistent across the main platforms, namely under Windowson the PC, the Macintosh, and under X Windows on Unix platforms. Many smallimprovements and fixes have been made. The new interfaces provide more toolsand support for getting output from parts of worksheets into PostScript filesfor preparing LaTeX documents and books.Graphics========Most of the improvements in the rendering software have been to fix problemson the various platforms. New plotting facilities include.1: Plotting discontinuities---------------------------A facility for identifying discontinuities in an algebraic expression.For example> plot( tan(x), x = -10..10, y=-4..4, discont = true );> plot( -1.5 + Heaviside(x) + Heaviside( 2 - x ), x=-5..5, discont = true );2: Statistical plotting routines--------------------------------New statistical plotting routines.> with(stats[statplots]); [boxplot, histogram, notchedbox, quantile, quantile2, scatter1d, scatter2d, symmetry, xscale, xshift, xyexchange]See section below on stats package for examples.3: New options--------------See ?plot,options and ?plot3d,options and ?plot3d,structure for details.- contours=n specifies the number of contour lines to be drawn- thickness=n where n is 0,1,2, or 3 for changing line thickness- symbol=s specifies how a point is to be displayed where s is one of BOX, CROSS, CIRCLE, POINT, or DIAMOND- font=f for changing the font of a TEXT object where f is a list of the form [family, style, size], family is one of TIMES, COURIER or HELVETICA}, style is one of BOLD, BOLDOBLIQUE, ITALIC, or BOLDITALIC and var is the point size.New and Enhanced Mathematical Facilities========================================1: Definite Integration-----------------------Work is proceeding on generalizing certain classes of integrals which yieldsolutions in terms of special functions. This solution of the followingintegral is computed in terms of the Beta function and its derivative withrespect to its first argument.> f:=(x^(-1/3))*ln(x)*((1-x)^(1/2)):> Int(f,x=0..1) = simplify(int(f,x=0..1)); 1 / 1/2 | ln(x) (1 - x) | ---------------- dx = 3/98 | 1/3/ x0 1/2 (- 42 gamma + 7 Pi 3 - 63 ln(3) - 288 - 42 Psi(1/6)) GAMMA(2/3) GAMMA(5/6) ----------------------------------------------------------------------------- 1/2 PiThe solution of this integral involves the Beta and hypergeometric functions.> assume(a>0): assume(b<0):> f:=x^(a-1)*(1-Kt*x)^(-b):> Int(f,x=0..1) = int(f,x=0..1); 1 / | (a - 1) (- b) Beta(a, 1) a | x (1 - Kt x) dx = -------------------- | b / (a - b) (1 - Kt) 0 Beta(a, 1) a - ----------------------- b Kt (a - b) (1 - Kt) Beta(a, 1) a hypergeom([a - 1, b], [a], Kt) + ------------------------------------------------ Kt (a - b)Is the answer correct? We include one numerical check by comparing the formulaobtained with the result from numerical integration at some particular values.> subs(a=1/2,Kt=1/3,b=-6,"); 1 / 6 | (1 - 1/3 x) | ------------ dx = | 1/2 / x 0 128 - ---- Beta(1/2, 1) + 3/13 Beta(1/2, 1) hypergeom([-6, -1/2], [1/2], 1/3) 9477> simplify("); 1 / 6 | (x - 3) 845440 1/729 | -------- dx = ------ | 1/2 729729 / x 0> evalf("); 1.158567084 = 1.158567084> a := 'a': b := 'b':2: Indefinite Integration-------------------------Maple now knows how to integrate some Bessel Functions, for example> int(x^9*BesselY(3,2*x^2),x); 8 2 2 x BesselY(4, 4 x )> assume(a>0):> int( x^(2*a)*BesselJ(a,x)*BesselJ(a-1,x),x); (2 a + 1) 1/4 x (BesselJ(a, x) BesselJ(a - 1, x) + BesselJ(a + 1, x) BesselJ(a, x))/a> a := 'a':Maple now supports Hermite reduction for integrals of the form / | p(x) | f( u x + v) ----- dx | q(x) /where f is either exp, ln, sin or cos and p(x) and q(x) are polynomials.Examples> f := exp(-z)/z^2/(z^2 + 6*z + 6)^2:> Int(f,z) = int(f,z); / 2 | exp(- z) exp(- z) (2 + 5 z + z ) | ------------------ dz = - 1/12 ----------------------- + 1/12 Ei(1, z) | 2 2 2 2 / z (z + 6 z + 6) (z + 6 z + 6) z> f := exp(-z)/z/(z+1)/(z^3 + 2):> Int(f,z) = int(f,z); / | exp(- z) | ------------------ dz = - 1/2 Ei(1, z) + exp(1) Ei(1, z + 1) | 3 / z (z + 1) (z + 2) / ----- 2 | (2 + 2 _R1 + _R1 ) exp(_R1) Ei(1, z + _R1)| - | ) 1/6 ------------------------------------------| | / 2 | | ----- _R1 | \R1 = %1 / 3 %1 := RootOf(_Z - 2)> f := ln(x)/x/(x^2+1)^2:> Int(f,x) = int(f,x); / | ln(x) 2 | ----------- dx = 1/2 ln(x) + 1/2 Pi arctan(x) + 1/2 dilog(- I x) | 2 2 / x (x + 1) 2 2 ln(x) x + 1/2 dilog(I x) + 1/4 ln(x + 1) - 1/2 -------- 2 x + 1> f := sin(z)/(z^3-z-1):> Int(f,z) = int(f,z); / ----- | sin(z) Si(z - _R1) cos(_R1) + Ci(z - _R1) sin(_R1) | ---------- dz = ) ------------------------------------------- | 3 / 2 / z - z - 1 ----- 3 _R1 - 1 _R1 = %1 3 %1 := RootOf(_Z - _Z - 1)3: signum(0) = ?----------------The definition of signum has changed so that signum(0) is now undefined bydefault. The value of signum(<expr which evaluates to 0>) will return aresult which could be 0 or any complex number of magnitude 1. Why not simplydefine signum(0) to be 0? Or 1 as it was previously? Because any specificdefinition will not permit certain desirable simplifications from takingplace. For example, the transformation signum(abs(x)) ==> 1would be wrong at x=0 if signum(0)=0. Similarly, for real x and y, thetransformation signum(x y) ==> signum(x) signum(y)would be wrong for x<0 and y=0 if signum(0)=1. Yet both simplificationsare desired in many contexts e.g. definite integration. Thus making thevalue of signum(0) undefined appears to be the most useful definition.The value of signum(0) can however be fixed, either by assigning to theenvironment variable \Envsignum0 or by using a 3-argument form of signum: signum(0,<expr>,s).This will evaluate signum(expr) under the assumption that signum(0)=s .The leading argument "0" specifies that the 0'th derivative of signum is beingcomputed. The csgn function (complex sign) been modified in the same way.Examples> assume(y,real);> signum(abs(x)), signum(-2*x^2), signum(-2*y^2); # using signum(0)=undefined 2 1, - signum(x) , -1> _Envsignum0 := 0; # using signum(0)=0> signum(abs(x)), signum(-x^2), signum(-2*y^2); 2 2 signum(abs(x)), - signum(x) , - signum(y)> _Envsignum0 := 1; # using the old behavior> signum(abs(x)), signum(-x^2), signum(-2*y^2); 2 2 1, signum(- x ), signum(- y )> y := 'y': # clear y4: Laplace transforms---------------------The laplace functions have been extended to handle convolutions. E.g. given> f := laplace(F(t),t,s):> g := laplace(G(t),t,s):> h := laplace(H(t),t,s):Direct convolutions> invlaplace(f*g,s,t); t / | | G(_U1) F(t - _U1) d_U1 | / 0> laplace(",t,s); # check answer laplace(F(t), t, s) laplace(G(t), t, s)> invlaplace(f*g*h,s,t); t _U1 / / | | | | H(_U3) G(_U1 - _U3) d_U3 F(t - _U1) d_U1 | | / / 0 0> invlaplace(exp(s)*f,s,t); # case where one of the products has a transform Heaviside(t + 1) F(t + 1)> laplace(",t,s); laplace(F(t + 1), t, s)> invlaplace(exp(-s)*f,s,t); Heaviside(t - 1) F(t - 1)> invlaplace(s*f,s,t); # derivative case for convolution / d |---- F(t)| + F(0) Dirac(t) dt /> laplace(",t,s); s laplace(F(t), t, s)> invlaplace(1/(s - 1)*f,s,t); # integration case of convolution t / | | exp(_U) F(t - _U) d_U | / 0> laplace(",t,s); laplace(F(t), t, s) ------------------- s - 15: RootOf---------The value RootOf(a(x)=0,x) specifies a root of a(x). This is used torepresent algebraic numbers and functions in Maple that cannot be expressedin terms of radicals. RootOf(a(x)=0,x) represents any of the roots.The extension in the new version (for algebraic numbers) RootOf(a(x)=x,x,z)specifies the complex root of a(x) which is near the numerical approximation z.For example (further examples are given below for minimize and solve)> RootOf(x^4-2,x,+1.2); 4 RootOf(_Z - 2, 1.2)> evalf("); 1.189207115An example of a series expansion> series(RootOf(x^4+k*x-16, x, 2.001*I), k); 2 2 2 RootOf(_Z + 4, 2.001 I) + 1/16 k + 1/2048 RootOf(_Z + 4, 2.001 I) k 2 4 5 6 + 7/8388608 RootOf(_Z + 4, 2.001 I) k - 1/8388608 k + O(k )7: The minimize command-----------------------The definition of minimize now supports the option infinite which meansminimize will minimize over the closed real interval [infinity,infinity].The default is to minimize over (-infinity,infinity). For example> f := x^3-5*x^2+4; 3 2 f := x - 5 x + 4> minimize(f,x); 392 - --- 27> minimize(f,x,infinite); - infinityFor polynomials, if the minimum cannot be expressed in terms of radicals, itis now expressed in the RootOf notation where the root is identified as thesecond argument. For example> g := x^4-x+4; 4 g := x - x + 4> minimize(g,x); 3 - 3/4 RootOf(4 _Z - 1, .6299605249) + 4> evalf("); 3.527529606Also, minimize supports minimization over ranges, for example> minimize( -2*y^2/((y-x^2)^4+1)+x^2+y^2, {x,y}, {x=-1..1,y=-1..1} ); 10 6 8 2 4 - 1/4 %1 - 5/2 %1 + 5/4 %1 - 1/2 %1 + 5/2 %1 - 1/2 %1 := RootOf( 2 4 6 8 10 12 14 16 - 4 + 8 _Z + 16 _Z - 56 _Z + 72 _Z - 56 _Z + 28 _Z - 8 _Z + _Z , -.6891910084)> evalf("); -.38378936986: Solving algebraic equations------------------------------A new method for solving large systems which have algebraic functionssolutions. A better method for finding the solutions during back substitutionnot rationalizing the algebraic functions. An example of such a system> e1 := H1^2 + (2*H2*H3/3 + H3^2*x1/3) *(x3 - 3/2*x1*x2 + x1^3/2):> e2 := 2*H1*H2 - H2*H3*(x1^2 - x2) + H3^2*(-x1/2*(x1^2 - x2) +> (x3 - 3/2*x1*x2 + x1^3/2)/3):> e3 := 2*H1*H3 + H2^2 + 2*H2*H3*x1 + H3^2*(x1^2 + x2)/2:> eqns := {0 = a1 + a2*H1 + a3*e1, 1 = a2*H2 + a3*e2, 0 = a2*H3 + a3*e3}:where we want to solve for H1,H2,H3 where the solutions are algebraicfunctions of the parameters a1,a2,a3,x1,x2,x3. The solutions involve theroots of an irreducible polynomial over degree 8.Solving with radicals improved in general and also selects correct roots> solve( sqrt(x+2)-sqrt(2*x-1)=1 ); 1/2 6 - 2 7> solve( {x^2-y+2, x*y=sqrt(75), x-sqrt(3)+y-5}, {x,y} ); 1/2 {x = 3 , y = 5}Added power in solving systems of trigonometric equations> e1 := x - (l1*cos(t1) + l2*cos(t1+t2)):> e2 := y - (l1*sin(t1) + l2*sin(t1+t2)):> solve({e1,e2}, {t1,t2});{t1 = 2 arctan(%1), 3 2 2 2 2 t2 = - 2 arctan((%1 x + %1 l1 x + 2 %1 l1 x - %1 l2 x + %1 y x 2 3 2 2 2 / 2 2 3 + 2 %1 y l1 - y - x y + l2 y - l1 y) / (%1 x y - %1 l2 y + %1 y / 2 2 2 2 3 - %1 y l1 + 2 %1 y l1 l2 + 2 l1 x l2 + y x - l2 x - l1 x + x )) } 2 2 2 2 2 2 2 2 %1 := RootOf((l1 + 2 l1 x - l2 + y + x ) _Z - 4 _Z y l1 + x + y - l2 2 - 2 l1 x + l1 )Equations involving RootOfs are now handled more generally. For example,here is an algebraic function in a.> r := RootOf(x^2+a*x+1,x):> solve( r^2+1/r=a^2-1/a, a); 4 3 2 RootOf(2 _Z + 2 _Z + 1 - 2 _Z + _Z )More generality in the solutions of inequations> solve( x^3+x > 5-2/x ); 4 2 {0 < x, x < RootOf(- 5 _Z + 2 + _Z + _Z , .4482633973)}, 4 2 {RootOf(- 5 _Z + 2 + _Z + _Z , 1.292690487) < x}8: Complex evaluation of the Riemann Zeta function---------------------------------------------------Complex numerical evaluation of the Riemann Zeta function and its derivativeshas been implemented. Note, Zeta(n,z) is the nth derivative of Zeta(z) andZeta(n,z,q) is the nth derivative of the generalized Zeta function Zeta(0,z,q).For Zeta(0,z,q), for Re(z)<0 the index q is limited to the range 0<q le 1, andfor Zeta(n,z,q), is only available for Re(z)>0. Examples> Zeta(3.5+4.5*I); .9241880340 + .01456451995 I # The 1st non-trivial 0 (approx):> Zeta(1/2+14.13472514*I); -9 -8 .2163160213*10 - .1358779595*10 I # Derivatives:> Zeta(7, -3.5+1.9*I); .01231658152 + .01218445174 I # 2 argument Zeta (aka, Generalized zeta function, aka Hurwitz zeta function):> Zeta(0,3.5+4.5*I,.3); 43.96655549 - 51.81043075 I # Derivatives:> Zeta(5,3.5+2.7*I, .7); - .0002070976852 - .03085254975 I9: Polynomial factorization over finite fields----------------------------------------------Maple V Release 3 can factor univariate polynomials over GF(p^k).Maple represents elements of GF(p^k) as polynomials in alpha where alpha is aRootOf an irreducible polynomial. In the following example, elements ofGF(3^3) are represented as polynomials over GF(2) modulo the x^2+2*x+2.This polynomial representation does not place any restriction on the size ofthe field, and it is quite feasible to compute large fields e.g. GF(2^{128}).Here is a univariate factorization> alias( alpha=RootOf(x^2+2*x+2) ):> f := 2*alpha*x^3+(2+2*alpha)*x^2+(alpha+2)*x+1; 3 2 f := 2 alpha x + (2 + 2 alpha) x + (alpha + 2) x + 1> Factor(f) mod 3; 2 alpha (x + alpha + 2) (x + 1 + 2 alpha) (x + alpha)Release 3 can now factor multivariate polynomials over finite fields.> f := x^3+alpha*x^2*y+alpha^2*x*y^2+alpha^3*y^3; 3 2 2 2 3 3 f := x + alpha x y + alpha x y + alpha y> Factor(f) mod 3; (y + (alpha + 2) x) (y + alpha x) (y + 2 alpha x)In prior releases we have been using the Cantor-Zassenhaus algorithm forfactorization of univariate polynomials over GF(p) (p prime) and Berlekampsalgorithm for GF(p^k) for k>1. For GF(p) for large modulus p, Berlekampsalgorithm performs better in general. We timed the two methods on thefollowing problem taken from an article by von zur Gathen from the SIGSAMBulletin (Vol 26, No. 2, April 1992.), namely to factor the polynomialx^n + x + 1 mod p for p=3982441812995697363688351114001.We found that Berlekamps algorithm was approx. 2.6 times faster thanthe Cantor-Zassenhaus algorithm as implemented in Maple. More detailscomparing the two algorithms on von zur Gathen's tests can be found ina follow up article by Michael Monagan in the SIGSAM Bulletin(Vol 27, No. 2, April 1993). Note both algorithms are implemented forunivariate factorization over GF(p^k) as well as GF(p).10: Manipulation of sums, products, integrals and limits--------------------------------------------------------We have provided more tools for manipulating unevaluated sums, integrals,products and limits. The expand and simplify commands will applythe following transformations expand( F( a * f(x), ... ) ) ==> normal(a) * F(expand(f(x)), ...) simplify( F( a * f(x), ... ) ) ==> simplify(a) * F(simplify(f(x)), ...))where F is any of sum, int, limit, product, Sum, Int, Limit, Product.For example> f := Int( sqrt(a)/Pi*exp(-u*x^2)*x^2, x ):> f = expand(f); / 2 1/2 | x a | --------- dx / 1/2 2 2 | 2 | a exp(- u x ) x / exp(u x ) | ------------------- dx = --------------------- | Pi Pi /> g := sum( a[i]*i/2^n, i=1..n ):> g = simplify(g); n / n ----- |----- | a[i] i (- n) | | ) ------ = 2 | ) a[i] i| / n | / | ----- 2 |----- | i = 1 i = 1 /Differential Equations======================1: DESol - Solutions of Differential Equations----------------------------------------------We have introduced a new structure DESol for representing the solutionsof differential equations (DEs). It has the following structure DESol( differential equation(s), variable(s), initial condition(s) )The DEs can be described either functionally using the D operator, or as anexpression using the diff command. For example, the followingdescribes the solutions to the equation y'' + y = 0.> DESol( D(D(y)) = -y, y ); (2) de1 := DESol({D (y) + y}, {y})> DESol( diff(y(x),x,x) + y(x), y(x), {y(0)=0, D(y)(0)=1} ); / 2 | d | de2 := DESol({|----- y(x)| + y(x)}, {y(x)}) | 2 | dx /The purpose of DESol is to allow Maple to represent and manipulate thesolution of a DE symbolically without first computing it's solution in closedform -- which often is not possible. The DESol structure then is ratherlike the RootOf structure in Maple which represents a solution to analgebraic equation. Presently Maple knows how to differentiate, integrate,generate a series expansion, and numerically evaluate a DESol. Examples> de := DESol( D(y)-a*y=1, y ); de := DESol({D(y) - a y - 1}, {y})> D(de); a DESol({D(y) - a y - 1}, {y}) + 1> de(x); / d DESol({|---- y(x)| - a y(x) - 1}, {y(x)}) dx /> int( 1/de(x), x ); / d ln(DESol({|---- y(x)| - a y(x) - 1}, {y(x)})) dx / / d - ln(a DESol({|---- y(x)| - a y(x) - 1}, {y(x)}) + 1) dx /Series of DESol (simple ones) are now handled. By simple we mean that aTaylor series can be computed using the derivatives of the DE. This, togetherwith the use of initial conditions, gives nice results. For example> series(de(x),x=0); 2 2 3 y(0) + (1 + a y(0)) x + 1/2 a (1 + a y(0)) x + 1/6 a (1 + a y(0)) x 3 4 4 5 6 + 1/24 a (1 + a y(0)) x + 1/120 a (1 + a y(0)) x + O(x )> de := DESol( diff(x(t),t,t) = g/l*sin(x(t)), x(t), {x(0)=0, D(x)(0)=v0} ):> series(de,t=0); / 3 2 g v0 3 | g v0 g v0| 5 6 v0 t + 1/6 ---- t + |- 1/120 ----- + 1/120 -----| t + O(t ) l | l 2 | l /2: The use of RootOfs---------------------For ODEs where the characteristic polynomial cannot be factored, Maple nowexpresses the solution in terms of the roots of the characteristic polynomialusing a RootOf. Example> ode := diff(y(x),x5 ) + 2*diff(y(x),x) + 2*y(x) = 0; / 5 | d | / d ode := |----- y(x)| + 2 |---- y(x)| + 2 y(x) = 0 | 5 | dx / dx /> dsolve(ode,y(x)); ----- y(x) = ) _C1[_R] exp(_R x) / ----- _R = %1 5 %1 := RootOf(2 + 2 _Z + _Z )> ode := diff(y(x),x6) + 4*diff(y(x),x4) +> 4*diff(y(x),x3) + 4*diff(y(x),x2) + 8*diff(y(x),x):> dsolve(ode,y(x)); / ----- 1/2 1/2 | | y(x) = _C2 + _C3 cos(2 x) + _C4 sin(2 x) + | ) _C1[_R] exp(_R x)| | / | | ----- | \R = %1 / 3 %1 := RootOf(_Z + 2 _Z + 4)3: Bessel's Equation--------------------Maple now handles Bessel's equation shifted from the origin.> ode := diff(y(x),x,x) + (4*k+1)/(x+2)*> diff(y(x),x) + (4*(x+2)^6 + 3/(x+2)^2)*y(x); / d / 2 (4 k + 1) |---- y(x)| | d | dx / / 6 3 ode := |----- y(x)| + --------------------- + |4 (x + 2) + --------| y(x) | 2 | x + 2 | 2| dx / (x + 2) /> dsolve(ode,y(x));bytes used=2005608, alloc=1310480, time=6.73 2 (- k) 2 1/2 4 y(x) = _C1 (x + 4 x + 4) BesselJ(1/4 (4 k - 3) , 1/2 (x + 2) ) 2 (- k) 2 1/2 4 + _C2 (x + 4 x + 4) BesselY(1/4 (4 k - 3) , 1/2 (x + 2) )4: Exponential solutions of ODEs--------------------------------We have implemented the exponential linear ODE algorithm of Manuel Bronstein(Reference ``Linear Ordinary Differential Equations: Breaking Throughthe Order 2 Barrier'', Manuel Bronstein, Proceedings of ISSAC '92, ACM Press.)This algorithm finds solutions whose logarithmic derivative is in thecoefficient field, i.e. y'(x)/y(x) is a rational function. This includessolutions which themselves lie in the coefficient field. For example> ode := (-2*x^2+x+n^2)*y(x)+(4*x^2-2*x-n^2)*diff(y(x),x)+> (-3*x^2+x)*diff(y(x),x2)+x^2*diff(y(x),x3); 2 2 2 2 / d ode := (- 2 x + x + n ) y(x) + (4 x - 2 x - n ) |---- y(x)| dx / / 2 / 3 2 | d | 2 | d | + (- 3 x + x) |----- y(x)| + x |----- y(x)| | 2 | | 3 | dx / dx /> dsolve(ode,y(x));y(x) = / / | | _C1 exp(x) + _C2 exp(x) | BesselJ(n, x) dx + _C3 exp(x) | BesselY(n, x) dx | | / /> subs(n=1,ode); 2 2 / d (- 2 x + x + 1) y(x) + (4 x - 2 x - 1) |---- y(x)| dx / / 2 / 3 2 | d | 2 | d | + (- 3 x + x) |----- y(x)| + x |----- y(x)| | 2 | | 3 | dx / dx /> dsolve(",y(x)); y(x) = _C1 exp(x) + _C2 exp(x) BesselJ(0, x) + _C3 exp(x) BesselY(0, x)> ode := diff(y(x),x2) + 3/x*diff(y(x),x) + (x^2-143)/x^2*y(x)-1/x; d / 2 ---- y(x) 2 | d | dx (x - 143) y(x) ode := |----- y(x)| + 3 --------- + --------------- - 1/x | 2 | x 2 dx / x> dsolve(ode,y(x)); 2 4 6 8 y(x) = (980995276800 + 22295347200 x + 278691840 x + 2580480 x + 20160 x 10 12 / 13 _C1 BesselJ(12, x) _C2 Y(12, x) + 144 x + x ) / x + ------------------ + ------------ / x x5: Solutions in terms of DESol------------------------------If the solution cannot be computed in closed form, we can now return it interms of the DESol data structure.> ode := diff(y(x),x,x) + diff(y(x),x)*x^2 + y(x)*x; / 2 | d | / d 2 ode := |----- y(x)| + |---- y(x)| x + y(x) x | 2 | dx / dx /> dsolve(ode,y(x)); / 2 | d | 2 / d y(x) = DESol({|----- _Y(x)| + x |---- _Y(x)| + x _Y(x)}, {_Y(x)}) | 2 | dx / dx /This example shows a case where a partial solution is obtained using ManuelBronstein's algorithm.> ode := diff(y(x),x3) + 4*diff(y(x),x,x) + 4*diff(y(x),x) - 12*y(x)/x; / 3 / 2 | d | | d | / d y(x) ode := |----- y(x)| + 4 |----- y(x)| + 4 |---- y(x)| - 12 ---- | 3 | | 2 | dx / x dx / dx /> dsolve(ode,y(x)); / 2 3 2 3 | y(x) = _C1 (27 x + 24 x + 4 x ) + (27 x + 24 x + 4 x ) | DESol( | / / 2 2 3 | d | {(27 x + 24 x + 4 x ) |----- _Y(x)| | 2 | dx / 2 3 / d + (252 x + 132 x + 16 x + 81) |---- _Y(x)| dx / 2 3 + (564 x + 192 x + 16 x + 360) _Y(x)}, {_Y(x)}) dx6: Solution Basis-----------------An alternative output form is available in terms of a basis. For example> ode := 2*diff(y(x),x,x) + 3*diff(y(x),x) + y(x) - exp(-3*x); / 2 | d | / d ode := 2 |----- y(x)| + 3 |---- y(x)| + y(x) - exp(- 3 x) | 2 | dx / dx /> dsolve(ode,y(x),output=basis); [[exp(- x), exp(- 1/2 x)], 1/10 exp(- 3 x)]7: Numerical Solutions----------------------The output form now returns a list for every point (rather than a set).> p := dsolve( {diff(y(x),x) = -y(x),y(0)=1},y(x),type=numeric);p := proc(rkf45_x) ... end> p(1); [x = 1, y(x) = .3678794379225918]Alternatively, the output can be a list of procedures> p := dsolve({diff(x(t),t)=y(t),diff(y(t),t)=x(t)+y(t),x(0)=2,y(0)=1},> {x(t),y(t)}, type=numeric, output=listprocedure); p := [t = proc(t) ... end, x(t) = proc(t) ... end, y(t) = proc(t) ... end]Now pick off the desired procedures and make a parametric plot.> X := subs(p,x(t)): Y := subs(p,y(t)):> plot([X,Y,0..3]);A new numerical algorithm called dverk78 of W. Enright has been implementedwhich guarantees a preset accuracy for the answer.8: Series Solutions-------------------The series option to dsolve now accepts non-zero initial conditions, e.g.> Order := 3:> dsolve(diff(y(x),x2) - y(x) = 1, y(x),series); 2 3 y(x) = y(0) + D(y)(0) x + (1/2 + 1/2 y(0)) x + O(x )> dsolve({diff(y(x),x2) - y(x) = 1,y(1)=y(1)},y(x),series); 2 3y(x) = y(1) + D(y)(1) (- 1 + x) + (1/2 + 1/2 y(1)) (- 1 + x) + O((- 1 + x) )Sqrt and Radical Simplifications================================1: Automatic radical transformations------------------------------------The following transformations that Maple previously made automatically (x*y)^(n/d) ==> x^(n/d)*y^(n/d) e.g. (x*y)^(1/2) ==> x^(1/2)*y^(1/2) (x^r)^(n/d) ==> x^(r*n/d) e.g. (x^2)^(1/2) ==> x, (1/x)^(1/2) ==> 1/x^(1/2)which are incorrect for negative x,y, are no longer made automatically by theinternal Maple simplifier. The only transformations made automatically are (i) reduction of integer powers for integers n,a,b n^(a/b) ==> n^(q+r/b) ==> (n^q)*n^(r/b) e.g. 2^(4/3) ==> 2*2^(1/3) (ii) rational power simplification for integers n,d, and rational r (n/d)^r ==> n^r/d^r e.g. (2/3)^(1/2) ==> 2^(1/2)/3^(1/2) (iii) combining radical powers for rational r, integers n,d (x^r)^(n/d) ==> x^(r*n/d) iff -1<r<1 e.g. (x^(1/2))^(3/2) ==> x^(3/4)2: Radical transformations made by sqrt, combine, simplify and expand---------------------------------------------------------------------The transformations made by the sqrt, simplify, and combine functions tosquare roots and radicals which are not correct for all values ofthe arguments are no longer made. Only provably correct transformations aremade as determined by the signum, csgn, and Re and Im functions. For example,because of the following> signum(Pi-3); 1i.e. Maple has proven this to be positive - it used interval arithmetic - thenthe following simplifications can be made.> f := ((Pi-3)^2*x^2*y)^(1/2); 2 2 1/2 f := ((Pi - 3) x y)> simplify(f); 2 1/2 (Pi - 3) (x y)Because Maple does not know anything about x, it cannot simplify this to(Pi - 3) x sqrt(y). Another example,> f := 2^(1/3)*(x+1)^(1/3)*(y+1)^(1/3); 1/3 1/3 1/3 f := 2 (x + 1) (y + 1)> combine(f,radical); 1/3 1/3 (y + 1) (2 x + 2)Now that transformations that might be incorrect are no longer made, thereneeds to be mechanisms for the user to make these transformations when theyare known to be correct. The user has two options. Using the symbolicoption, the user can force Maple to make the transformation, i.e. effectivelyassuming that the sign of the expressions is positive. Hence> sqrt( (Pi-3)^2*x^2, symbolic ); (Pi - 3) x> sqrt( (3-Pi)^2*x^2, symbolic ); (Pi - 3) x> sqrt( -a^3*b^2*c, symbolic ); 1/2 a b (- c a)This is useful when you are solving an equation and you just need oneroot, the simplest one, and you will construct the other roots from this.For example> solve(x^2+a^3*b^2*c,x); 1/2 1/2 a b (- c a) , - a b (- c a)Alternatively, the user can use the assume facility to tell Maple thatexpressions such as a,b,c here are real, real and positive, real andnegative etc. For example> assume(x>0);> sqrt(x^2*y); 1/2 x y> assume(x,real);> sqrt(x^6); 2 2 1/2 x (x )> simplify("); 3 x signum(x)3: The simplify command------------------------------The code for simplifying expressions containing square roots and general rootshas been improved. Each (square) root is first simplified. The principaltransformation made when a>0 is (a^n*b)^(m/d) = (a^(q+r/d)*b)^(m/d) ==> a^(m*q) * (a^(r/d)*b)^(m/d)For example> f := (a^8*b)^(1/3); 8 1/3 f := (a b)> assume(a>0);> simplify(f,radical); 2 2 1/3 a (a b)Then dependent integer roots are located in the expression.For example in the expression> s := 6^(1/2)-2^(1/2)*3^(1/2)+1; 1/2 1/2 1/2 s := 6 - 3 2 + 1It is determined that sqrt(6) can be written as sqrt(2) sqrt(3) hencethe expression is simplified to> simplify(s,radical); 1Finally, the expression is rationalized. For example, writing the expression> s := (2*x+2)^(3/2)-2*(2*x+2)^(1/2); 3/2 1/2 s := (2 x + 2) - 2 (2 x + 2)as (2 x + 2) S - 2 S, then simplifying this as a rational expression, we obtain> simplify(s,radical); 1/2 2 (2 x + 2) x4: The combine command----------------------Radicals can be combined together with combine(expr,radical); combine(expr,radical,symbolic);The principal transformation made is x^(m/d) * y^(n/d) ==> (x^m*y^n)^(1/d) iff signum(x)>0 or signum(y)>0For example> e := 2^(1/2)*3^(1/2)*(x+1)^(3/2)*y^(3/2); 1/2 1/2 3/2 3/2 e := 2 3 (x + 1) y> combine(e,radical); 3/2 1/2 (x + 1) y (6 x + 6)> combine(e,radical,symbolic); 1/2 (x + 1) y (6 x y + 6 y)5: Denesting of radicals and the radnormal command--------------------------------------------------Nested square roots of the form sqrt(r + s sqrt(n)) where n is an integer,r and s are rationals are denested where possible by the sqrt andsimplify functions. For example> sqrt(3+4*I), sqrt(4-sqrt(12)), sqrt(1/2+sqrt(3)/4); 1/2 1/2 1/2 2 + I, 3 - 1, 1/4 6 + 1/4 2A more powerful facility for denesting and simplifying radicals is availablewith the radnormal command. Presently this facility only works for algebraicnumbers, not algebraic functions. For example> f := sqrt( 2*(3-sqrt(2)-sqrt(3)+sqrt(6)) ); 1/2 1/2 1/2 1/2 f := (6 - 2 2 - 2 3 + 2 6 )> readlib(radnormal)(f); 1/2 1/2 1/2 - 1 + 3 + 1/3 3 66: The rationalize command--------------------------The command rationalize will rationalize an expression containingradicals, i.e. given a rational expression of the form n/d, the result is anew expression n'/d' where no radicals appear in the new denominator d'.For example> f := sqrt(2)/(1+sqrt(3)); 1/2 2 f := -------- 1/2 1 + 3> rationalize(f); 1/2 1/2 1/2 2 (- 1 + 3 )> f := 1/(x^(1/3)+y^(3/2)); 1 f := ----------- 1/3 3/2 x + y> rationalize(f); 3 3/2 1/3 2/3 9/2 (- y + y x - x ) (- x + y ) -------------------------------------- 9 2 - y + x7: The simplify command-----------------------The command simplify(expr,assume=t) will simplify an expression assumingall variables are of type t where t is typically real, positive. For example> f := r^2 * sin (t) / sqrt(x^2+r^2-2*x*r*cos(t));> g := int( int( f, t=0..Pi ), r=0..1 ); 2 3/2 2 1/2 2 2 1/2 g := 1/6 (2 ((1 + x) ) - 3 ((1 + x) ) x - 3 ((1 + x) ) x 2 3/2 2 1/2 2 2 1/2 - 2 ((- 1 + x) ) + 3 ((- 1 + x) ) x - 3 ((- 1 + x) ) x)/x> simplify(g,assume=real); 3 - 1/6 (- 2 signum(1 + x) - 3 signum(1 + x) x + signum(1 + x) x 3 - 2 signum(- 1 + x) + 3 signum(- 1 + x) x - signum(- 1 + x) x )/xNew and Enhanced System Facilities==================================1: Global statement-------------------Procedures may now include an optional global statement which follows thelocal statement in a procedure. For example, the procedureproc(n) local y; global A; y := 1; for i to n do y := x*y; A[i] := y od;end;has one parameter n, one local variable y, and one global variable A. Thevariables i and x are not defined, and in the older versions of Maple, would be assumedto be global variables. In this case, one can guess that x is meant to beglobal and i should be local. In the new version of Maple, in order to reducethe likelihood of errors, if a variable is not defined, then Maple will declareit to be local if (i) it appears on the left hand side of an assignment statement (ii) it is used as an index of a for statement or seq statementotherwise Maple will declare it global. Applying these rules to the aboveprocedure, the undeclared variable i will be declared to be local, and theundeclared variable x will be assumed global. Hence the following actionis taken on the above procedureWarning, i is assumed to be a local variableproc(n) local y,i; global A; y := 1; for i to n do y := x*y; A[i] := y odendThe warning serves as a useful reminder to the user to declare variables.2: Name protection------------------A protection facility has been added to prevent the user from accidentallyassigning to Maple system variables. For example, the names ``list'' and``lhs'' are now protected. Attempting to assign to them will result in> lhs := x^2-1;Error, attempting to assign to lhs which is protected> list := [1,2,3];Error, attempting to assign to list which is protectedA name can be protected using the protect function. For example> height := proc(p,x) local t; max(seq(abs(t),t=[coeffs(p,x)])) end:> protect(height);> height := 1;Error, attempting to assign to height which is protectedNames can be unprotected either by unassigning them, or by using the unprotectfunction. For example> list := 'list':> list := proc() convert([args],'list') end:> list(1,2,3); [1, 2, 3]> unprotect(height);> height := 1; height := 13: march the Maple library archiver------------------------------------------Maple versions now come with a library archive facility called march.This tool can be used to create, insert and update ``.m'' files in a Maplelibrary archive. A Maple library consists of two files, maple.lib andmaple.ind. The maple.lib file contains the Maple code, a set of .m files,and the maple.ind file is a index into the file maple.lib for fast access.This facility yields faster access and is more economical in file space.It also provides a convenient way to distribute a library of Maple codes.The command march -c archiveDir tableSizecreates a Maple archive in the directory <archiveDir> where <tableSize>is an estimate of the number of files to be put in the archive. The commands march -a archiveDir fileName indexName march -u archiveDir fileName indexNameadds, respectively updates, the archive in the directory <archiveDir>with the file <fileName> to be called <indexName> in the archive.There are further options for packing, extracting, removing .m files etc.4: makehelp-----------This utility routine takes as input the name of a file which containsplain text and makes a Maple TEXT object out of a file for use with theon-line help command ? . The resulting TEXT object can be saved into a fileto be included as on-help within a package. See ?makehelp for details5: The fortran command----------------------The fortran function now accepts an optional argumentmode = <modtype> where the mode type must be one of single(the default), double, complex or generic whichspecifies how function names are to be translated. For example> fortran( ln(x)+sin(x) ); t0 = alog(x)+sin(x)> fortran( ln(x)+sin(x), mode=generic ); t0 = log(x)+sin(x)The handling of arrays has been improved (also in the C function)to output subscripts in lexicographical order and if an array entry isnot assigned, the string undefined is output. For example> A := array(symmetric,1..2,1..2,[(1,1)=ln(x),(2,1)=sin(x)]):> fortran(A); A(1,1) = alog(x) A(1,2) = sin(x) A(2,1) = sin(x) A(2,2) = undefined6: The piecewise function-------------------------The piecewise() function allows one to define a function with different formson different intervals. One can also assert a global smoothness at the joints.At present, diff/max and diff/min produce answers in terms of piecewise.For example, the quadratic B-spline is given by the following piecewisequadratic polynomial. The first argument 1 states that the polynomial is C1continuous> b2 := piecewise( 1,> x<0, 0,> x<1, x^2/2,> x<2, -3/2+x*(3-x),> x<3, 9/2+x*(x-3),> 0 # otherwise> ):> diff(b2,x); piecewise(0, x < 0, 0, x < 1, x, x < 2, - 2 x + 3, x < 3, 2 x - 3, 0)7: help=======The following commands have been added to display parts of on-line help files.- The command info(foo) will display the first line of the help file i.e. the FUNCTION line.- The command usage(foo) or ??foo will display the CALLING SEQUENCE section.- The command example(foo) or ???foo will display the EXAMPLES section.- The command related(foo) will display the SEE ALSO section.Note the old example function has been replaced by this functionality.8: String and text processing capabilities------------------------------------------Maple strings now have no limitation on their length. Previously thelength limitation was 499 characters. The SearchText and searchtextfunctions (case sensitive and insensitive respectively) can be used tosearch a string for a pattern. The functionality is searchtext(t,s) searchtext(t,s,a..b)meaning search for the substring t in the string is (optionally startingat position a in the string s ending at position b).> s := `maple and Maple and MAPLE`:> SearchText(`Maple`,s); 11> searchtext(`Maple`,s); 19: The interface command------------------------The version of Maple is available from> interface(version); Maple V, Release 3, Thu Aug 19 15:16:50 MET DST 1993The number of bits in the machine word is available via> interface(wordsize); 32Library Packages================The package mechanism has been extended to support subpackages. This worksin an obvious way and is illustrated by the new stats package below.1: numtheory - number theory package------------------------------------The function factorEQ(m,d) factors the integer m in the Euclidean domainZ[sqrt(d)]. For example> numtheory[factorEQ](38477343,11); 1/2 1/2 1/2 1/2 (3) (125 + 34 11 ) (125 - 34 11 ) (85 + 16 11 ) (85 - 16 11 )The isprime function now uses one strong pseudo primality test andone Lucas test (not known to fail). numtheory[safeprime] has also beenupdated in the same way.We have implemented a new iterative algorithm for numtheory[jacobi]that yields a modest improvement of 15% in running time.2: linalg - linear and vector algebra package---------------------------------------------The functions curl, diverge, grad, and laplacian have been extended to workin spherical, cylindrical, and in orthogonally curvilinear coordinate systemsin general (default cartesian).> with(linalg,curl,grad):> g := [r,sin(theta),z]: v := [r,theta,z]:> curl(g,v,coords=cylindrical); sin(theta) [ 0, 0, ---------- ] r> g := r^2*sin(theta)*cos(phi): v := [r,theta,phi]:> grad(g,v,coords=spherical); [ 2 r sin(theta) cos(phi), r cos(theta) cos(phi), - r sin(phi) ]The functions ihermite, ismith, hermite and smith have been modified tooptionally return the multiplier matrices. That is H := ihermite(A,'U'); and H := hermite(A,x,'U');compute the Hermite normal form matrix H in the Euclidean domains Z andF[x] respectively and assigns U the multiplier matrix such that H = U A.(Hermite normal form is row reduction over a Euclidean ring). Similarly S := ismith(A,'U','V'); and S := smith(A,x,'U','V');compute the Smith normal form S in the Euclidean domains Z and F[x] andassigns U and V the multiplier matrices such that S = U S V.(Smith normal form is row and column reduction over a Euclidean ring).> with(linalg,ismith,ihermite,inverse,hilbert):> A := inverse(hilbert(3)); [ 9 -36 30 ] [ ] A := [ -36 192 -180 ] [ ] [ 30 -180 180 ]> H := ihermite(A,'U'):> print(H,U); [ 3 0 30 ] [ 13 9 7 ] [ ] [ ] [ 0 12 0 ], [ 6 4 3 ] [ ] [ ] [ 0 0 60 ] [ 20 15 12 ]> evalm( H - U &* A ); [ 0 0 0 ] [ ] [ 0 0 0 ] [ ] [ 0 0 0 ]> S := ismith(A,'U','V'):> print(S,U,V); [ 3 0 0 ] [ -3 0 1 ] [ -5 -6 -30 ] [ ] [ ] [ ] [ 0 12 0 ], [ 18 4 -1 ], [ 1 1 0 ] [ ] [ ] [ ] [ 0 0 60 ] [ -10 -5 -3 ] [ 1 1 1 ]> evalm( S - U &* A &* V ); [ 0 0 0 ] [ ] [ 0 0 0 ] [ ] [ 0 0 0 ]Note the new algorithm that is used for Hermite normal forms is, unlike theold algorithm, a polynomial time algorithm, and is in practice much fasterfor larger matrices.4: GaussInt -- Gaussian integer package---------------------------------------The routines GIhermite and GIsmith similarly have been added to compute theHermite and Smith normal forms over the Euclidean domain Z[i]The routines GIchrem implements the Chinese Remainder Algorithm for Z[i]> GaussInt[GIchrem]([5+13*I,15-9*I],[3+4*I,7-11*I]); - 17 + 17 IThe routine GInodiv computes the number of non-associated divisors> GaussInt[GInodiv](2+3*I); 2The Statistics Package stats----------------------------The stats package has been completely redesigned. The data structure for thearguments to the functions has changed. This implies that programs using theprevious version of the stats package will need to be updated.See ?stats[updates] on how to do this.New types of data are now supported in addition to numbers.- Missing data is represented by the keyword `missing'.- Data classes are represented as ranges a..b where the bound a is inclusive and the bound b is exclusive.- Weighted data is represented by the function Weight(data, weight). For example, the following are all valid data: 3, 3..4, missing, Weight(4,6), Weight(missing,7), Weight(3..4,9).The stats package is subdivided into the following subpackages.- describe: for descriptive statistics,- transform: for data transformations,- random: for generating numbers with a particular distribution,- statevalf: for numerical evaluations of statistical functions,- fit: for fitting data to a curve and- statplots: for statistical graphics.and the function importdata} which supplements Maple's other input facilities.Issuing with(stats); defines abbreviations for all the subpackages but not thesubfunctions belonging to them. Then issuing with(describe); definesabbreviations for the functions in the describe subpackage.> with(stats); [describe, fit, importdata, random, statevalf, statplots, transform]> with(describe):Now the following commands all refer to the same function on the data [1,5]> mean([1,5]), describe[mean]([1,5]), stats[describe,mean]([1,5]); 3, 3, 3Certain functions require (and others allow) extra parameters. For example,describe[quartile[1]] is a function that gives the first quartile of thedata. This allows one to do> data:=[1,5,Weight(6,3), 9, 10, 15]; data := [1, 5, Weight(6, 3), 9, 10, 15]> describe[quartile[1]](data); 5Functions like variance allow a parameter to specify if one is computingthe sample variance or the population variance. (The parameter usedthe number to be subtracted from the item count, so variance[0] isthe population variance and variance[1] is the sample variance).1: The descriptive statistics subspackage stats[describe]---------------------------------------------------------Contains the following functions coefficientofvariation, count, countmissing, covariance, decile, geometricmean, harmonicmean, kurtosis, linearcorrelation, mean, meandeviation, median, mode, moment, percentile, quadraticmean, quantile, quartile, range, skewness, standarddeviation, variance.2: The transform subpackage stats[transform]--------------------------------------------Contains apply, classmark, cumulativefrequency, deletemissing, divideby, frequency, moving, multiapply, remove, scaleweight, split, standardscore, statsort, statvalue, tally, tallyinto.The function apply is used to apply a transformation on each observation,whereas moving is to apply a function across a sliding window over the data(and some can be used to smooth data using, for example, a weighted movingmean.) The function split is used to split a list of data into multiplelists, which can be required to be of equal weight. Data are counted withtally and regrouped into a specified pattern (exceptions can be reported ifdesired) with tallyinto.3: Statistical distributions----------------------------The distributions are functions indexed by their parameters. For example,poisson[2] is a Poisson distribution with mean lambda = 2. The followingdistributions are supported: beta, binomiald (binomial), cauchy, chisquare, discreteuniform, empirical, exponential, fratio (variance ratio, Fisher F), gamma, hypergeometric laplaced (Laplace), logistic, lognormal, negativebinomial, normald (normal), poisson, studentst (T distribution), uniform, weibull.Given a distribution, random numbers with that distribution can be obtainedusing the stats[random] subpackage. One can specify the quantity ofnumbers to be generated at once, or that a generator is to be returned.> stats[random,normald[0,1]](5); 1.175839568, -.5633641309, .2353939952, -1.442550291, -1.079196234> T:=stats[random,studentst[3]]('generator'):> seq(T(),i=1..5); -1.749151242, -.5845810002, -2.441129943, -.05425587235, 1.632365981Numerical evaluations of statistical functions are computed by thestats[statevalf] subpackage. For example,> statevalf[pdf, normald](0.5); .3520653266gives the height of the standard normal curve at the value 0.5. Similarly> statevalf[cdf, chisquare[2]](0.6); .2591817793gives the area under the curve of the Chi square with 2 degrees of freedomlying to the left of 0.6. The inverse of this last function is obtained byusing icdf -- inverse cumulative distribution function> statevalf[icdf, chisquare[2]]("); .6000000000Similar facilities are available for discrete distributions.4: The regression subpackage stats[fit]---------------------------------------Provides for regressions. At the present, weighted least square fitsof data to linear models is provided.5: The plotting subpackage stats[statplots]--------------------------------------------Contains various statistical plots and plotting utilities. The result ofthese functions can also be manipulated via the plots[display] function.Example> with(statplots); [boxplot, histogram, notchedbox, quantile, quantile2, scatter1d, scatter2d, symmetry, xscale, xshift, xyexchange]> Xdata := [4.535, 4.029, 5.407, 1.605, 5.757, 3.527, 7.890, 8.159, 6.092,> 13.442, 2.845, 5.172, 3.277, 8.810, 3.657, 7.226, 3.851, 2.162,> 2.668, 4.692]:> Ydata:= [7.454, 4.476, 2.873, 5.476, 9.975,-1.476, 1.033, 1.140, 4.813,> .450, -.788, 9.389, 4.811,-3.107, 4.407, 5.534, 1.691, -.789,> 1.684, 1.605]:> p1 := scatter2d(Xdata,Ydata): p1; # scatter plot> p2 := boxplot[15](Ydata): p2; # boxplot in right margin> p3 := notchedbox[12](Xdata): p3; # notched box at top> plots[display]({ p1, p2,> xyexchange(p3)}, view =[0..17,-4..14], axes=FRAME );Share Library=============The Maple share library is a library of Maple routines (the Maple src codeincluded), Maple worksheets, and accompanying documentation files which havebeen contributed by users of Maple to the Maple user community.The version of the share library that comes with Maple V Release 3contains about 25 Maple applications packages, 50 Maple routines, 30 Mapleworksheets and 25 additional PostScript, LaTeX and TeX articles documentingthe routines and packages.In this version of the share library we have divided the share libraryup into the following subject areas to make it easier for the user to findwhat s/he is looking for and provided a contents listing for each areawith the given ? command Algebra ?share,algebra Analysis (Calculus) ?share,analysis or ?share,calculus Automatic Differentiation ?share,autodiff Combinatorics ?share,combinat Engineering ?share,engineer Graphics and Geometry ?share,graphics or ?share,geometry Linear Algebra ?share,linalg Number Theory ?share,numtheory Numerics ?share,numerics Programming ?share,programming Science ?share,science Statistics ?share,statistics System Tools ?share,systemFor each Maple routine and package in the share library we have simplifiedthe loading mechanism to make it easier to access the share library.For example, to access the gfun package in the calculus directory in theshare library, one does> with(share); # locate the share library> readshare(gfun,calculus); # load the gfun package> ?gfun # on-line helpIn addition to Maple code, the share library also contains other files.The files ending with the suffix- .tex -- are LaTeX or TeX src files- .dvi -- are device independent file (output from latex or tex)- .ps -- are PostScript files- .ms -- are Maple worksheets- .in -- are (plain text) Maple input files containing examplesFiles with no suffix are Maple src code files. The original Maple src codeis there and available to the user should s/he wish to study it or modify it.Users who would like to contribute Maple code or worksheets to the sharelibrary are encouraged to do so. Please contactDr. Michael Monaganmonagan@inf.ethz.chHere is a brief summary of some of the new routines/packages in theshare library.- perm: a package of routines for computing with permutation groups- guesss: A routine to guess the next values in a sequence- invar: a package of routines mainly for computing the invariant ring of permutation groups or finite linear groups over Q or Q(alpha)- macroC: a Maple package for generating C language code- BesselH: Implementation of Hankel Functions in terms of BesselJ and BesselY- algcurve:- pade2: computes a generalized Pade approximation of functions f1,f2,...,fn- intpak: an experimental interval arithmetic package.- fft, fht: fast Fourier and Hartley transforms- surfaces: a set of procedures to calculate basic differential-geometric quantities of parametric surfaces in space- sffge: row reduction of a sparse matrix of polynomials- genus: the genus of an algebraic curve given by the polynomial f(x,y)- normform: a package of routines for computing matrix normal forms Contains: ismithex, smithex, frobenius, jordan, and ratjordan- puiseux: a Puiseux series expansion of an algebraic function- ratlode: the rational solutions to a linear n'th order ODE in y(x) over Q- coxpoly: the coxeter polynomial of the rooted cycletree- relpoly: the reliability polynomial of a network- GB: Buchberger's Groebner bases algorithm over finite fields- integral\basis: of an algebraic number or function- FPS: tries to find a formula for the coefficients of a formal power series- fields: uses Groebner bases methods to answer questions about degrees of algebraic field extensions and related questions- polycon: a package for analysis of polynomial and rational control systems- fjeforms: a new package for computing with differential forms- IntSolve: an integral equation solver- coxeter: procedures for studying roots systems and finite Coxeter groups- weyl: for manipulating weight vectors and computing multiplicities for irreducible representations of semisimple Lie algebras- ratinterp: rational function interpolation- elliptic: determines the order of the group of points on a non-singular elliptic curve y^2 = x^3+A*x+B over a finite field Z mod pIn addition, new in this version of the share library are a selection ofapproximately 30 worksheets showing applications of Maple in variousdisciplines, in education and research.Miscellaneous=============- Convert/binomial converts expressions involving factorials and GAMMAs into binomials, for example> f := (n+1)!/k!/(n+1-k)!*(2*n)!/n!^2:> f = convert(f,binomial); (n + 1)! (2 n)! --------------------- = binomial(n + 1, k) binomial(2 n, n) 2 k! (n + 1 - k)! (n!)- The combine/ln function takes an optional argument t to specify which type (default type rational) of logs you want to combine, e.g.> f := (a*ln(x)+3*ln(x)-ln(1-x)+ln(1+x)/2:> combine(f,ln); 3 1/2 x (1 + x) a ln(x) + ln(-------------) 1 - x> combine(f,ln,integer); 3 x a ln(x) + 1/2 ln(1 + x) + ln(-----) 1 - x> combine(f,ln,anything); a 3 1/2 x x (1 + x) ln(----------------) 1 - x- numerical comparisons against infinity and -infinity are now allowed> evalb( 5 < infinity ); true- new function: numboccur(a,b) count the number of occurrences of b in a> numboccur( expand(sin(20*x)), x ); 20- The system function lprint has changed a little so that it's output can be read back into Maple. The lprint form of series has changed to output a series command.Changes to Maple V Release 3============================- The new global statement will affect many users Maple procedures. Maple will declare variables to be local automatically. The rules are described in the section ``New and Enhanced System Facilities''. The new release comes with a tool to insert global declarations needed to update old code.- The local variable declaration in -> operators is no longer accepted. I.e. the operator x -> local i; x; will now yield a syntax error.- The synonym linalg[range] for linalg[colspace] has been removed.- The keywords linear and group in the define package have been renamed Linear and Group respectively because linear is a Maple type and group is a Maple package.- The example function has been redesigned. It now displays the EXAMPLE section from the help file.- The stats package has been rewritten. See the section ``The Statistics Package stats above. Details for upgrading are given in ?stats,updates- The following sqrt and radical simplifications are no longer applied automatically.> sqrt(x^2), (x^3)^(1/3); x, x> sqrt(x*y), (x*y)^(1/3); 1/2 1/2 1/3 1/3 x y , x y See the section ``Sqrt and Radical Simplifications'' for details. Similarly the simplify command no longer makes the above transformations unless it can prove that they are correct i.e. x is positive.- The definition of signum(0) has changed. See the section ``New and Enhanced Mathematical Facilities'' for details.- The output from lprint of series has changed. See the ``Miscellaneous'' section for details..- All builtin and readlib defined function names, type names, and system constants are now protected. E.g. exp, gcd, list, true respectively. See the section ``New and Enhanced System Facilities'' for details.- The calling sequence of grobner[gsolve] has changed from grobner[gsolve](<polys>,<notzero>,<vars>) to be grobner[gsolve](<polys>,<vars>,<notzero>) (where the last two arguments are optional) inorder to be consistent with other solvers in Maple.- The variables gamma and R in the cartan package have been renamed `cartan/gamma` and `cartan/R` respectively.