Maple V - Maple Help

 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 of setting defaults, key bindings, etc. are documented in the help file for 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 variables or parametrically.  The coordinate system can be either cartesian, spherical, or cylindrical.  The surface can be rendered as surface patches, a wire frame plot (with optional hidden line removal), or a collection of points. There is also a "plots" package which contains a number of specialized plotting 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 < ... > notations for defining functions (procedures), the following "arrow" notation has 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 appear in an expression.  Univariate polynomials are sorted in descending order. Multivariate polynomials may be sorted by "total degree" (default) with ties 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  + y 5: 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 as polynomials, 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 invoked during output of a Maple expression once for each different instance of 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 I 7: 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 > ?mod The 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 2 New 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 more integrands of the following form: int( R(t)*exp(-u*t^s)*ln(b*t)^m*cos(c*t^r), t=a..infinity ) or sin where 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 the form 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 the i'th argument.  The chain rule is applied and by default and it is assumed 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) y 5: Enhanced limit and series facilities --------------------------------------- Asymptotic series have been extended to allow exponential terms to 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 expansions for 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 ); 2 6: 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 polynomial or 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/171 7: Polynomial factorization and root finding -------------------------------------------- The factor command now accepts an additional argument, an algebraic extension which specifies an algebraic number field over 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 fields defined 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 to the 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 polynomials and/or over finite fields defined by multiple algebraic extensions. 9: Transforms ------------- The Mellin, Z, and discrete fast Fourier transforms have been added to the library.  The Mellin transform of f(t) is g(s) = int( f(t)*t^(s-1), t=0..infinity ) The Z transform for f(n) is g(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 ellipsoid evalr: evaluation over a range(s) fnormal: floating point normalization galois: computes the galois group of a (univariate) polynomial (up to degree 7) history: a history mechanism (an alternative to Maple "'s) iratrecon: rational reconstruction mellin: mellin transform poisson: poisson series expansion irreduc: irreducibility test of a (multivariate) polynomial roots: computes the roots of a (univariate) polynomial shake: real interval arithmetic (to Digits precision) sturm: use the Sturm sequence to find the number of real roots in an interval sturmseq: compute the Sturm sequence of a polynomial over Q or R thiele: continued fraction interpolation userinfo: generate user information ztrans, invztrans: the Z-transform and it's inverse C: Maple to C language translator FFT: Fast Fourier transform Hermite: computes the Hermite normal form of a matrix over a finite field Irreduc: irreducibility test of a (univariate) polynomial mod p MOLS: generates mutually orthogonal Latin squares Nullspace: computes the nullspace of a matrix over a finite field Primitive: tests if a univariate polynomial over a finite field is primitive Randpoly: random univariate polynomial of degree k mod p Randprime: random monic irreducible univariate polynomial of degree k mod p Smith: computes the Smith normal form of a matrix over a finite field New 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 matrix companion -- constructs the companion matrix for a monic polynomial concat -- concatenate matrices and/or column vectors together ffgausselim -- "fraction-free" Gaussian elimination gausselim -- changed to do "ordinary Gaussian elimination" over a field GramSchmidt -- Gram-Schmidt orthogonalization innerprod -- the inner product of a sequence of matrices and vectors JordanBlock -- constructs a Jordan block matrix linsolve -- extended to solve A*X = B where B is a matrix matrix -- utility routine for creating a matrix minor -- utility routine for picking off the i,j'th minor of a matrix randmatrix -- utility routine to generate matrices with random entries pivot -- do one row elimination step on a matrix stack -- stack matrices and/or row vectors on top of each other vector -- utility routine for creating a vector rank, rowspace, colspace -- generalized to work for rational functions eigenvects -- 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 vectors for the basis for the eigenspace of e[i].  It has also been generalized 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 letters cartprod -- iterator for the cartesian product of two lists fibonacci -- 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 objects randpart -- generate a random partition of and integer subsets -- iterator for a powerset (iterates over the subsets of a set) vectoint, inttovec -- bijection of the monomials represented as exponent vectors using the total degree reverse lexicographical ordering with the non-negative integers 3: numtheory (number theory package) ------------------------------------ mipolys(n,p,k) -- computes the number of monic irreducible polynomials of degree n over a finite field with p^k elements sigma -- now accepts a subscript sigma[k](n) and computes the sum of the kth powers of divisors order(n,m) -- solves n^k == 1 mod m for the first integer k > 0 4: 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 s RandExponential(l): Exponential distribution with mean l RandGamma(a): Gamma distribution of order a RandBeta(a,b): Beta distribution of order a and b RandChiSquare(v): X-square distribution with v degrees of freedom RandFdist(v1,v2): F-distribution with v1 and v2 degrees of freedom New 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 describes the type of a composite object.  The type "set" specifies a set, but not the type of the objects in the set.  The type set(=) however specifies a set of equations.  And the type set(name=algebraic)) specifies a set of equations whose left hand sides are (variable) names, and whose right 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 of arbitrarily 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 the form 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 the statement being executed and the values of the local variables are all printed. 3: Sequences and for loops -------------------------- A new "seq" operator (for constructing sequences) has been added to the language.  It has the same evaluation semantics as the Maple for loop and as such should be easier to use and understand than the \$ operator which it will eventually replace.  There are two versions, modelled on 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/66 4: 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 tables indices (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 expressions which exceed the 19 line continuation limit of Fortran. The library routine latex for typesetting Maple output in TeX now handles products, 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 the following modular method.  For n word size prime moduli p[1], ..., p[n], the gcd 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 remainder theorem.  This new method is an order of magnitude more efficient for large problems.  This improves the performance of arithmetic in Q(x). 2: Polynomial resultants ------------------------ Bivariate polynomial resultants over the integers are now computed using using the 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 combined using the Chinese remainder theorem.  Each resultant calculation in Z/(p)[x,y] is reduced to d resultant calculations in Z/(p)[x] by polynomial evaluation 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 precision has 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 reduced from 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 = 0 To implement this formula, the series has been expressed as a 4, 3 argument hypergeometric function which is computed using the routine mentioned in point 3 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 the roots 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 expressed as 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 technology which 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 padic lifting 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 B t := A; A := B; B := t; If A and B are assigned arrays, tables or procedures, one must write t := eval(A); A := eval(B); B := eval(t);