The CurveFitting package contains functions to fit various types of curves through given data points.  The functions in this package allow the data points to be provided in several different formats.  Some of the functions replace older Maple functions which are now obsolete, while others, such as CurveFitting[BSplineCurve], provide new functionality.

This new package provides a convenient interface to Maple's existing External Calling mechanism.

The package implements direct methods for solving linear functional systems (differential, difference, q-difference) with polynomial coefficients. The direct methods are based on constructing the corresponding matrix recurrence for the coefficients of the solution to be found (similar to some known algorithms for the scalar case). The main functionalities include:

Find polynomial solutions of the linear functional (namely, differential, difference, and q-difference) systems of equations with polynomial coefficients.

Find rational solutions of the linear functional  systems of equations with polynomial coefficients.

Find formal power series solutions of the linear functional systems of equations with polynomial coefficients.

Find the universal denominator of the rational solutions of the linear functional systems of equations with polynomial coefficients (this problem is auxiliary for the second item).

Transform matrix recurrence system into an equivalent system with nonsingular leading or trailing matrix.

The differential case:

sys := [
        diff(y1(x), x) - y2(x),
        diff(y2(x), x) - y3(x) - y4(x),
        diff(y3(x), x) - y5(x),
        diff(y4(x), x) - 2*y1(x) - 2*x*y2(x) - y5(x),
        diff(y5(x), x) - x^2*y1(x) - 2*x*y3(x) - y6(x),
        diff(y6(x), x) - x^2*y2(x) + 2*y3(x)
       ];

vars := [y1(x), y2(x), y3(x), y4(x), y5(x), y6(x)];

Find polynomial solution:

LinearFunctionalSystems[PolynomialSolution](sys, vars);

The difference case:

sys := [
         (x+3)*(x + 6)*(x + 1)*(x + 5)*x*y1(x + 1) -
         (x - 1)*(x + 2)*(x + 3)*(x + 6)*(x + 1)*y1(x) -
         x*(x^6 + 11*x^5 + 41*x^4 + 65*x^3 + 50*x^2-36)*y2(x) +
         6*(x + 2)*(x + 3)*(x + 6)*(x + 1)*x*y4(x),
         (x + 6)*(x + 2)*y2(x + 1) - x^2*y2(x),
         (x + 6)*(x + 1)*(x + 5)*x*y3(x + 1) +
         (x + 6)*(x + 1)*(x - 1)*y1(x) - x*(x^5 + 7*x^4 + 11*x^3 +
         4*x^2 - 5*x + 6)*y2(x) - y3(x)*(x + 6)*(x + 1)*(x + 5)*x +
         (x + 6)*(x + 1)*x*3*(x + 3)*y4(x),
         (x + 6)*y4(x + 1) + x^2*y2(x) - (x + 6)*y4(x)
        ];

vars := [y1(x), y2(x), y3(x), y4(x)];

LinearFunctionalSystems[RationalSolution](sys, vars);

This package provides tools to work with linear functional equations. The main functionalities of the package include:

For a given linear equation with d'Alembertian right hand side, find a d'Alembertian solution if it exists.

For a given d'Alembertian term, find an operator which annihilates the term.

For a given d'Alembertian term, find the minimal annihilator of the term.

For two given operators, find their greatest common right divisor in the factored form.

For a given operator L, find the annihilator of the term g which is primitive for the solution f of Ly=0 and the operator K which convert f to  (if they exist). This is called ``accurate integration.''

This set of tools can be used, for example,

to solve linear differential equations,

to expand a function as a power series and subsequently to investigate the expansion,

to solve inhomogeneous linear functional equations,

to integrate, and

to recognize the equivalence of two given functions.

D'Alembertian solution (differential case):

ode := x^2*diff(diff(y(x),x),x)+x*diff(y(x),x)+(x^2-3)*y(x);

b := -2*x/Pi^(1/2)*(-1+2*x^2)*exp(-x^2)+(x^2-3)*erf(x);

L:=LinearOperators[DEToOrePoly](ode,y(x),x);

normal(LinearOperators[dAlembertianSolver](L,b,x,'differential'));

b := 'b':

Accurate integration (difference case):

sn := binomial(2*n,n)/4^n;

L := LinearOperators[FactoredAnnihilator](sn,n,'shift');

ML := LinearOperators[MinimalAnnihilator](L,expr,n,'shift');

(Lt,r) := LinearOperators[IntegrateSols](ML,n,'shift');

Hence, a primitive of sn is

Sum(sn,n) = LinearOperators[Apply](r,sn,n,'shift');

The new ListTools package contains functions that perform fundamental operations on list objects, useful for constructions or manipulations.

The ListTools functions have been written to provide the fastest possible implementations using the Maple library.  Some of the functions accept optional arguments, but their calling sequences are fixed.

with(ListTools):

L:=[ x, y, z ];

Reverse( L );

Pad[1]( L, a );

This package supports the MathML 2.0 standard (http://www.w3.org/TR/MathML2/). It imports or exports Maple expressions as either Presentation, Content, or Parallel mode MathML text. The package provides a programmer's API to the new facilities. Moreover, these facilities are used by Maple to implement the MathML functionality available in the Graphical User Interface (GUI).

MathML, as a standard, is still in its early stages. It will take time before applications fully comply and for it to fulfill its true potential for offering seamless Web connectivity and operatability between applications. With Maple 7, we have tried our best to provide an implementation that complies to the standard as it existed at the time of development, and to provide the necessary tools to help you benefit from this existing standard immediately. For the latest information on MathML, and to get useful applets and other components to take maximum advantage of the standard, visit http://www.maplesoft.com/standards/MathML/info.html. We will maintain this page with all of the latest developments.

This package contains functions to manipulate series expansions in terms of classical orthogonal polynomials or, more generally, hypergeometric polynomials.  More precisely, it can manipulate series expansions in terms of continuous, discrete, and q-discrete hypergeometric polynomials. It can handle both univariate and multivariate series, and the expansion basis can differ for each variable.  It can perform all manipulations on the truncated forms of the series, and some manipulations can also be done on the infinite series.

At present, the manipulations implemented include addition, multiplication (series, polynomial, and scalar), evaluation, as well as truncation, degree, derivative, coefficient extraction, apply, create, and conversion to Sum form.  For more details, see the OrthogonalSeries page.

The new RandomTools package contains a function Generate which creates pseudo-random objects of specified types, bounds, and other properties.  A specification of such properties is called a flavor (similar to a type or verification), and numerous flavors have been predefined.  Other functions are available for creating new flavors.

with(RandomTools):

Generate(integer*identical(x) + rational);

seq(Generate(1/nonzeroint(range=-3..3)), i=1..10);

Multiplicative normal forms of rational functions which exhibit the shift structure of the factors are useful in the design of algorithms for summation and solution of difference equations in closed form. The Polynomial Normal Form is used in algorithms for hypergeometric summation, finding hypergeometric solutions of difference equations, and rational summation. The Rational Normal Forms are used to construct minimal representations and to solve the decomposition problem for indefinite sums of hypergeometric terms.

The main functionalities of the package include:

Construct the polynomial normal form of a rational functions.

Construct the rational canonical forms of a rational functions.

Construct the minimal representations of a hypergeometric terms.

Minimal representation of hypergeometric terms:

F := (n^2-1)*(3*n+1)!/((n+3)!*(2*n+7)!);

RationalNormalForms:-MinimalRepresentation[1](F,n,k);

RationalNormalForms:-MinimalRepresentation[2](F,n,k);

The RealDomain package provides an environment in which the user is able to work entirely with real numbers. This package provides special forms of the usual basic functions and commands of Maple.  They attempt to avoid returning complex numbers as answers.

with( RealDomain ):

solve( x^3=-8 );

ln( -1 );

This package tries to accommodate users, such as pre-calculus students, who are not yet familiar with complex numbers, and would prefer answers from the real number system to be returned when possible. Whenever the only correct answer is a complex number, the value undefined (or Float(undefined) if the answer is approximate) is returned instead.

Use the Sockets package to write Intranet and Internet applications in Maple. Using this package, your Maple programs can communicate with any host anywhere in the world via TCP/IP networking. The package provides facilities with which you can write networked clients that access existing servers, or your own servers, so that you can establish bi-directional communication between Maple sessions running on different machines on a common network.

The SolveTools package provides a few routines that are used at the heart of Maple's solve command.  These allow an expert user more control over how a solution is found.

The package includes routines for comparing relative complexities of expressions, and choosing the simplest linear basis for a collection of expressions. Also, rational coefficients can be found for attempts at rewriting expressions as linear combinations of particular forms.

SolveTools:-RationalCoefficients( 2*a+3*b,[4*(a-b),5*a+3*b]);

The StringTools package provides a number of highly efficient routines for manipulating text in the form of Maple strings. Also provided are some facilities for working with regular expressions.

with( StringTools ):

msg := Capitalize( "text processing is fun" );

RegSub( "(^.*)Fun", msg, "\\1Fast" );

The package comprises a carefully designed set of efficient routines that can be easily and effectively composed to build efficient and elegant text processing tools. While not a primary domain of application for Maple, the increasing demands of communication with external applications and processes makes the ability to manipulate text efficiently more important. This package therefore contributes to the overall themes of improved efficiency in general, and of connectivity in particular.

The package implements unit conversions and allows the user to augment Maple's already significant knowledge of known units and dimensions.

convert( 32, units, ft, m );

convert( 1.0, units, cm/min, furlongs/fortnight );

convert( 32.5, temperature, degF, K );

convert( N*m, dimensions );

convert( N*m/K, dimensions );

convert( [kg, lb, oz], conversion_table, output=grid );

This package contains a number of subpackages:

Standard Units environment (Units[Standard]),

Natural Units environment (Units[Natural]), and

Units Converter package (Units[Converter]).

The Standard Units environment is a package which, when loaded using with, creates an environment in which unit calculations can be done by specifying units.

with(Units[Standard]):

3*s^4*Unit(m/s) + 4*s*Unit(km/h);

3*Unit(lb)*diff((35), s*Unit(s));

The Natural Units environment is like the Standard Units environment, but units are implicitly used.

with(Units[Natural]):

3 * m + 4 * ft;

(37) / s;

convert( (38), system, FPS );

The Unit Converter package allows access to those units and dimensions which appear in the worksheet's Unit Converter.

The natural environment interprets all symbols, names, or functions which could be interpreted as units as such, including many single letter symbols including as .  In order to have only those symbols which are interpreted as units within the current system of units (by default SI), use the strict option to UseSystem routine.

2.0*Bi*AU*d + D;   # biot astronomical units days + debyes

km + 4*ft*m;        # kilometers + 4 foot metres

Error, (in Units:-Standard:-`+`) the units `km` and `m^2` have incompatible dimensions

Units[UseSystem](strict=true);

Bi*d*ft + D;        # an expression of symbols

km + 4*ft*m;        # kilometers + '4*ft' meters

Strictly using the SI system results in only m, g, s, A, K, mol, cd, and their associated multiples (e.g., km, ms) to be interpreted as units.  You can still use the Unit routine to force a symbol to be recognized as a unit, though:

km^2 + 4*Unit(ft)*m;

The XMLTools package provides access to structured data represented as XML through a Maple interface. The package provides a (nonvalidating) parser, formatter, and a number of simple utilities that define an XML document as an abstract data type.

This package includes two new functions: implicitize and algfun_series_sol. implicitize computes an implicit polynomial equation of a curve surface or hypersurface given by parametric equations and can deal with a wide variety of problems. For a given algebraic equation, algfun_series_sol finds the Puiseux expansions with ``nice'' coefficients (hypergeometric, rational, polynomial, m-sparse, and m-sparse-hypergeometric cases) and determines candidate points for all these cases.

algcurves[algfun_series_sol](x*y^2-1-2*y-y^2,x,y,'coeffs'='polynomial');

algcurves[algfun_series_sol](x^11-2*x^8+x^5-y^2*x^6+2*y^2*x^3-y^2+2*y*x^3-2*y-1,
x=0,y,'coeffs'='mhypergeom','msparse_order'=6);

The codegen[MathML] function has been added to provide translation of Maple expressions to MathML text.  Also, the codegen[C] function allows a new mode option to specify whether single precision or double precision math function names are generated.

Maple 7 includes enhancements and new tool commands for differential equations. With the new features of Maple's dsolve and pdsolve, Maple can now successfully compute, in varied situations, closed form solutions to systems of partial differential equations (PDEs). These systems could also include ordinary differential equations (ODEs), inequations, and algebraic nondifferential equations as constraints.

Also, system of equations containing nonpolynomial objects are now tackled using techniques for polynomial ones (see PDEtools[dpolyform]) and the solutions returned optionally include the singular solutions of the system. This feature permits a detailed analysis of the parameters entering a given problem, in order to find the particular values of them which lead to "different" singular solutions not included in the general solution.

Functions for manipulating with differential equations:

A new command, PDEtools[dpolyform], receives a system of equations (ODEs, PDEs, and may also include nondifferential equations), typically containing nonpolynomial objects. It returns an equivalent system of equations such that: 1) the returned system if fully polynomial in the unknowns and its derivatives; 2) any solution of the original nonpolynomial system is also a solution of the polynomial system. This command has a number of potential applications in it that permits tackling nonpolynomial systems using techniques for polynomial ones.

The PDEtools[casesplit] command can now perform differential elimination, triangularization, and uncoupling of nonpolynomial systems of differential equations, in the presence of much varied nonpolynomial objects.

A new command, DEtools[hyperode], will return the Ordinary Differential Equation (ODE) satisfied by the product of any function and a given hypergeometric or generalized hypergeometric (MeijerG) function. The ODE returned can optionally admit additional given solutions. This command is useful for studying hypergeometric functions and their relations, in connection with the properties their differential equations have, as well as to study formal solutions to linear ODEs in general.

The capabilities of the conversion facility for ODEs (see convert,ODEs) have been extended. It is now possible to convert to normal form ODEs of type: linear (arbitrary order), Riccati and Abel. For Abel ODEs there is a new conversion to "Rational Normal Form". These tools are useful to study the solving properties of these relevant classes of equations. Also a conversion applicable to ODEs in general, called here 'y_x', to switch the roles between the dependent (y) and independent (x) variables, was implemented. This is a useful conversion tool in different frameworks since this transformation enters many standard and alternative interactive solving approaches.

Functions for handling ODEs in the framework of the Integrating Factors and Lie symmetry approaches

Taking advantage of the new PDE system solver available in Maple 7, the DEtools[symgen] command now accepts the optional argument 'way = formal', meaning: compute the ODE symmetries by formally triangularizing and solving the underlying partial differential equations system. In this way, when symgen is successful, it directly returns the infinitesimals generating a multiparameter Lie group (when such a group exists). This new branch of the program is automatically invoked by Maple's dsolve whenever the optional argument 'Lie' is given to it (see dsolve,Lie).

A new command, DEtools[reduce_order], receives an ODE linear or nonlinear, and a sequence of symmetries admitted by this ODE, and returns a reduction of the differential order of the ODE using these symmetries. When the amount of symmetries is equal to the differential order this command actually returns the solution in parametric form, thus providing a useful alternative for nonlinear problems, where the solution typically involves RootOfs. Also, since reduce_order can be used with linear nonhomogeneous ODEs, where any ODE solution S(x) to the homogeneous part is also an ODE symmetry of the form [0, S(x)], this command provides an alternative way to constructing solutions for nonhomogeneous linear equations. In both cases, reduce_order can be used with pedagogical purposes by taking advantage of its optional argument 'in_sequence', which allows for displaying, one after the other, the whole sequence of reductions of order involved in the solving of an ODE using its symmetries.

Taking advantage of the new PDE system solver available in Maple 7, the DEtools[equinv] command now accepts the optional argument 'formal = true', meaning: compute the ODE invariant under possibly many given symmetries by formally triangularizing and solving the underlying system of partial differential equations. This new branch of the program permits solving varied problems not solved in previous Maple releases.

Functions for constructing closed-form solutions

Two new functions have been added under this title: hypergeomsols and MeijerGsols. The former will attempt to find hypergeometric solutions and the latter will attempt generalized hypergeometric (i.e. MeijerG function) solutions to given linear ODEs with rational coefficients.

The Maple implementation of Kovacic's algorithm for linear ODEs was entirely rewritten. The new implementation is an order of magnitude faster and can reliably tell whether a given second order linear ODE, with rational coefficients (may include symbolic parameters) admits Liouvillian solutions.

Functions for simplifying differential systems using integrability conditions or performing differential elimination

Many enhancements have been made to the Rif, subpackage of DEtools.

The new command maxdimsystems can be used for determining the "maximum dimensional" subsystems of a given system of differential equations.

The caseplot command (for plotting the tree corresponding to the splitting into cases of a DE system) can now display information related to the case splitting performed by rifsimp, and the initial data of the computed cases.

The initialdata command can now be given a case from the output of a rifsimp computation, and will provide in the output any additional constraints that the data must satisfy in terms of the computed initial data. These additional constraints are the nonlinear relations and inequations (equations of the form ) that must hold for the case.

The main rifsimp command accepts a new optional argument indicating that some functions or constants (not the true unknowns of the problem) should be considered "arbitrary", and to avoid splitting into cases dependent upon their values. This results in a significant decrease in the running time of the algorithm when arbitrary functions or constants are present.

Additional functionality is available with options to control the form of the output solution, the manner in which case splitting is performed, detection of empty cases, nonlinear equation processing, and time spent investigating cases (see rifsimp[options], rifsimp[adv_options], and rifsimp[cases]).

A new feature was added to rifsimp, providing the ability to save partial computations in order to examine them manually afterwards (see also rifread). This is most useful for large and/or complex problems that require excessive resources to complete.

Additionally, rifsimp has been enhanced so that it revises the case splitting tree to remove the effect of any inconsistent cases on the results. This has the benefit of producing a more compact set of cases, and removal of pivots that have been discovered to always hold true.

The whole package has been revised and optimized to perform faster for both linear and nonlinear problems. New nonlinear equation handling code has enabled rifsimp to tackle many significant problems that were too difficult for prior versions of the package (See also rifsimp[nonlinear]).

Two new functions have been added, Groebner[SetBasis] and Groebner[MulMatrix], to compute respectively a "normal set" from a zero dimensional Groebner basis, and the corresponding multiplication matrix.

This package includes a large number of enhancements that lead to faster computation, reduced storage requirements, and greater ease of use.

Optimized Routines for Basic Operations: Significant improvements to the speed of hardware floating-point computations in the LinearAlgebra package have been made for supported UNIX platforms. This is due to new linking of the external NAG and CLAPACK libraries with the optimized ATLAS library.  These optimizations parallel the high performance present in Maple 6 for the Microsoft Windows platforms obtained from linking with Intel's Math Kernel library.

Enhanced Support for Band and Packed Triangular Matrices: There is added support for fast matrix operations involving floating-point band and packed triangular matrices.  This support, provided through external routines specially designed for such matrix structures, allows the operations to be done with a minimum amount of storage.  See Shapes and Storage Modes for Matrices and Vectors for more information.

Enhanced Support for Sparse Matrices: There is added support for efficient floating-point sparse matrix arithmetic. In addition, the LinearSolve function now allows the option of choosing an iterative solver for sparse symmetric linear systems.  Conjugate Gradient and SYMMLQ methods are available, along with various types of incomplete factorization preconditioners.

Extended Parameter Domain: The LinearAlgebra routines now allow the user to provide, as input values, algebraic expressions that simplify to the parameter types expected.  An example is provided below:

with(LinearAlgebra):

expr := <<a,b>|<c,d>> - x * IdentityMatrix(2);

Determinant(expr);

This additional functionality is not available with programming layer routines.

Automatic Setting of Computation Environment: The UseHardwareFloats environment variable is now set to the default value deduced.  This setting tells Maple to deduce the computation environment (hardware or software) from the current setting of the Digits environment variable.

Additional Improvements: There is improved floating-point support for the Eigenvectors, Transpose, and HermitianTranspose functions. The Eigenvectors function now uses a "divide-and-conquer" scheme for nongeneralized real-symmetric and complex-hermitian problems.  In addition, many improvements have been made to the LeastSquares function, including a more robust SVD scheme for rank-deficient problems, the ability to handle multiple right-hand sides, and more efficient calculation of optimized solutions in the rank-deficient case.

The PolynomialTools is a collection of tools for working with polynomial objects in Maple, and has superseded the polytools package.

New functions were added for performing basic manipulations of polynomials, including PolynomialTools[Shorten], PolynomialTools[PolynomialToPDE], and PolynomialTools[PDEToPolynomial] to convert between polynomial form of systems (suitable for Groebner basis computations for example) and Partial Differential Equation form (suitable for rifsimp computations).

with( PolynomialTools ):

Sort( [x^3,x^2,x+1,x+5], x );

Shorten( 3*x^3+18*x+14, x );

This package includes two new functions: mhypergeom_formal_sol and series_by_leastsquare. The function mhypergeom_formal_sol constructs formal solutions with m-hypergeometric series of a homogeneous linear differential equation with polynomial coefficients. The function series_by_leastsquare constructs the linear subspace of the given linear space of series such that the initial coefficients of those series best satisfy the given linear conditions in the least-squares sense (at a given ordinary or singular point).

mhypergeom_formal_sol

ode := diff(y(x),x,x)=-(6*x^3+1)*diff(y(x),x)/x^4-2*y(x)*(3*x^3+2)/x^5;

Slode[mhypergeom_formal_sol](ode,y(x));

series_by_leastsquare via FPseries

ode := (x-1)*diff(y(x),x$4)-(x-4)*diff(y(x),x$2)+diff(y(x),x)-y(x)=0;

Slode[FPseries]({ode,y(1)=a1,D(y)(1)=b1,(D@@2)(y)(1)=c1,(D@@3)(y)(1)=d1},y(x),u(n),1);