updates/R5/symbolic - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : updates/R5/symbolic

Improved Symbolics in Maple V Release 5

  

Many improvements to the symbolic capabilities of Maple have been made in Release 5.  A brief description of these improvements follows.

 

General

Evaluation (eval, evala)

Simplification (simplify)

Conversions (convert)

New Functions

Changes to Functions

The Integrator

The Differential Equation solvers

Pattern Matcher

General

• 

The gcd command now can manipulate radicals, radical extensions, and in some cases,  can attempt to deal with transcendental expressions. (Care must be exercised if non-rational subexpressions are algebraically dependent, but many common cases will work.)

gcd( sin( x ), cos( x ), 'a', 'b' );

1

(1)

a;

sinx

(2)

b;

cosx

(3)
• 

The gcd command takes advantage of (partially) factored inputs and can thus return some partially factored results.

• 

The commands seq, add, and mul work better with infinities.

• 

Two-dimensional coordinate systems can be added using addcoords.

readlib( addcoords )( cnew, [ t1, t2 ], [ ( t1^2 - 1 ) / t2, ( t2^3 - 1 ) / t1 ] );

plot( sqrt( x ), x = -10 .. 10, coords = cnew );

• 

The coefficients of x^infinity and x^-infinity, in a polynomial, are 0:

coeff(p(x),x,infinity);

0

(4)

coeff(p(x),x,-infinity);

0

(5)
• 

The degree and ldegree commands now behave correctly with respect to the zero polynomial.

degree( 0, x );

(6)

ldegree( 0, x );

(7)
• 

The dsolve command has been rewritten to use Lie's symmetry methods by default, resulting in a remarkable improvement in its performance and functionality. Also dsolve is now fully integrated with the odeadvisor command (see DEtools,Lie).

ODE[1] := diff(y(x),x)=(y(x)-x*ln(x))^2/(x^2) + ln(x);

ODE1ⅆⅆxyx=yxxlnx2x2+lnx

(8)

DEtools[odeadvisor](ODE[1]);

_1st_order,_with_linear_symmetries,_Riccati

(9)

DEtools[symgen](ODE[1]);         # ODE symmetries

_ξ=x,_η=x+y

(10)

dsolve(ODE[1], can);

yx=x25lnx+5tanhlnx+c__1525510

(11)
  

A high order example solved using symmetries (see dsolve,Lie)

ODE[2] := diff(y(x),x,x)*diff(y(x),x)*y(x)*x^6 - 2*diff(y(x),x)^3*x^6
+ 2*diff(y(x),x)^2*y(x)*x^5+y(x)^5;

ODE2ⅆ2ⅆx2yxⅆⅆxyxyxx62ⅆⅆxyx3x6+2ⅆⅆxyx2yxx5+yx5

(12)

ans := dsolve(ODE[2], gon2);

ansyx=3x22xc__1x+12c__1x3c__2x2+22xc__1x+1

(13)
• 

dsolve now uses ODESolStruc to convey reductions of order of high order ODEs.

• 

The evala command has improved performance and functionality.

• 

The functions factors and eliminate are now readlib defined.

• 

The value command understands more functions: DESol, RESol, Hypergeom, Eval, Intat.

Eval( sin(x), x = Pi );

sinxx=π|sinxx=π

(14)

value( (14) );

0

(15)
• 

The galois command has been improved. The Galois groups of polynomials of degree up to 8 can now be computed.

  

Additionally, galois now returns more information about the groups it computes, including the order and sign (indicating whether the group is contained in the alternating group of the same degree). The form of generators has also changed; they are represented as Maple strings written in disjoint cycle notation.

readlib( galois ): with( group ):

p := sum( (-1)^i * x^(2*i) - i, i=0..4);

px8x6+x4x29

(16)

Grec := galois( p );

Grec8T44,[2^4]S(4),-,384,(4 8),(1 8)(4 5),(1 2 3 8)(4 5 6 7)

(17)

member( permgroup( degree( p, x ), {[]} ), DerivedS( permgroup( degree( p, x ), Grec[5] ) ) ); # is p(x) solvable by radicals?

true

(18)
• 

The sum command has been improved. Moenck's algorithm has been replaced with Abramov's algorithm. Performance is better and simpler representations are often achieved.

• 

Handling of the incomplete GAMMA function by expand has been improved.

• 

The performance of lattice has been improved.

• 

The testeq command is faster and more powerful.

• 

The optimizer (for expressions and computation sequences and simple maple procedures), optimize, has been improved. There is also a new option, tryhard{optimize}.

a := 'a': b := 'b': c := 'c':

f := proc(a,b,c)
        local   r,s;
        r := a * b + a * c;
        s := c * b + c^2;
        r - s;
end;

f:=proca,b,clocalr,s;r:=b*a+c*a;s:=c*b+c^2;rsend proc

(19)

codegen[optimize]( f );

proca,b,clocalt4;t4:=c^2;b*a+c*ac*bt4end proc

(20)

codegen[optimize]( f, 'tryhard' );

proca,b,clocalresult,t1;t1:=b+c;result:=a*t1c*t1end proc

(21)

f := 'f':

• 

The directory separator for the machine currently running Maple can be found using kernelopts(dirsep)

• 

To see the effect of optimization, we can use the cost function on the computation sequence from the body of f.

cs := [ r = a * b + a * c, s = c * b + c^2 ];

csr=ba+ca,s=cb+c2

(22)

codegen[optimize]( cs );

r=ba+ca,t4=c2,s=cb+t4

(23)

codegen[cost]( (23) );

2additions+4multiplications+3assignments

(24)

codegen[optimize]( cs, 'tryhard' );

t2=b+c,r=t2a,s=t2c

(25)

codegen[cost]( (25) );

additions+3assignments+2multiplications

(26)

Evaluation (eval, evala)

• 

Evaluation at a point, using the second argument of eval, has been added.  Note that this is defined quite generally, and can deal with expressions where subs was incorrect.

eval( sin(t - Pi/2), t = Pi );

1

(27)

eval( x/sin(x), x=0);

Error, numeric exception: division by zero

int(f(x),x=-infinity..infinity);

fxⅆx

(28)

eval( (28), f=(t->exp(-t^2)));

π

(29)
• 

Functions with special support for evaluation at a point:

  

diff, Diff,

  

int, Int,

  

limit, Limit,

  

product, Product,

  

sum, Sum,

  

the inttrans functions and piecewise.

eval( int( sin( t ), t = 0 .. x ), x = Pi/2 );

1

(30)

eval( int( f( t ), t = 0 .. x ), t = a );

0xftⅆt

(31)

eval( diff( abs(x), x ), x = 0 );

Error, (in `simpl/abs`) abs is not differentiable at 0

eval( diff( abs(x), x ), x = 1 );

1

(32)
  

In addition, a new command, intat, for "evaluating integrals at a point" has been added.

intat(F(a),a =r) = int(F(r),r);

` `rFaⅆa=Frⅆr

(33)

Intat(diff(F(z),z,z),z=G(x))=intat(diff(F(z),z,z),z=G(x));

` `Gxⅆ2ⅆz2Fzⅆz=DFGx

(34)
• 

The internals of evala have been substantially improved. It is now faster and more powerful.

• 

The evala command can now handle more expressions by operating recursively.

Expand( ( 1 + RootOf( x^2 - 2 ) )^1000 );

Expand1+RootOf_Z221000

(35)

evala( (35) );

21093096734545788527500836634727099588489384390319004814017810623293211815789209911283798336840541227810827362247961462076340236731742628764087168306758128066643738616268857975982438181087665615915626282432004505944399554607844270641892800758687636009968274277222295140088568054131815535180156183128363609909859421735474877635959333893583537947135921530940258496573995974651586025272RootOf_Z22+29830143474442298001129795174793040151744428847802742169166276817001664681121782120915351803428453748118551925116779805767489527890968849645306147349089263359830312589220741815894109864844474418807750002082487853475867434347137762094092099359890863256272576723592614162865351044825595779184368879043532947321306433685532982297015411679683242382695050673704586852323753879398408655937

(36)

Simplification (simplify)

• 

The simplify command has been extended to interpret the following functions.

  

Ci

  

LegendreP

  

LegendreQ

  

LerchPhi

  

Whittaker

  

wronskian

diff( LerchPhi( z, 3, 4 ), z );

LerchPhiz,2,4z4LerchPhiz,3,4z

(37)

simplify( (37) );

4z3+27z2+108polylog2,z432polylog3,z+324z108z5

(38)

Conversions (convert)

• 

convert(..., Sum)

  

Convert MeijerG functions to sums.

convert(MeijerG([[1,1],[2,2,2]],[[3,3,3,3],[4,4,4,4,4]],z),'Sum',z);

_k1=0−1_k1Γ4+_k12Γ3+_k13z4+_k11+_k15Γ2+_k19

(39)
• 

convert(..., dawson)

  

Convert to a Dawson integral. Dawson's integral is defined as

exp( -x^2 ) * Int( exp( t^2 ), t = 0 .. x );

ⅇx20xⅇt2ⅆt

(40)

convert( erf( x ), 'dawson' );

2Iⅇx2dawsonIxπ

(41)
• 

convert(..., erfi)

  

Convert to an expression in terms of the imaginary error function erfi.

convert( dawson( x ), 'erf' );

I2πerfIxⅇx2

(42)

convert( dawson( x ), 'erfi' );

πerfix2ⅇx2

(43)
• 

convert(..., sincos)

  

Specify only those terms that depend upon a specified variable which are to be converted, using an optional third parameter.

convert(cot(t)*tan(x),'sincos');

costsinxsintcosx

(44)

convert(cot(t)*tan(x),'sincos',x);

cottsinxcosx

(45)
• 

convert(..., StandardFunctions)

  

Convert functions represented in terms of hypergeometric functions and Meijer G functions to a form in terms of standard special and elementary functions.

convert( hypergeom([1,3],[1/2],z), 'StandardFunctions');

2z2+9z+881z3+15zarcsinz81z72

(46)
• 

convert(..., MeijerG)

  

Convert special functions to a form using MeijerG functions.

• 

convert(..., Riccati) and convert(..., linearODE)

  

Convert a linear second order homogeneous ODE into a first order Riccati type ODE and vice-versa; see convert,ODEs.

ODE := diff(y(x),x)-y(x)^2+y(x)*sin(x)-cos(x);

ODEⅆⅆxyxyx2+yxsinxcosx

(47)

ODE2 := convert(ODE,linearODE);

ODE2ⅆ2ⅆx2_ax=sinxⅆⅆx_axcosx_ax,yx=ⅆⅆx_ax_ax

(48)
  

The first element in the sequence above is the second order linear ODE and the second element is the transformation of variables used in the process.

  

The linear ODE can be reconverted into one of Riccati type introducing an arbitrary function _F1

convert(ODE2[1], Riccati);

ⅆⅆx_bx=_F1x_bx2+sinx_F1xⅆⅆx_F1x_bx_F1x+cosx_F1x,_ax=ⅇ_bx_F1xⅆxc__1

(49)

New Functions

Special Functions

  

Many new special functions have been added in Release 5.

• 

StruveH The Struve H function

dsolve(x^2*diff(y(x),x,x)+x*diff(y(x),x)+(x^2-v^2)*y(x)
=(4*(x/2)^(v+1))/(sqrt(Pi)*GAMMA(v+1/2)),y(x));

yx=BesselJv,xc__2+BesselYv,xc__1+StruveHv,x

(50)
• 

StruveL The Struve L function

dsolve(x^2*diff(y(x),x,x)+x*diff(y(x),x)-(x^2+v^2)*y(x)=(4*(x/2)^(v+1))/(sqrt(Pi)*GAMMA(v+1/2)),y(x));

yx=BesselIv,xc__2+BesselKv,xc__1+StruveLv,x

(51)
• 

LerchPhi The general Lerch Phi function is defined as the following integral.

( z, a, v ) -> Sum( z^n / ( v + n )^a, n = 0 .. infinity );

z,a,vn=0znv+na

(52)
• 

erfi The Imaginary Error Function. This is related to the error function erf by the following relation.

erfi( x ) = -I * erf( I * x );

erfix=−IerfIx

(53)
• 

KummerM - Kummer function M[mu], [nu](z)

• 

KummerU - Kummer function U[mu], [nu](z)

• 

LegendreP - The Legendre functions and associated Legendre functions of the first and second kinds

• 

LegendreQ -  The Legendre functions and associated Legendre functions of the first and second kinds

• 

LommelS1 - Lommel function s[mu], [nu](z)

• 

LommelS2 - Lommel function S[mu], [nu](z)

• 

WhittakerM - Whittaker function M[mu], [nu](z)

• 

WhittakerW - Whittaker function W[mu], [nu](z)

  

The Whittaker functions occur in the solution of the following differential equation.

dsolve( z * diff( y( z ), z, z ) + ( nu - z ) * diff( y( z ), z ) - mu * y( z ) = 0, y( z ) );

yz=c__1KummerMμ,ν,z+c__2KummerUμ,ν,z

(54)
• 

AiryAiZeros - Real zeros of the Airy Ai function

• 

BesselJZeros - Real zeros of Bessel J functions

• 

BesselYZeros - Real zeros of Bessel Y functions

map( AiryAi, [ AiryAiZeros( 1 .. 5 ) ] );

0

(55)

BesselJZeros(1/2,3);

3π

(56)

Other Functions

• 

intat and Intat for evaluating integrals at a point. In some cases, the solution to ODEs and PDEs returned by dsolve and pdsolve is presented using intat.

ODE := diff(diff(y(x),x),x) =
1/x^2*(diff(y(x),x)^2*x^2-2*y(x)*diff(y(x),x)*x+y(x)^2);

ODEⅆ2ⅆx2yx=ⅆⅆxyx2x22yxⅆⅆxyxx+yx2x2

(57)

dsolve(ODE);

yx=ⅇc__1Ei1ln1x+c__1+c__2x

(58)
• 

The new Maple PDE-solver, pdsolve, returns general or particular solutions for PDEs, and accepts hints.

PDE := S(x,y)*diff(S(x,y),y,x) + diff(S(x,y),x)*diff(S(x,y),y) = 1;

PDESx,y2xySx,y+xSx,yySx,y=1

(59)

pdsolve(PDE, HINT=P(x,y)^(1/2));

Sx,y=f__2x+f__1y+2yx

(60)
• 

odetest and pdetest are for testing implicit or explicit answers for ODEs and PDEs.

ODE := diff(y(x),x)=exp(y(x)/x)*ln(y(x)/x);

ODEⅆⅆxyx=ⅇyxxlnyxx

(61)

ans := dsolve(ODE,implicit);

ans` `yxx1ⅇ_aln_a_aⅆ_alnxc__1=0

(62)

odetest(ans, ODE);

0

(63)
• 

A new command for conveying reductions of order by dsolve was implemented (see ODESolStruc). A third order ODE reduced to a first order ODE of Riccati type.

ODE := diff(diff(diff(y(x),x),x),x) =
(y(x)-x)/diff(diff(y(x),x),x)*(-1+diff(y(x),x))^5;

ODEⅆ3ⅆx3yx=yxx1+ⅆⅆxyx5ⅆ2ⅆx2yx

(64)

ans := dsolve(ODE);

ansyx=_f+ⅇ_g_fⅆ_f+c__1ⅆ_f+c__2whereⅆⅆ_f_g_f=2_g_f2+_f_g_f,_f=yxx,_g_f=ⅆ2ⅆx2yx1+ⅆⅆxyx2,x=ⅇ_g_fⅆ_f+c__1ⅆ_f+c__2,yx=_f+ⅇ_g_fⅆ_f+c__1ⅆ_f+c__2

(65)
  

Reductions of order can also be tested using odetest

odetest(ans, ODE);

0

(66)
• 

The new solvefor function can be used to solve for a specified unknown, or set of unknowns, in an equation.  It is mostly meant to be used by the Context Menu functionality of the Graphical User Interface.  This function is related to eliminate but the output is easier to use in further interactive exploration.

solvefor[x]( x^2 - y^3 = 1 );

x=y3+1,x=y3+1

(67)

solvefor[y]( x^2 - y^3 = 1 );

y=x2113,y=x21132I3x21132,y=x21132+I3x21132

(68)
• 

You can augment a set of equations with initial conditions, using the new initialcondition routine.

de := diff( f( x ), x) = exp( x );

deⅆⅆxfx=ⅇx

(69)

initialcondition[ f ]( de );

ⅆⅆxfx=ⅇx,Dn0f0=0

(70)
• 

The new command charfcn can be used to represent the characteristic function of sets.

S := { 1, 2, 3, 4 };

S1,2,3,4

(71)

charfcn[ S ]( 2 );

1

(72)

charfcn[ S ]( 5 );

0

(73)

map( charfcn[ { a, b, c } ], [ c, d ] );

1,0

(74)

charfcn[ 0 .. 1 + I ]( 1 - I );

0

(75)

charfcn[ 0 .. 1 + I ]( ( 1 + I ) / 2 );

1

(76)

charfcn[ 0 .. 1000 ]( x );

charfcn0..1000x

(77)
• 

evalrC - Evaluate an expression using complex range arithmetic.

f := x -> x^2;

fxx2

(78)

dom := INTERVAL( 0, 0, 1, 1 );

domINTERVAL0,0,1,1

(79)

rng := evalrC( f( INTERVAL( 0, 0, 1, 1 ) ) );

rngINTERVAL−1,0,1,2

(80)

f := 'f':

with( plots ): with( plottools ):

dom_plot := rectangle( [op(1,dom),op(2,dom)],[op(3,dom),op(4,dom)], color=pink):

rng_plot :=  rectangle( [op(1,rng),op(2,rng)],[op(3,rng),op(4,rng)], color=yellow):

display( { dom_plot, rng_plot } ):

• 

intat - Integration at a point

• 

Intat - Inert integration at a point

Intat( f( t ), t = x );

` `xftⅆt

(81)

subs( f = sin, (81) );

` `xsintⅆt

(82)

value( (82) );

cosx

(83)
• 

The operators `^` and `**` are now active functions.

Changes to Functions

• 

The C procedure, which compiles Maple expressions to C code, is now in the codegen package.

• 

The C procedure can still be loaded using readlib.

• 

C handles ceil, floor, round, trunc

f := proc( a, b )
        local   t;
        t := a^2 + b^2;
        ceil( t );
end;

f:=proca,blocalt;t:=b^2+a^2;ceiltend proc

(84)

codegen[C]( f, 'optimized', 'ansi' );

#include <math.h>
int f(double a,double b)
{
  double t1;
  double t2;
  {
    t1 = a*a;
    t2 = b*b;
    return(ceil(t1+t2));
  }
}

• 

The fortran procedure, which compiles Maple into fortran code, is now part of the codegen package.

• 

However, fortran can be accessed without using readlib or with in Release 5.

fortran( f, optimized, mode = generic );

 integer function f(a,b)

 real a

 real b

 real t1

 real t2

   t1 = a**2

   t2 = b**2

   f = ceil(t1+t2)

   return

 end

f := 'f':

The Integrator

  

int of DESol

  

int of surd

  

lots of improvements on inttrans

  

the definite integrator has been substantially improved for the cases where the integrand can be converted to a MeijerG function and the usual theorems for integration of such functions apply

  

elliptic integration - Improved with symbolic parameters

• 

An integral that previous versions of Maple could not evaluate can now be solved in R5 in two different ways.

f := x -> 1/(1+x^3)^(1/3):

r := Int(f(x),x);

r1x3+113&DifferentialD;x

(85)
  

Let's evaluate this integral.

value(r);

xhypergeom13&comma;13&comma;43&comma;x3

(86)
  

Maple can also compute this integral in algebraic form, and to do that, we'll convert the integral into RootOf notation.

g := convert(r, RootOf);

g1RootOf_Z3x31&comma;index=1&DifferentialD;x

(87)
  

Maple can compute the value of g using the Risch-Trager algorithm. On a Pentium Pro 200, R5 evaluates this integral in half the time it takes R4 to perform it.

value(g);

RootOf_Z2_Z+1lnRootOf_Z2_Z+12x33RootOf_Z2_Z+1RootOf_Z3x31&comma;index=12x3RootOf_Z2_Z+1RootOf_Z3x31&comma;index=1x24RootOf_Z2_Z+1x3+3RootOf_Z3x31&comma;index=12x+3RootOf_Z3x31&comma;index=1x2+4x3RootOf_Z2_Z+1+23lnRootOf_Z2_Z+12x3+3RootOf_Z2_Z+1RootOf_Z3x31&comma;index=12x+3RootOf_Z2_Z+1RootOf_Z3x31&comma;index=1x2+2RootOf_Z2_Z+1x3+x3+RootOf_Z2_Z+1+1RootOf_Z2_Z+13+lnRootOf_Z2_Z+12x3+3RootOf_Z2_Z+1RootOf_Z3x31&comma;index=12x+3RootOf_Z2_Z+1RootOf_Z3x31&comma;index=1x2+2RootOf_Z2_Z+1x3+x3+RootOf_Z2_Z+1+13

(88)

convert((88), radical);

12+I32ln12+I322x3312+I32x3+123x312+I32x3+113x2412+I32x3+3x3+123x+3x3+113x2+4x3+32I323ln12+I322x3+312+I32x3+123x+312+I32x3+113x2+212+I32x3+x3+32+I3212+I323+ln12+I322x3+312+I32x3+123x+312+I32x3+113x2+212+I32x3+x3+32+I323

(89)
  

And we verify that the solution is indeed correct.

simplify(diff((89),x)-f(x));

0

(90)
  

New Hermite reduction-type algorithms have been implemented for some classes of elementary functions where the solution is in terms of polylogarithms.

int(ln(x+1)^2/x, x);

lnx+12lnx+2lnx+1polylog2&comma;x+12polylog3&comma;x+1

(91)

int(x^3/(exp(x)-a)^2, x);

x3a&ExponentialE;x+a+x44a2x3ln1&ExponentialE;xaa23x2polylog2&comma;&ExponentialE;xaa2+6xpolylog3&comma;&ExponentialE;xaa26polylog4&comma;&ExponentialE;xaa2x3a2+3x2ln1&ExponentialE;xaa2+6xpolylog2&comma;&ExponentialE;xaa26polylog3&comma;&ExponentialE;xaa2

(92)
  

The following examples can now be evaluated in R5 using newly implemented algorithms of Meijer G Function representations.

int(z^n*BesselJ(nu,z),z);

zn+ν1BesselJν&comma;zLommelS1n1&comma;ν1&comma;zzBesselJν1&comma;zLommelS1n&comma;ν&comma;z

(93)

int(sin(b*x)/(x^2+z^2)^rho, x=0..infinity);

0sinbxx2+z2ρ&DifferentialD;x

(94)

int(cos(alpha*x^2+2*b*x), x=0..infinity);

limxπ2cosb2αFresnelC2αx+bπα+sinb2αFresnelS2αx+bπαcosb2αFresnelCb2παsinb2αFresnelSb2πα2α

(95)

int(cos(b*x)*arctan(a/x^2), x=0..infinity);

0cosbxarctanax2&DifferentialD;x

(96)

int(cos(b*sqrt(x))*BesselJ(0,c*x)/sqrt(x), x=0..infinity);

0cosbxBesselJ0&comma;cxx&DifferentialD;x

(97)

int(BesselJ(1,b*x)*BesselJ(1,c*x)/x^2, x=0..infinity);

0BesselJ1&comma;bxBesselJ1&comma;cxx2&DifferentialD;x

(98)

int(x*BesselJ(nu/4, b*x^2)^2*BesselJ(nu, c*x), x=0..infinity);

0xBesselJν4&comma;bx22BesselJν&comma;cx&DifferentialD;x

(99)

int(exp(I*p*x)*HankelH1(0,c*x),x=0..infinity);

0&ExponentialE;Ix8x6+x4x29xHankelH10&comma;cx&DifferentialD;x

(100)

int(x^(nu+1)*sin(c*x^2/(2*a))*BesselK(nu,c*x), x=0..infinity);

0xν+1sincx22aBesselKν&comma;cx&DifferentialD;x

(101)

int(sin(b*x^2)*BesselK(nu,c*x), x=0..infinity);

0sinbx2BesselKν&comma;cx&DifferentialD;x

(102)

The Differential Equation solvers

• 

The differential equation solver dsolve has been substantially rewritten.  It is now much more powerful, and uses several new techniques for finding closed form solutions.

• 

The most noticable improvements are in the areas of nonlinear ODEs and ODEs with special function solutions.

• 

The partial differential equation solve pdesolve is now obsolete, and has been replaced by the much more powerful pdsolve.

• 

There is now a wealth of tools available to manipulate, explore and solve differential equations and related objects in the packages PDEtools and DEtools.

Pattern Matcher

  

applyrule - applying rules

  

compiletable - table lookup

  

patmatch - pattern matching

  

tablelook - table lookup

  

define - define characteristics of an operator name

  

definemore - define characteristics of an operator name

• 

Several example worksheets are available: examples/patmatch examples/define examples/applyrl.