New Features in Maple V
Development of Improved User Interfaces=======================================1: X Window interface---------------------A user interface for X Window has been designed.The X Window user interface provides separate help and plot windows,allows editing of input expressions, maintains a log of a Maple session,and supports an assortment of other options. The various methods ofsetting defaults, key bindings, etc. are documented in the help filefor X11.2: 3-Dimensional graphics-------------------------Maple V supports 3-D surface plots under several software platforms,including X Window. Printed output is provided for a variety of printers,including Postscript devices.Surfaces can be described either by a single function of two variablesor parametrically. The coordinate system can be either cartesian, spherical,or cylindrical. The surface can be rendered as surface patches, a wire frameplot (with optional hidden line removal), or a collection of points.There is also a "plots" package which contains a number of specializedplotting facilities e.g. matrix plots, conformal plots, tube plots etc.Additional documentation is available on-line for the plots package.3: New arrow syntax for specifying operators (functions)--------------------------------------------------------In addition to the "proc ... end" and the angle bracket < ... > notationsfor defining functions (procedures), the following "arrow" notationhas been adopted as an alternative syntax f := x -> x^2 g := (x,y) -> sin(x+exp(y))4: Sorting polynomials----------------------Expressions in Maple are usually stored in the order they were created.Consequently polynomials often appear in a seemingly random order.The sort command can now be applied to sort any polynomials that appearin an expression. Univariate polynomials are sorted in descending order.Multivariate polynomials may be sorted by "total degree" (default) withties broken by lexicographical order, or in pure lexicographical order.An optional argument may be given to specify the variable ordering.Example: > a := y^3+y^2*x^2+x^3; 3 2 2 3 a := y + y x + x > sort(a,[x,y],tdeg); 2 2 3 3 x y + x + y > sort(a,[x,y],plex); 3 2 2 3 x + x y + y5: Improved display of output-----------------------------The output of matrices, vectors, and repeated composition has been improved.Example: compute a Taylor series expansion for an unknown function F > s := taylor(f(x),x=0,4); (2) 2 (3) 3 4 s := f(0) + D(f)(0) x + 1/2 D (f)(0) x + 1/6 D (f)(0) x + O(x ) > linalg[vector]( 4, i -> coeff(s,x,i-1) ); (2) (3) [ f(0), D(f)(0), 1/2 D (f)(0), 1/6 D (f)(0) ]6: User defined formatting routines-----------------------------------Maple's pretty printer understands how to display certain objects such aspolynomials, plots, matrices, vectors, integrals, subscripts, etc.Users may now specify how their own functions are to be displayed as follows:To format a function foo(...) the user may assign to the name`print/foo` a Maple procedure. The Maple procedure will be invokedduring output of a Maple expression once for each different instanceof foo in the output. The procedure can return any expression.Example: > `print/complex` := proc(r,i) r+i*I end: > complex(1,2); 1 + 2 I7: New help syntax and user defined help routines-------------------------------------------------Help is now also available using the ? syntax.For example, to get help for the mod operator, one types simply > ?modThe searching component of the help system has been much improved.The help files themselves now include the actual Maple output.The user may tell Maple how to generate help for a function "foo"by assigning the name `help/text/foo` to a TEXT object, e.g. > `help/text/foo` := TEXT(`this is line 1`, `and this is line 2`): > ?foo this is line 1 and this is line 2New and enhanced mathematical facilities========================================1: New Mathematical functions known to Maple--------------------------------------------- Complementary error function erfc(z) = 1-erf(z) (diff/erfc, limit/erfc, evalf/erfc, series/erfc)- Airy wave functions Ai(x) and Bi(x) (evalf/Ai, evalf/Bi)- The 3 argument limiting case only of the Meijer G function (diff/MeijerG, evalf/MeijerG, series/MeijerG)- The Dirac delta function Dirac(x) and its derivatives Dirac(n,x)- The generalized Riemann Zeta function Zeta(0,x,s) and its derivatives Zeta(n,x,s).2: Enhanced numerical facilities--------------------------------- Asymptotic series are now used to numerically evaluate the following functions for large x: Si(x) and Ci(x) (Sine and Cosine integrals), Ai(x) and Bi(x) (Airy wave functions), erfc(x) (complementary error function), BesselJ and BesselY (Bessel functions J(v,x) and Y(v,x)).- Evalf of sum(f(r),r=RootOf(a(x),x)) sums f(r) over the complex roots of a polynomial a(x).- Dsolve has been extended to use a Runga Kutta based numerical method for solving initial value ODEs.- The library routines shake and evalr provide a model of interval arithmetic which is used for simplifications of signum of exact real constants.3: Enhanced integration facilities----------------------------------Definite integration has been extended to handle moreintegrands of the following form:int( R(t)*exp(-u*t^s)*ln(b*t)^m*cos(c*t^r), t=a..infinity )or sinwhere r in {0,s,2*s,s/2} and other restrictions on the constants apply.In general these integrals can be expressed in terms of the Gamma function,incomplete Gamma function GAMMA(a,x), and the Polygamma function Psi(x),the Riemann Zeta function Zeta(x), the error function and Fresnel integrals,and the Meijer G function.Examples where R(t) is a power of t (possibly negative and/or fractional): > int( exp(-t^2)*cos(2*t)*t^2, t=0..infinity ); 1/2 - 1/4 Pi exp(-1) > int( exp(-sqrt(2*Pi)*t)*sin(t^2), t=0..infinity ); 1/2 1/2 1/2 1/2 1/4 2 Pi - 1/2 2 Pi FresnelS(1) > int( exp(-t)/t^(1/3), t=1..infinity ); GAMMA(2/3, 1) > int( exp(-t)*ln(t)/t, t=1..infinity ); MeijerG(3, 0, 1) > int( exp(-t)*ln(t)/t^(1/2), t=1..infinity ); MeijerG(3, 1/2, 1)Maple can do some cases where the denominator of R(t) is of theform 1-exp(-v*t^s), e.g. > int( exp(-t)*t^2/(1-exp(-2*t)), t=0..infinity ); 7/4 Zeta(3)And also a few cases where R(t) includes an error function, e.g. > int( t*exp(-t^2)*erf(2*t+1), t=0..infinity ); 1/2 1/2 1/2 erf(1) + 1/5 exp(-1/5) erfc(2/5 5 ) 5 > int( ln(2*t^2)*erf(t/2)/t^(3/2), t=0..infinity ); 1/2 1/2 1/2 ln(2) Pi Pi Pi Psi(1/4) 6 ----------- + 8 ---------- + 2 -------------- GAMMA(3/4) GAMMA(3/4) GAMMA(3/4)4: The derivative operator D----------------------------The D operator has been extended to handle partial derivatives.The notation D[i](f) means the derivative of f with respect to thei'th argument. The chain rule is applied and by default and it isassumed that partial derivatives commute. Examples: > g := (x,y) -> sin(x+cos(y)): > D[1](g); (x,y) -> cos(x + cos(y)) > D[1,2](g); (x,y) -> sin(x + cos(y)) sin(y)Consequently the mtaylor function (for multivariate Taylor series)will now expand an unknown function of more than one argument, e.g. > mtaylor(f(x,y),[x=0,y=0],3); 2 f(0, 0) + D[1](f)(0, 0) x + D[2](f)(0, 0) y + 1/2 D[1, 1](f)(0, 0) x 2 + D[1, 2](f)(0, 0) x y + 1/2 D[2, 2](f)(0, 0) y5: Enhanced limit and series facilities---------------------------------------Asymptotic series have been extended to allow exponential termsto appear in the resulting series. Example: > asympt( Psi(2*exp(x))-x, x, 4 ); 1 1 1 ln(2) - -------- - ---------- + O(-------) 4 exp(x) 2 4 48 exp(x) exp(x) > limit( Psi(2*exp(x))-x, x=infinity ); ln(2)Series expansions for erfc(x), GAMMA(a,x) for a > 0, and MeijerG(a,b,x)for a > 1, a an integer have been added. Also asymptotic expansionsfor the GAMMA and binomial functions have been added. Examples: > asympt( GAMMA(x)*Ei(x)/x^x/sqrt(2*Pi), x ); 1 13 601 319721 60973877 1 ---- + ------- + -------- + ---------- + ------------- + O(-----) 3/2 5/2 7/2 9/2 11/2 13/2 x 12 x 288 x 51840 x 2488320 x x # An indefinite summation using Gosper's algorithm > s := sum( binomial(2*n,n)/(n+1)/(2^n)^2, n ); binomial(2 n, n) s := - 1/2 ---------------- (n - 1) 2 (2 ) > asympt(s,n,3); 2 1 1 1 - ---------- + ------------ - ------------- + O(----) 1/2 1/2 1/2 3/2 1/2 5/2 7/2 Pi n 4 Pi n 64 Pi n n # Hence since s = -2 at n = 0, we have > sum( binomial(2*n,n)/(n+1)/(2^n)^2, n=0..infinity ); 26: Definite sums and products over roots of polynomials-------------------------------------------------------Let alpha denote the set of roots of the polynomial a(x).In Maple, the roots of a(x) are expressed as RootOf( a(x), x ).Let sum(f(k),k=alpha) mean the sum of f over the roots of a(x).Likewise let product(f(i),k=alpha) be the product of f over the roots of a(x).Then Maple can evaluate such sums and products when f is a polynomialor rational function in k, e.g. > alpha := RootOf(x^5+x+11,x): > sum( 1/(k^2+1), k=alpha ); 35/57 > product( k^2+1, k=alpha ); 1/1717: Polynomial factorization and root finding--------------------------------------------The factor command now accepts an additional argument,an algebraic extension which specifies an algebraic number fieldover which the polynomial is to be factored.The extension can be specified as a single RootOf or radical,or in the case of multiple extensions, a list or set of such.Example: factor the polynomial y^4+2 over Q(sqrt(2)) > factor(y^4-2,sqrt(2)); 2 1/2 2 1/2 (y + 2 ) (y - 2 ) > alias(alpha = RootOf(x^2-2)); > factor(y^4-2,alpha); 2 2 (y + alpha) (y - alpha)An algebraic extension can also be given to the roots and irreduc functions.Similarly for finite fields (see below).8: Arithmetic over finite fields (Galois fields)------------------------------------------------A special representation for univariate polynomials over finite fieldsdefined by a single algebraic extension over Z mod p has been implemented.The new facility includes support for computing polynomial gcd's,factorization and root finding. It is accessed via the mod function.Example: factor the polynomial x^6+x^5+x^4+x^3+1 over GF(2) then GF(4) > f := x^6+x^5+x^4+x^3+1: > Factor(f) mod 2; 2 4 (x + x + 1) (x + x + 1) > alias(alpha=RootOf(x^2+x+1)): > Factor(f,alpha) mod 2; 2 2 (x + alpha) (x + x + alpha + 1) (x + alpha + 1) (x + x + alpha)An algebraic extension can also be given tothe Roots and Irreduc functions, e.g. > Roots(f,alpha) mod 2; [[alpha, 1], [alpha + 1, 1]]Future work will see the functionality extended to multivariate polynomialsand/or over finite fields defined by multiple algebraic extensions.9: Transforms-------------The Mellin, Z, and discrete fast Fourier transforms have been added to thelibrary. The Mellin transform of f(t) isg(s) = int( f(t)*t^(s-1), t=0..infinity )The Z transform for f(n) isg(z) = sum( f(n)/z^n, n=0..infinity )The discrete Fourier transform of a complex vector $z$ is the vector[ sum( exp(-2*Pi*j*k*I/n )*z[k], k=0..n-1) for j=0..n-1 ]The Laplace transform package has been taught about Bessel functions.New library functions=====================ellipsoid: surface area of an ellipsoidevalr: evaluation over a range(s)fnormal: floating point normalizationgalois: computes the galois group of a (univariate) polynomial (up to degree 7)history: a history mechanism (an alternative to Maple "'s)iratrecon: rational reconstructionmellin: mellin transformpoisson: poisson series expansionirreduc: irreducibility test of a (multivariate) polynomialroots: computes the roots of a (univariate) polynomialshake: real interval arithmetic (to Digits precision)sturm: use the Sturm sequence to find the number of real roots in an intervalsturmseq: compute the Sturm sequence of a polynomial over Q or Rthiele: continued fraction interpolationuserinfo: generate user informationztrans, invztrans: the Z-transform and it's inverseC: Maple to C language translatorFFT: Fast Fourier transformHermite: computes the Hermite normal form of a matrix over a finite fieldIrreduc: irreducibility test of a (univariate) polynomial mod pMOLS: generates mutually orthogonal Latin squaresNullspace: computes the nullspace of a matrix over a finite fieldPrimitive: tests if a univariate polynomial over a finite field is primitiveRandpoly: random univariate polynomial of degree k mod pRandprime: random monic irreducible univariate polynomial of degree k mod pSmith: computes the Smith normal form of a matrix over a finite fieldNew library packages====================1: bianchi (3-d Lie algebra classification package)2: cartan (special-purpose relativity tensor package -- Cartan's formalism)3: debever (special-purpose relativity tensor package -- Debever's formalism)4: finance (amortization and Black Scholes stock call option pricing)5: geom3d (3-d geometry package)6: heap (priority queue data structure)7: liesymm: (Lie symmetries package -- obtains the determining equations for the Lie symmetries of a system of partial differential equations)8: logic (boolean algebra package)9: oframe (orthonormal frame package using the Ellis-MacCallum formalism)10: petrov (Weyl tensor classification package)11: plots (2-d and 3-d special plots package)12: tensor (relativity tensor package)New functionality in library packages=====================================1: linalg (linear algebra package)----------------------------------backsub -- back substitution in an augmented triangular matrixcompanion -- constructs the companion matrix for a monic polynomialconcat -- concatenate matrices and/or column vectors togetherffgausselim -- "fraction-free" Gaussian eliminationgausselim -- changed to do "ordinary Gaussian elimination" over a fieldGramSchmidt -- Gram-Schmidt orthogonalizationinnerprod -- the inner product of a sequence of matrices and vectorsJordanBlock -- constructs a Jordan block matrixlinsolve -- extended to solve A*X = B where B is a matrixmatrix -- utility routine for creating a matrixminor -- utility routine for picking off the i,j'th minor of a matrixrandmatrix -- utility routine to generate matrices with random entriespivot -- do one row elimination step on a matrixstack -- stack matrices and/or row vectors on top of each othervector -- utility routine for creating a vectorrank, rowspace, colspace -- generalized to work for rational functionseigenvects -- has been modified to return a sequence of lists of the form[e[i],m[i],{v[i,1],...,v[i,n[i]]}] where e[i] is the eigenvalue,m[i] it's multiplicity, and {v[i,1], ..., v[i,n[i]]} a set of vectorsfor the basis for the eigenspace of e[i]. It has also beengeneralized to work for a matrix over any algebraic number field.2: combinat (combinatorial functions package)---------------------------------------------character -- character table for Sn the symmetric group on n letterscartprod -- iterator for the cartesian product of two listsfibonacci -- extended to compute the fibonacci polynomials F[n](x)numbcomb -- replaces combinations (computes the number of combinations)numbpart -- replaces partitions (computes the number of partitions)numbperm -- replaces permutations (computes the number of permutations)randcomb -- generate a random combination of m objects from s objectsrandpart -- generate a random partition of and integersubsets -- iterator for a powerset (iterates over the subsets of a set)vectoint, inttovec -- bijection of the monomials represented as exponentvectors using the total degree reverse lexicographical orderingwith the non-negative integers3: numtheory (number theory package)------------------------------------mipolys(n,p,k) -- computes the number of monic irreducible polynomialsof degree n over a finite field with p^k elementssigma -- now accepts a subscript sigma[k](n) and computesthe sum of the kth powers of divisorsorder(n,m) -- solves n^k == 1 mod m for the first integer k > 04: stats (statistics package)-----------------------------Added random variate generators for the following distributions:RandUniform(a..b): Uniform distribution on [a,b)RandNormal(u,s): Normal distribution with mean u, standard deviation sRandExponential(l): Exponential distribution with mean lRandGamma(a): Gamma distribution of order aRandBeta(a,b): Beta distribution of order a and bRandChiSquare(v): X-square distribution with v degrees of freedomRandFdist(v1,v2): F-distribution with v1 and v2 degrees of freedomNew and enhanced system facilities==================================1: Type testing in Maple V--------------------------In Maple version 4.3, we extended the notion of a "type" to include"structured" types. A structured type is a Maple expression that describesthe type of a composite object. The type "set" specifies a set,but not the type of the objects in the set. The type set(`=`) howeverspecifies a set of equations. And the type set(name=algebraic)) specifiesa set of equations whose left hand sides are (variable) names, and whoseright hand sides are algebraic expressions.In Maple V, all types are now structured types. The old polynomial type test type( p, polynom, [x,y], rational )which tests if p is a polynomial in x and y with rational coefficients becomes type( p, polynom(rational,[x,y]) )Because all types are now single objects, one can describe the type ofarbitrarily complex objects very concisely. For example, the type matrix( polynom(algnum), square )specifies a square matrix whose entries are polynomials(in any number of variables) over an algebraic number field, and the type [ exp(anything}, {name,name=constant..constant} ]specifies a list of exactly two objects, the first an exponential(of any type), the second either a variable name, or an equation of theform indicated -- the set brackets denote alternation.For a more detailed description see type[structure].2: Debugging facilities-----------------------On an ERROR condition, if printlevel is higher than 1 thestatement being executed and the values of the local variablesare all printed.3: Sequences and for loops--------------------------A new "seq" operator (for constructing sequences) has been added tothe language. It has the same evaluation semantics as the Maple for loopand as such should be easier to use and understand than the $ operatorwhich it will eventually replace. There are two versions, modelledon the two kinds of for loops as indicated by the comments below. > s := seq( bernoulli(i), i=1..10 ); # for i to 10 do bernoulli(i) od; s := -1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66 > seq( abs(x), x=s ); # for x in s do abs(x) od; 1/2, 1/6, 0, 1/30, 0, 1/42, 0, 1/30, 0, 5/664: Table and array entries--------------------------Arrays and tables can now be descended (picked apart) using the "op" function.Hence the only objects in Maple now which cannot be descended are procedures.In addition to the indices function (which computes a sequence of a tablesindices (keys)) the entries function computes a sequence of a tables entries.Example: > t := table([red = rot, blue = blau, yellow = gelb, grey = grau]): > indices(t); [blue], [yellow], [grey], [red] > entries(t); [blau], [gelb], [grau], [rot] > op(op(t)); [blue = blau, yellow = gelb, grey = grau, red = rot]5: Procedure execution----------------------This version includes a new implementation of non-local goto's(as generated by ERROR, RETURN, interrupts and system errors).The new implementation results in a lower overhead for procedure invocation.Simple procedure calls execute 4 times faster in Maple V.6: Language translation facilities----------------------------------The library routine C translates Maple expressions and arrays into C code.There is an optional code optimization facility.The library routine fortran has been fixed to break up expressionswhich exceed the 19 line continuation limit of Fortran.The library routine latex for typesetting Maple output in TeX now handlesproducts, composition, vectors, tables and some operators.The library routine eqn for troff output now handles products and operators.Algorithmic improvements========================1: Polynomial gcd's-------------------Univariate polynomial gcd's over the integers are now computed using thefollowing modular method. For n word size prime moduli p[1], ..., p[n], thegcd is computed over Z/(p[k]) efficiently using in-place machine arithmetic.The n modular gcd's are then combined by application of the Chinese remaindertheorem. This new method is an order of magnitude more efficient for largeproblems. This improves the performance of arithmetic in Q(x).2: Polynomial resultants------------------------Bivariate polynomial resultants over the integers are now computed using usingthe following modular method. For n word size prime moduli p[1], ..., p[n],the resultant is computed in Z/(p[k])[x,y], and these images are combinedusing the Chinese remainder theorem. Each resultant calculation inZ/(p)[x,y] is reduced to d resultant calculations in Z/(p)[x] by polynomialevaluation and interpolation. This method (due to George Collins)gives better performance for polynomials of large degree.3: Arbitrary precision floating point arithmetic------------------------------------------------A routine for evaluating hypergeometric functions to arbitrary precisionhas been added to the kernel.Since an elementary function can be expressed as a hypergeometric function,this routine is used to evaluate elementary functions as well.The time to compute sin(1) and ln(3) to 1000 digits, for example, is reducedfrom 70 to 26 and 120 to 8 seconds respectively on a Sun 3/280 computer.4: Computation of Pi--------------------Maple is now using the Chudnovsky's formula for computing Pi to high precision.Their formula is infinity ----- 1 6541681608 ( 13591409 ) (6*k)! (-1)^k--- = -------------- ) (----------- + k) -------------- ------------- Pi 640320^(3/2) / ( 545140134 ) (3*k)!*(k!)^3 640320^(3*k) ----- k = 0To implement this formula, the series has been expressed as a 4, 3 argumenthypergeometric function which is computed using the routine mentioned in point3 above. This method is about 30% faster in Maple than the previous method(a similar formula due to Ramanujan).5: Integration of rational functions------------------------------------Integration of rational functions now returns a sum of logarithms over theroots of a polynomial a(x) of smallest possible degree in the form sum( f(alpha)*log(x+g(alpha)), alpha=RootOf(a(x)) )The resulting sum, if evaluated in floating point, will be expressedas an explicit sum of logarithms over the complex roots of alpha.The above can also be manipulated as a function of x, i.e.differentiated, expanded as a series in x etc.The new form is much more concise and usable than the old technologywhich produced a "mess" of nested radicals.6: Polynomial root finding over finite rings--------------------------------------------The Roots function has been extended to work for a composite modulus n.The roots are computed mod each prime factor of n then lifted using padiclifting and combined by application of the Chinese remainder theorem.The result returned is a list of the roots and their multiplicities.Example: find the roots of the polynomial x^2 mod 72 > Roots(x^2) mod 72; [[36, 2], [24, 1], [12, 1], [60, 1], [0, 2], [48, 1]]Miscellaneous changes=====================- Maple no longer has two representations for the complex unit i . The unique representation is (-1)^(1/2) and the symbol I is initially an alias for (-1)^(1/2).- Radical powers of rationals are now automatically reduced, e.g. > (2/3)^(-3/2); 1/2 1/2 3/4 3 2- Different radicals are no longer automatically combined so as to preserve a canonical form. The combine function can be used to combine radicals except the imaginary constant I, e.g. > a := I+2^(1/2)+3^(1/2): > a := expand(a^2); 1/2 1/2 1/2 1/2 a := 4 + 2 I 2 + 2 I 3 + 2 2 3 > combine(a,power); 1/2 1/2 1/2 4 + 2 I 2 + 2 I 3 + 2 6- The library routine userinfo can be used to generate user information messages for a function during the course of a computation. In future versions of Maple, this facility will be exploited in the Maple library to generate information about what Maple is doing.- The library routine log has been extended to allow for different bases. The syntax is log[b](x) meaning log base b of x.- The mtaylor function (multivariate taylor series) now returns a Maple sum of products and accepts integral weights for the variables.- Addition of norm and trace operations to GF (Galois Field package)- Addition of Bessels equation to dsolve.- The solve command for solving systems of equations now accepts an additional argument "split" which directs solve to try to split a system into one or more simpler systems using factorization at every step.- The coeff function has been extended to understand coeff(p,x^n) for n<>0 to be equivalent to coeff(p,x,n) meaning the coefficient of x^n in p.- The alias and macro facilities no longer affect parameters and locals. I.e. one can have an alias I and a local variable I simultaneously. Also, alias now will return a sequence of all current alias's.- The POINT option in the 2-D plotting has been improved to print crosses + instead of dots.- Map map's onto named arrays and tables, e.g. map(simplify,A); i.e simplify each entry in the array- All entries of an antisymmetric array can now be assigned.- Saving procedures in src format inserts back-quotes where necessary.- Since the neutral operator &* is being used for matrix multiplication it has been given the same precedence as * (multiplication)- New Iris variable "endcolon" returns true iff the last statement was terminated with a colon (instead of a semi-colon).- These functions that previously existed are now readlib defined: allvalues, compoly, discrim, eqn, fortran, latex, norm, plot3d, select.- The semantics of the read statement inside a Maple procedure has changed from stacking the input to reading and executing the input immediately.- The rsolve function now takes an optional directive "ztrans" to solve recurrences or systems of recurrence equations using Z transforms.- The rsolve function can now solve a large class of 1st order equations and more complicated nonhomogeneous linear equations, e.g. > rsolve( {y(n) = n*y(n-1) + (n-1)!, y(0) = 1}, y(n) ); GAMMA(n + 1) (Psi(n + 1) + gamma + 1)- The isolve function (for integer solutions to equations) can now solve a single equation of Pythagorean type, i.e. a x^2 + b y^2 + c z^2 = 0 . where a, b, c are integers. In the example below, the % labels stand for repeated common subexpressions, and _N1, _N2, _N3 stand for arbitrary integers. > isolve(2*x^2-7*y^2+5*z^2); _N3 %1 _N3 %3 _N3 %2 {z = ----------------, x = ----------------, y = ----------------} igcd(%1, %2, %3) igcd(%1, %2, %3) igcd(%1, %2, %3) 2 2 %1 := - 5 _N1 - 4 _N1 _N2 + 2 _N2 2 2 %2 := 5 _N1 + 2 _N2 2 2 %3 := 5 _N1 - 10 _N1 _N2 - 2 _N2- The rules for last-name evaluation have changed. Recall that the purpose of last-name evaluation is to allow vectors, matrices and arrays to have one (or more) as yet undefined entries, e.g. > A := array(1..2,1..2): > linalg[det](A); A[1, 1] A[2, 2] - A[1, 2] A[2, 1] > A; A > op(A); [ ?[1, 1] ?[1, 2] ] [ ] [ ?[2, 1] ?[2, 2] ] In Maple V this has been extended to subscripted names e.g. replace A by t[1] in the above. > t[1] := array(1..2,1..2): > linalg[det](t[1]); t[1][1, 1] t[1][2, 2] - t[1][1, 2] t[1][2, 1] However, to access the array object one cannot use op, since op(t[1]); would then yield 1, the index. The way to access the array object now is to use the eval function, e.g. > eval(t[1]); [ ?[1, 1] ?[1, 2] ] [ ] [ ?[2, 1] ?[2, 2] ] Finally, a reminder not to make the following mistake.# Interchange matrices A and Bt := A; A := B; B := t; If A and B are assigned arrays, tables or procedures, one must writet := eval(A); A := eval(B); B := eval(t);