Items tagged with functions functions Tagged Items Feed


Symbolic sequences enter in various formulations in mathematics. This post is about a related new subpackage, Sequences, within the MathematicalFunctions package, available for download in Maplesoft's R&D page for Mathematical Functions and Differential Equations (currently bundled with updates to the Physics package).


Perhaps the most typical cases of symbolic sequences are:


1) A sequence of numbers - say from n to m - frequently displayed as

n, `...`, m


2) A sequence of one object, say a, repeated say p times, frequently displayed as


3) A more general sequence, as in 1), but of different objects and not necessarily numbers, frequently displayed as

a[n], `...`, a[m]

or likewise a sequence of functions

f(n), `...`, f(m)

In all these cases, of course, none of n, m, or p are known: they are just symbols, or algebraic expressions, representing integer values.


These most typical cases of symbolic sequences have been implemented in Maple since day 1 using the `$` operator. Cases 1), 2) and 3) above are respectively entered as `$`(n .. m), `$`(a, p), and `$`(a[i], i = n .. m) or "`$`(f(i), i = n .. m)." To have computer algebra representations for all these symbolic sequences is something wonderful, I would say unique in Maple.

Until recently, however, the typesetting of these symbolic sequences was frankly poor, input like `$`(a[i], i = n .. m) or ``$\``(a, p) just being echoed in the display. More relevant: too little could be done with these objects; the rest of Maple didn't know how to add, multiply, differentiate or map an operation over the elements of the sequence, nor for instance count the sequence's number of elements.


All this has now been implemented.  What follows is a brief illustration.


First of all, now these three types of sequences have textbook-like typesetting:

`$`(n .. m)

`$`(n .. m)


`$`(a, p)

`$`(a, p)


For the above, a$p works the same way

`$`(a[i], i = n .. m)

`$`(a[i], i = n .. m)


Moreover, this now permits textbook display of mathematical functions that depend on sequences of paramateters, for example:

hypergeom([`$`(a[i], i = 1 .. p)], [`$`(b[i], i = 1 .. q)], z)

hypergeom([`$`(a[i], i = 1 .. p)], [`$`(b[i], i = 1 .. q)], z)


IncompleteBellB(n, k, `$`(factorial(j), j = 1 .. n-k+1))

IncompleteBellB(n, k, `$`(factorial(j), j = 1 .. n-k+1))


More interestingly, these new developments now permit differentiating these functions even when their arguments are symbolic sequences, and displaying the result as in textbooks, with copy and paste working properly, for instance

(%diff = diff)(hypergeom([`$`(a[i], i = 1 .. p)], [`$`(b[i], i = 1 .. q)], z), z)

%diff(hypergeom([`$`(a[i], i = 1 .. p)], [`$`(b[i], i = 1 .. q)], z), z) = (product(a[i], i = 1 .. p))*hypergeom([`$`(a[i]+1, i = 1 .. p)], [`$`(b[i]+1, i = 1 .. q)], z)/(product(b[i], i = 1 .. q))


It is very interesting how much this enhances the representation capabilities; to mention but one, this makes 100% possible the implementation of the Faa-di-Bruno  formula for the nth symbolic derivative of composite functions (more on this in a post to follow this one).

But the bread-and-butter first: the new package for handling sequences is


[Add, Differentiate, Map, Multiply, Nops]


The five commands that got loaded do what their name tells. Consider for instance the first kind of sequences mentione above, i.e

`$`(n .. m)

`$`(n .. m)


Check what is behind this nice typesetting

lprint(`$`(n .. m))

`$`(n .. m)


All OK. How many operands (an abstract version of Maple's nops  command):

Nops(`$`(n .. m))



That was easy, ok. Add the sequence

Add(`$`(n .. m))



Multiply the sequence

Multiply(`$`(n .. m))



Map an operation over the elements of the sequence

Map(f, `$`(n .. m))

`$`(f(j), j = n .. m)


lprint(`$`(f(j), j = n .. m))

`$`(f(j), j = n .. m)


Map works as map, i.e. you can map extra arguments as well

MathematicalFunctions:-Sequences:-Map(Int, `$`(n .. m), x)

`$`(Int(j, x), j = n .. m)


All this works the same way with symbolic sequences of forms "((a,`...`,a))" , and a[n], `...`, a[m]. For example:

`$`(a, p)

`$`(a, p)


lprint(`$`(a, p))

`$`(a, p)


MathematicalFunctions:-Sequences:-Nops(`$`(a, p))



Add(`$`(a, p))



Multiply(`$`(a, p))



Differentation also works

Differentiate(`$`(a, p), a)

`$`(1, p)


MathematicalFunctions:-Sequences:-Map(f, `$`(a, p))

`$`(f(a), p)


MathematicalFunctions:-Sequences:-Differentiate(`$`(f(a), p), a)

`$`(diff(f(a), a), p)


For a symbolic sequence of type 3)

`$`(a[i], i = n .. m)

`$`(a[i], i = n .. m)


MathematicalFunctions:-Sequences:-Nops(`$`(a[i], i = n .. m))



Add(`$`(a[i], i = n .. m))

sum(a[i], i = n .. m)


Multiply(`$`(a[i], i = n .. m))

product(a[i], i = n .. m)


The following is nontrivial: differentiating the sequence a[n], `...`, a[m], with respect to a[k] should return 1 when n = k (i.e the running index has the value k), and 0 otherwise, and the same regarding m and k. That is how it works now:

Differentiate(`$`(a[i], i = n .. m), a[k])

`$`(piecewise(k = i, 1, 0), i = n .. m)


lprint(`$`(piecewise(k = i, 1, 0), i = n .. m))

`$`(piecewise(k = i, 1, 0), i = n .. m)


MathematicalFunctions:-Sequences:-Map(f, `$`(a[i], i = n .. m))

`$`(f(a[i]), i = n .. m)


Differentiate(`$`(f(a[i]), i = n .. m), a[k])

`$`((diff(f(a[i]), a[i]))*piecewise(k = i, 1, 0), i = n .. m)


lprint(`$`((diff(f(a[i]), a[i]))*piecewise(k = i, 1, 0), i = n .. m))

`$`((diff(f(a[i]), a[i]))*piecewise(k = i, 1, 0), i = n .. m)



And that is it. Summarizing: in addition to the former implementation of symbolic sequences, we now have textbook-like typesetting for them, and more important: Add, Multiply, Differentiate, Map and Nops. :)


The first large application we have been working on taking advantage of this is symbolic differentiation, with very nice results; I will see to summarize them in a post to follow in a couple of days.



Edgardo S. Cheb-Terrab
Physics, Differential Equations and Mathematical Functions, Maplesoft


I have a procedure wich is something like 


F:=proc(a,b,l) limit(f(a,b),b=l); end proc;

For my specific problem, the limit always exists and is a well defined function

After that, I would like to generate other functions, depending on F(a,b,l), e.g.:


G:=proc(a,b,N) add(F(a,b,l),l=1..N); end proc;


However, when I tried to do that, Maple inserts in G an unevaluated F, depending on the results of the limits. This makes G not work properly (unevaluated), since the limit is not computed before G. I tried to use some intermediate steps, like using unapply command, but it does not works.

If someone can help, I would appreciate.



Hi everyone:

I have two functions in terms of theta variable, how can I expressed function Y(X)?

X :=(theta)->cos(theta)+0.8e-1*cos(3.*theta)

Y :=(theta)->-sin(theta)+0.8e-1*sin(3.*theta)

I will earn Y(X) infact.

Thanks alot...





I'm looking at Maple as a possible alternative to Mathcad (which I've been using for years, but is now very jaded compared to other options like Maple and Mathematica).  I'm a civil engineer and for what I do, one of the better features of Mathcad is the way it handles units.  For example, if I specify an angle in degrees (say phi=30 degrees) and then ask for sin(phi), I get 0.5.  At face value, I though Maple would do the same kind of thing.  However, this doesn't appear to be the case (see attached worksheet).  The only workaround that I can see is to specify the angle in degrees (but without assigning ) and then multiply the specified value by pi/180 (to convert to radians) before passing it to the sin function.  Which is all a bit messy and not at all an attractive solution.

Am I misunderstanding the way units work in Maple and is there a clean way of specifying angles in degrees (which is what engineers work with) and using these values directy in trig functions?

Thanks in anticipation,


With this application we can meet safety characteristics of a relationship and simple or compound functions. Made with maple 2015.

(in spanish)



I am trying to implement the following basis functions $h_n(t)$. Please suggest how to implement. thanks


Hey Everyone:

I was wondering what are your favorite and most useful code snippets that you often use. Maybe ones that are in your initialization code? Maybe ones that speed up something that you often do in maple? Maybe ones that you've seen on this and other websites and adopted for your own purposes?

For fun, I attach my init.mpl (.txt here, as .mpl attachments are not allowed by mapleprimes) here init.txt

Some of the snippets that I use the most are also listed below:

#rearrange curves inside an already created plot, so that certain curves are "on top" of the other ones.
#discussed here:
rearrangeCurves:= proc(
     v_items::specfunc(anything, PLOT),
     v_reorder::list([integer,integer]):= []
local p, curves, rest;
     (curves,rest):= selectremove(type, v_items, specfunc(anything, CURVES));
     curves:= < op(curves) >:         
     for p in v_reorder do
          curves[p]:= curves[p[[2,1]]]
     end do;
     PLOT(convert(curves,list)[], op(rest))
end proc:

#for numerical differentiation
#based on the idea from:
#example use:
#alist:=[seq(i, i=0..10, 0.1)]:
#data:=map(x->evalf(sin(x)), alist):
#plot(alist, data);
#plot([cos(x), 'num_diff(x, LinearAlgebra:-Transpose(Matrix([alist,data])))'], x=1..10, thickness=5, linestyle=[solid, dot], color=[blue, red]);
num_diff:=proc(x, v_data, v_options:=[method=spline, degree=3])
 #v_data is a matrix
 #TODO: let the data be in a more arbitrary format that ArrayInterpolation understands, but keep x as first var
 evalf(D[1](x->CurveFitting:-ArrayInterpolation(v_data, [x],v_options[])[])(x));

#extract nth columns/rows from a matrix
#these only work if have a 2d object... should be updated to also work
#with 1d row/column vectors
#Example use cases
#A := LinearAlgebra:-RandomMatrix(20, 20, outputoptions = [datatype = float[8]]);
#nthColumns(A, 2); #Every other column
#nthRows(A, 10)[.., 1..3]; #Every 10th row, but show only first 3 columns
nthColumns:=proc(v_m, v_n)
  v_m[..,[seq(i, i=1..rtable_size(v_m)[2], v_n)]]
nthRows:=proc(v_m, v_n)
  v_m[[seq(i, i=1..rtable_size(v_m)[1], v_n)],..]

#saves a png plot
savePlot:=proc(v_p, v_fileName, v_w:="800", v_h:="500")
    plotsetup("png", plotoutput=v_fileName, plotoptions=cat("quality=100,portrait,noborder,width=",v_w,",height=",v_h));


I have solved ODE's with either i.c. or b.c. (mechanics stuff) where the results were in terms of expressions, not functions.  I could plot these expressions, substitute values in for parameters, etc. 

Then I thought that the real way to solve an ODE or system of ODE's was to define functions.  I wanted this to be in three levels: the solutions in generality, the solutions with i.c./m.c. applied, and then further with the parameter values defined. 

So far, no joy.  Lots of confusion--input eqns as sequence, list, set?  I looked on the Maple help page, thought I was doing things right. I even tried out "union" for the ode's and the ic's.

The code is below; statement (11) produces an error. Yes, I am using Maple 18, even though the file says Maple 15.  I'd like to solve the 4-ODE system at the three levels listed above, and then (if possible), plot the result! Am I asking too much?  Should I be using MapleSim or some other product instead?


Thanks for any and all help!


robert w.



assume(m1 > 0);

eqn1 := diff(z1(t), t) = z2(t);

diff(z1(t), t) = z2(t)


eqn2 := diff(z2(t), t) = -(k1+k2)*z1(t)/m1-(c1+c2)*z2(t)/m1+k2*z3(t)/m1+c2*z4(t)/m1;

diff(z2(t), t) = -(k1+k2)*z1(t)/m1-(c1+c2)*z2(t)/m1+k2*z3(t)/m1+c2*z4(t)/m1


eqn3 := diff(z3(t), t) = z4(t);

diff(z3(t), t) = z4(t)


eqn4 := diff(z4(t), t) = k2*z1(t)/m2+c2*z2(t)/m2-k2*z3(t)/m2-c2*z4(t)/m2;

diff(z4(t), t) = k2*z1(t)/m2+c2*z2(t)/m2-k2*z3(t)/m2-c2*z4(t)/m2


eqns := eqn1, eqn2, eqn3, eqn4;

diff(z1(t), t) = z2(t), diff(z2(t), t) = -(k1+k2)*z1(t)/m1-(c1+c2)*z2(t)/m1+k2*z3(t)/m1+c2*z4(t)/m1, diff(z3(t), t) = z4(t), diff(z4(t), t) = k2*z1(t)/m2+c2*z2(t)/m2-k2*z3(t)/m2-c2*z4(t)/m2


var := z1(t), z2(t), z3(t), z4(t);

z1(t), z2(t), z3(t), z4(t)


ic1 := z1(0) = -2;

z1(0) = -2


ic2 := z2(0) = 0;

z2(0) = 0


ic3 := z3(0) = 1;

z3(0) = 1


ic4 := z4(0) = 0;

z4(0) = 0


ics := ic1, ic2, ic3, ic4;

z1(0) = -2, z2(0) = 0, z3(0) = 1, z4(0) = 0


dsolve(`union`(eqns, ics), var)

Error, invalid input: `union` received diff(z1(t), t) = z2(t), which is not valid for its 1st argument



z1(t), z2(t), z3(t), z4(t)



m1 = 1, m2 = 2, m3 = 1, c1 = 0, c2 = 0, c3 = 0, k1 = 5, k2 = 2, k3 = 2


eqnsev := subs(data, eqns);

diff(z4(t), t) = z1(t)-z3(t)




I have the following system I need to solve:


dy(t)/dt = alpha(t)-y(t)





 I am trying to get functions of y(t) and x(t), so I can plot y(t), x(t) and alpha(t) as it changes over time.


I have tried using dsolve to no effect.  I define the inital conditions, I define the functions I am looking for and when I press enter dsolve doesn't return anything.  I also know all the constants and defined them as well.




Thank you.




thanks for the answers below, I can now get listing of content of an .mla like this:


But could not yet find a command that actually lists the standard *.mla libraries that come with Maple. I have to go to C:\Program Files\Maple 18\lib and copy the name of each file with .mla extention in there to get its content. Is there a way to obtain a list of all the .mla files or the standard libraries so that to automate all of this? Otherwise, I'll just copy the names of all the mla files in the above folder and make a list of them manually.

original question:

in Maple, I can do ?packages to get a help page showing list of packages available. But I need a way to do this in code, and obtain result as list or set. Next I'd like to go over each package and also obtain list of all symbols and functions/proc in this package.

For example, once I get list of packages, I'd like to get list of functions in say algcurves package, so I should get ["AbelMap", "algfun_series_sol",.....].  The list can be just strings. That is ok, I am just trying to enumerate all packages and build-in commands and symbols in Maple. May be make a small report of it for documentation purposes and to get better idea what is in Maple.

What are the commands I need to get such lists?

I am using Maple 18.02 on windows.


I am trying to define some functions by recursion relations but I get this error:

Error, (in type/realcons) too many levels of recursion

Please see the attached file for details:

I'm trying to find the partial sum of the function. Now I need to plot the first couple partial sums onto 1 graph.

I'm not really sure how to input the plot function. I was able to graph it by inputting each partial sum function but I would prefer an easier solution.

I'm trying to solve a series of equations and then graph them. I'm trying to solve for the variables involved:

values := solve({eq1, eq2, eq3, eq4, eq5, eq6, eq7, eq8, eq9,

eq10, eq11, eq12, eq13, eq14, eq15, eq16}, {a, b, b, c, d, e, f,

g, h, i, j, k, l, m, n, o, p});


. . . but it gives me this:

Warning, solving for expressions other than names or functions is not recommended. 

values := 

Hi all;

I have following program for plotting numerous function using hybrid functions.

if g1(t) is arbitrary function and g2(t) is its approximate by hybrid functions, I want to have a table of g1(t)-g2(t) for different value of t. but the result is without numeric values. what part is wrong????

best wishes


Mahmood   Dadkhah

Ph.D Candidate

Applied Mathematics Department

1 2 3 4 5 6 7 Last Page 1 of 42