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 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);
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.
> `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
+ 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 );
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;
(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.
> 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);
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);
a := 4 + 2 I 2 + 2 I 3 + 2 2 3
> combine(a,power);
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)
%1 := - 5 _N1 - 4 _N1 _N2 + 2 _N2
%2 := 5 _N1 + 2 _N2
%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]);
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);
Download Help Document
