## Weakness in limit and MultiSeries:-limit

Maple

Let us consider

```J := int(x^n/sqrt(1+x^n), x = 0 .. 1) assuming n > 0;

2*(2^(1/2)-hypergeom([1/2, 1/n], [(n+1)/n], -1))/(2+n)

limit(J,n=infinity);
FAIL
MultiSeries:-limit(J,n=infinity);
FAIL```

Mma 11 finds the limit is zero. Hope one feels the difference.

## Discordance of outputs of two limit commands

Maple
```limit((x^2-1)*sin(1/(x-1)), x = infinity, complex);
infinity-infinity*I
MultiSeries:-limit((x^2-1)*sin(1/(x-1)), x = infinity, complex);
infinity```

whereas the same outputs are expected. The help http://www.maplesoft.com/support/help/Maple/view.aspx?path=infinity&term=infinity does not shed light on the problem. Here are few pearls:

• infinity is used to denote a mathematical infinity, and hence it is usually used as a symbol by itself or as -infinity.
• The quantities infinity, -infinity, infinity*I, -infinity*I, infinity + y*I, -infinity + y*I, x + infinity*I and x - infinity*I, where x and y are finite, are all considered to be distinct in Maple. However, all 2-component complex numerics in which both components are infinity are considered to be the same (representing the single point at the "north pole" of the Riemann sphere).
• The type cx_infinity can be used to recognize this "north pole" infinity.

## Utilizing MapleSim to Improve Assisted Living...

This MaplePrimes guest blog post is from Dr. James Smith, an Assistant Lecturer in the Electrical Engineering and Computer Science Department of York University’s Lassonde School of Engineering. His team has been working with Maplesim to improve the design of assistive devices.

As we go through our everyday lives, we rarely give much thought to the complex motions and movements our bodies go through on a regular basis. Motions and movements that seem so simple on the surface require more strength and coordination to execute than we realize. And these are made far more difficult as we age or when our health is in decline. So what can be done to assist us with these functions?

In recent years, my research team and I have been working on developing more practical and streamlined devices to assist humans with everyday movements, such as standing and sitting. Our objective was to determine if energy could be regenerated in prosthetic devices during these movements, similar to the way in which hybrid electric vehicles recover waste heat from braking and convert it into useable energy.

People use – and potentially generate – more energy than they realize in carrying out common, everyday movements. Our research for this project focused on the leg joints, and investigated which of the three joints (ankle, knee or hip) was able to regenerate the most energy throughout a sitting or standing motion. We were confident that determining this would lead to the development of more efficient locomotive devices for people suffering from diseases or disabilities affecting the muscles around these joints.

In order to identify the point at which regenerative power is at its peak, we determined that MapleSim was the best tool to help us gather the desired data. We took biomechanical data from actual human trials and applied them to a robotic model that mimics human movements when transitioning between sitting and standing positions. We created models to measure unique movements and energy consumption at each joint throughout the identified movements to determine where the greatest regeneration occurred.

To successfully carry out our research, it was essential that we were able to model the complex chemical reactions that occur within the battery needed to power the assistive device. It is a challenge finding this feature in many engineering software programs and MapleSim’s battery modeling library saved our team a great deal of time and effort during the process, as we were able to use an existing MapleSim model and simply make adjustments to fit our project.

Using MapleSim, we developed a simplified model of the human leg with a foot firmly planted on the ground, followed by a more complex model with a realistic human foot that could be raised off the ground. The first model was used to create a simplified model-based motion controller that was then applied to the second model. The human trials we conducted produced the necessary data for input into a multi-domain MapleSim model that was used to accurately simulate the necessary motions to properly analyze battery autonomy.

The findings that resulted from our research have useful and substantial applications for prostheses and orthoses designs. If one is able to determine the most efficient battery autonomy, operation of these assistive devices can be prolonged, and smaller, lighter batteries can be used to power them. Ultimately, our simulations and the resulting data create the possibility of more efficient devices that can reduce joint loads during standing to sitting processes, and vice versa.

## Bugs in FromMma

Maple

Let us consider

```MmaTranslator:-FromMma(" Table[0,{n=10},{m=2}]");

[seq([seq(0,i=1..(m := 2))],j=1..(n := 10))]
```

The above result is syntactically incorrect in Maple language. The translation should be

```Matrix(10,2)
#or
[seq([seq(0,i=1.. 2)],j=1..10)]```

up to the Mmma's result

```Table[0, {n = 10}, {m = 2}]

{{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0,0}, {0, 0}}```

Another bug is as follows.

```MmaTranslator:-FromMma("Sinc[x]");

Sinc(x)```

whereas the expected result is piecewise(x=0,1,sin(x)/x) up to http://reference.wolfram.com/language/ref/Sinc.html

In general, the MmaTranslator package is outdated. It often returns working Mma's commands as incorrect (Concrete examples are long and need a context. These may be exposed on demand.). The question arises about the quality of other Maple translations.

## Bug in implicitplot

Maple

The command

```plots:-implicitplot(evalc(argument((1+x+I*y)/(1-x-I*y))) <= (1/4)*Pi, x = -5 .. 5, y = -5 .. 5, crossingrefine = 1, gridrefine = 2, rational = true, filled, signchange = true, resolution = 1000);
```

produces an incorrect result

in view of

```evalf(argument((1-4+4*I)/(1+4-4*I)));
2.889038378
```

There is a workaround

`plots:-inequal(evalc(argument((1+x+I*y)/(1-x-I*y))) <= (1/4)*Pi, x = -5 .. 5, y = -5 .. 5);`

Maple

The command

`restart; st := time(): FunctionAdvisor(EllipticE); time()-st;`

produces the result on my comp in 805.484 s. Too much time.

## Bug in int

The command

`J := int(sin(x)/(x*(1-2*a*cos(x)+a^2)), x = 0 .. infinity)assuming a::real,a^2 <>0;`

outputs

`(infinity*I)*signum(a^3*(Sum(a^_k1, _k1 = 0 .. infinity))-a^2*(Sum(a^_k1, _k1 = 0 .. infinity))-a*(Sum(a^(-_k1), _k1 = 0 .. infinity))+a^2+Sum(a^(-_k1), _k1 = 0 .. infinity)+a)`

which is wrong in view of

```evalf(eval(J, a = 1/2));
Float(undefined) I```

The correct answer is Pi/(4*a)*(abs((1+a)/(1-a))-1) according to G&R 3.792.6. Numeric calculations confirm it.

## Bug in minimize/maximize

Maple

Both the commands

```maximize(x*sin(t)+y*sin(2*t), t = 0 .. 2*Pi)assuming x>=0,y>=0;
minimize(x*sin(t)+y*sin(2*t), t = 0 .. 2*Pi)assuming x>=0,y>=0;```

output 0. Simply no words.

## Bug in implicitplot

Maple

The following three commands

```plots:-implicitplot(3*cos(x) = tan(y)^3, x = -Pi .. Pi, y = -(1/2)*Pi-1 .. (1/2)*Pi+1, thickness = 3, crossingrefine = 1, rational = true, signchange = true, resolution = 1000, gridrefine = 2);
plots:-implicitplot(3*cos(x) = tan(y)^3, x = -Pi .. Pi, y = -(1/2)*Pi-1 .. (1/2)*Pi+1, thickness = 3, crossingrefine = 1, rational = true, signchange = false, resolution = 1000, gridrefine = 2);
plots:-implicitplot(3*cos(x) = tan(y)^3, x = -Pi .. Pi, y = -(1/2)*Pi-1 .. (1/2)*Pi+1, thickness = 3, crossingrefine = 1, rational = true, resolution = 1000, gridrefine = 2);```

produce the same incorrect plot

It is clear the sraight lines given by y=Pi/2 and y=-Pi/2 are superfluous. It should be noticed that the Mmma's ContourPlot command without any options produces a correct plot.

## Critical bug in solve

Maple 2016
 • If the solve command does not find any solutions, then if the second argument is a name or set of names, then the empty sequence (NULL) is returned; if the second argument is a list, then the empty list is returned. This means that there are no solutions, or the solve command cannot find the solutions. In the second case, a warning is issued, and the global variable_SolutionsMayBeLost is set to true.

Let us consider

```solve({x > -Pi, (tan(x)-tan(x)^2)^2-cos(x+4*tan(x)) = -1, x < Pi}, [x]);
[]
```

We see the command omits the solution x=0 without any warning. It should be noticed that Mathematica solves it, outputting

{{x -> 0}, {x -> 0}}

and the warning

Solve::incs: Warning: Solve was unable to prove that the solution set found is complete.

One may draw a conclusion on her/his own.

## A graphical view of Maple releases

Maple

Just a simple graphical view of Maple releases over the years.

```with(plots):
MapleVersions := [[1, 1982], [1.1, 1982.05], [2, 1982.33], [2.1, 1982.42], [2.15, 1982.58], [2.2, 1982.92], [3, 1983.17], [3.1, 1983.75], [3.2, 1984.25], [3.3, 1985.17], [4, 1986.25], [4.1, 1987.33], [4.2, 1987.92], [4.3, 1989.17], [5.1, 1990.58], [5.2, 1992.83], [5.3, 1994.17], [5.4, 1996], [5.5, 1997.83], [6, 1999.92], [7, 2001.5], [8, 2002.25], [9, 2003.42], [9.5, 2004.25], [10, 2005.33], [10.01, 2005.58], [10.02, 2005.83], [10.03, 2006.17], [10.04, 2006.42], [10.05, 2006.5], [10.06, 2006.75], [11, 2007.08], [11.01, 2007.5], [11.02, 2007.83], [12, 2008.33], [12.01, 2008.75], [12.02, 2008.92], [13, 2009.25], [13.01, 2009.5], [13.02, 2009.75], [14, 2010.25], [14.01, 2010.75], [15, 2011.25], [15.01, 2011.42], [16, 2012.17], [16.01, 2012.33], [17, 2013.17], [17.01, 2013.5], [18, 2014.17], [18.01, 2014.33], [18.015, 2014.5], [18.02, 2014.83], [19, 2015.17], [19.1, 2015.33], [20, 2016.17], [20.1, 2016.25], [20.15, 2016.30]]
a:=map(ListTools:-Reverse,MapleVersions): #swap x-y axis
plot(a, style = point, symbol = point)
```

## Goldbaugh Verification

Maple 13

Hi Mapleprimes,

I have made this little procedure with Maple.

check_g_conjecture_10.pdf

similar to this next one check_g_conjecture_10.mw

This may be worth a look.

Regards,

Matthew

In My Humble Opinion, Wikipedia is a good crowd sourced resource.

## Cutting problem (2 procedures)

by:

This post - this is a generalization of the question from  here .
Suppose we have  m  divisible objects that need to be divided equally between n persons, and so that the total number of parts (called  N  in the text of the procedure) after cutting should be a minimum. Cutting procedure exactly solves this problem. It can be proved that the estimate holds  n<=N<=n+m-1, and  N<n+m-1 if and only if there are several objects (< m), whose measures sum to be a multiple of the share (Obj in the text of the procedure).

In the attached file you can find also the text of the second procedure Cutting1, which is approximately solves the problem. The procedure Cutting1 is much faster than Cutting. But the results of their work are usually the same or Cutting procedure gives a slightly better result than Cutting1.

Required parameters of the procedure: L is the list of the measures of the objects to be cutted, n is the number of persons. The optional parameter  Name is a name or the list of names of the objects of L (if the latter then should be nops(L)=nops(Name) ).

Cutting:=proc(L::list(numeric), n::posint, Name::{name,list(name)}:=Object)

local m, n1, L1, L11, mes, Obj, It, M, N;

uses combinat, ListTools;

m:=nops(L); L1:=sort([seq([`if`(Name::name,Name||i,Name[i]),L[i]], i=1..m)], (a,b)->a[2]<=b[2]);

mes:=table(map(t->t[1]=t[2],L1));

Obj:=`+`(L[])/n;

It:=proc(L1, n)

local i, M, m1, S, n0, a, L2;

if nops(L1)=1 then return [[[L1[1,1],Obj]] \$ n] fi;

if n=1 then return [L1] fi;

for i from 1 while `+`(seq(L1[k,2],k=1..i))<=Obj do

od;

M:=[seq(choose(L1,k)[], k=1..ceil(nops(L1)/2))];

S:=[];

for m1 in M while nops(S)=0 do n0:=`+`(seq(m1[k,2],k=1..nops(m1)))/Obj;

if type(n0,integer) then S:=m1 fi;

od;

if nops(S)=0 then

a:=Obj-`+`(seq(L1[k,2],k=1..i-1));

L2:=[[L1[i,1],L1[i,2]-a],seq(L1[k],k=i+1..nops(L1))];

[[seq(L1[k], k=1..i-1),`if`(a=0,NULL,[L1[i,1],a])],It(L2,n-1)[]] else L2:=sort(convert(convert(L1,set) minus convert(S,set), list),(a,b)->a[2]<=b[2]);

[It(S,n0)[], It(L2,n-n0)[]] fi;

end proc;

M:=It(L1,n);

Flatten(M, 1);

[Categorize((a,b)->a[1]=b[1],%)];

print(``);

print(cat(`Cutting scheme (total  `, N, `  parts):`) );

print(map(t->[seq(t[k,2]/`+`(seq(t[k,2],k=1..nops(t)))*t[1,1],k=1..nops(t))], %)[]);

print(``);

print(`Scheme of sharing out:`);

seq([Person||k,`+`(seq(M[k,i,2]/mes[M[k,i,1]]*M[k,i,1], i=1..nops(M[k])))],k=1..n);

end proc:

Examples of use.

First example from the link above:

Cutting([225,400,625], 4, Cake);  # 3 cakes must be equally divided by 4 persons

eval(%,[Cake1,Cake2,Cake3]=~[225,400,625]);  # Check

Second example (the same for 10 persons):

Cutting([225,400,625], 10, Cake);

Third example (7 identical apples should be divided between 12 persons):

Cutting([1 \$ 7], 12, apple);

Edited:

1. Fixed a bug in the procedure Cutting  (I forgot sort the list  L2  in sub-procedure  It  if  nops(S)<>0 ).

2. Changes made to the sub-procedure  It  for the case if there are several objects (>1  and  < m), whose measures                     sum to be a multiple of the share  Obj .

## Digitizing mathematics: ODEs, Special Functions...

by: Maple

The material below was presented in the "Semantic Representation of Mathematical Knowledge Workshop", February 3-5, 2016 at the Fields Institute, University of Toronto. It shows the approach I used for “digitizing mathematical knowledge" regarding Differential Equations, Special Functions and Solutions to Einstein's equations. While for these areas using databases of information helps (for example textbooks frequently contain these sort of databases), these are areas that, at the same time, are very suitable for using algorithmic mathematical approaches, that result in much richer mathematics than what can be hard-coded into a database. The material also focuses on an interesting cherry-picked collection of Maple functionality, that I think is beautiful, not well know, and seldom focused inter-related as here.

 Digitizing of special functions, differential equations, and solutions to Einstein’s equations within a computer algebra system   Edgardo S. Cheb-Terrab Physics, Differential Equations and Mathematical Functions, Maplesoft Editor, Computer Physics Communications

 • Big amounts of knowledge available to everybody in local machines or through the internet
 • Take advantage of basic computer functionality, like searching and editing

 • By digitizing mathematical knowledge inside appropriate computational contexts that understand about the topics, one can use the digitized knowledge to automatically generate more and higher level knowledge
 Challenges 1) how to identify, test and organize the key blocks of information,   2) how to access it: the interface,   3) how to mathematically process it to automatically obtain more information on demand
 Three examples

Mathematical Functions

"Mathematical functions, are defined by algebraic expressions. So consider algebraic expressions in general ..."

"Supporting information on definitions, identities, possible simplifications, integral forms, different types of series expansions, and mathematical properties in general"

 Examples
 General description
 References

Differential equation representation for generic nonlinear algebraic expressions - their use

"Compute differential polynomial forms for arbitrary systems of non-polynomial equations ..."

 The Differential Equations representing arbitrary algebraic expresssions
 Deriving knowledge: ODE solving methods
 Extending the mathematical language to include the inverse functions
 Solving non-polynomial algebraic equations by solving polynomial differential equations
 References

Branch Cuts of algebraic expressions

"Algebraically compute, and visualize, the branch cuts of arbitrary mathematical expressions"

 Examples
 References

Algebraic expresssions in terms of specified functions

"A conversion network for arbitrary mathematical expressions, to rewrite them in terms of different functions in flexible ways"

 Examples
 General description
 References

Symbolic differentiation of algebraic expressions

"Perform symbolic differentiation by combining different algebraic techniques, including functions of symbolic sequences and Faà di Bruno's formula"

 Examples
 References

Ordinary Differential Equations

"Beyond the concept of a database, classify an arbitrary ODE and suggest solution methods for it"

 General description
 Examples
 References

Exact Solutions to Einstein's equations

"The authors of "Exact solutions toEinstein's equations" reviewed more than 4,000 papers containing solutions to Einstein’s equations in the general relativity literature, organized the whole material into chapters according to the physical properties of these solutions. These solutions are key in the area of general relativity, are now all digitized and become alive in a worksheet"

The ability to search the database according to the physical properties of the solutions, their classification, or just by parts of keywords (old paradigm) changes the game.

More important, within a computer algebra system this knowledge becomes alive (new paradigm).

 • The solutions are turned active by a simple call to one commend, called the g_  spacetime metric.
 • Everything else gets automatically derived and set on the fly ( Christoffel symbols  , Ricci  and Riemann  tensors orthonormal and null tetrads , etc.)
 • Almost all of the mathematical operations one can perform on these solutions are implemented as commands in the Physics  and DifferentialGeometry  packages.
 • All the mathematics within the Maple library are instantly ready to work with these solutions and derived mathematical objects.

Finally, in the Maple PDEtools package , we have all the mathematical tools to tackle the equivalence problem around these solutions.

 Examples
 References

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

## Quantization of the Lorentz Force

by: Maple

This presentation is on an undergrad intermediate Quantum Mechanics topic. Tackling the problem within a computer algebra worksheet in the way shown below is actually the novelty, using the Physics package to formulate the problem with quantum operators and related algebra rules in tensor notation.

Quantization of the Lorentz Force

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2

(1) Laboratoire PhLAM, UMR CNRS 8523, Université Lille 1, F-59655, France

(2) Maplesoft

We consider the case of a quantum, non-relativistic, particle with mass m and charge q evolving under the action of an arbitrary time-independent magnetic field where  is the vector potential. The Hamiltonian for this system is

where  is the momentum of the particle, and the force acting in this particle, also called the Lorentz force, is given by

where  is the quantized velocity of the particle, and all of  , , , ,  and  are Hermitian quantum operators representing observable quantities.

In the classic (non-quantum) case,  for such a particle in the absence of electrical field is given by

=  ,

Problem: Departing from the Hamiltonian, show that in the quantum case the Lorentz force is given by [1]

[1] Photons et atomes, Introduction à l'électrodynamique quantique, p. 179, Claude Cohen-Tannoudji, Jacques Dupont-Roc et Gilbert Grynberg - EDP Sciences janvier 1987.

Solution

We choose to tackle the problem in Heisenberg's picture of quantum mechanices, where the state of a system is static and only the quantum operators evolve in time according to

Also, the algebraic manipulations are simpler using tensor abstract notation instead of the standard 3D vector notation. We then start setting the framework for the problem, a system of coordinates X, indicating the dimension of the tensor space to be 3 and the metric Euclidean, and that we will use lowercaselatin letters to represent tensor indices. In addition, not necessary but for convenience, we set the lowercase latin i to represent the imaginary unit and we request automaticsimplification so that the output of everything comes automatically simplified in size.

 >
 >
 (1)

Next we indicate the letters we will use to represent the quantum operators with which we will work, and also the standard commutation rules between position and momentum, always the starting point when dealing with quantum mechanics problems

 >
 (2)

Note that we start not indicating  as Hermitian, in order to arrive at that result. The quantum operators , , and  are explicit functions of X, so to avoid redundant display of this functionality on the screen we use

 >
 (3)

Define now as tensors the quantum operators that we will use with tensorial notation (recalling: for these, Einstein's sum rule for repeated indices will be automatically applied when simplifying)

 >
 (4)

The Hamiltonian,

in tensorial notation, is given by

 >
 (5)

Generally speaking to arrive at   what we now need to do is

1) Express this Hamiltonian (5) in terms of the velocity

And, recalling that, in Heisenberg's picture, quantum operators evolve in time according to

2) Take the commutator of  with the velocity itself to obtain its time derivative and, from  , that commutator is already the force up to some constant factors.

To get in contact with the basic commutation rules between position and momentum behind quantum phenomena, the quantized velocity itself can be computed as the time derivative of the position operator, i.e as the commutator of  with

 >
 (6)

This expression for the velocity, that involves commutators between the potential , the position  and the momentum , can be simplified taking into account the basic quantum algebra rules between position and momentum. We assume that (X) can be decomposed into a formal power series (possibly infinite) of the , hence all the  commute between themselves as well as with all the

 >
 (7)

(Note: in some cases, this is not true, but those cases are beyond the scope of this worksheet.)

Add these rules to the algebra rules already set so that they are all taken into account when simplifying things

 >
 (8)
 >
 (9)

The right-hand side of (9) is then the kth component of the velocity tensor quantum operator, the relationship is the same as in the classical case

 >
 (10)

and with this the Hamiltonian (5) can now be rewritten in term of the velocity completing step 1)

 >
 (11)

For step 2), to compute

we need the commutator between the different components of the quantized velocity which, contrary to what happens in the classical case, do not commute. For this purpose, take the commutator between (10) with itself after replacing the free index

 >
 (12)

To simplify (12), we use the fact that if f  is a commutative mapping that can be decomposed into a formal power series in all the complex plan (which is assumed to be the case for all (X)), then

where  is the momentum operator along the  axis. This relation reads in tensor notation:

 >
 (13)

Add this rule to the rules previously set in order to automatically take it into account in (12)

 >
 (14)
 >
 (15)

Also add this other rule so that it is taken into account automatically

 >
 (16)

Recalling now the expression of the Hamiltonian (11) as a function of the velocity, one can compute the components of the force operator

 >
 (17)

Simplify this expression for the quantized force taking the quantum algebra rules (16) into account

 >
 (18)

It is not difficult to verify that this is the antisymmetrized vector product . Departing from  expressed using tensor notation,

 >
 (19)

and taking into acount that

multiply both sides of (19) by , getting

 >
 (20)
 >
 (21)

Finally, replacing the repeated index m by n

 >
 (22)

Likewise, for

multiplying (19), this time from the right instead of from the left, we get

 >
 (23)
 >
 (24)

Simplifying now the expression (18) for the quantized force taking into account (22) and (24) we get

 >
 (25)

i.e.

in tensor notation. Finally, we note that this operator is Hermitian as expected

 >
 (26)

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

 First 21 22 23 24 25 26 27 Last Page 23 of 62
﻿