MaplePrimes Posts

Latest Posts Latest Posts Feed

Thу post is the answer to  http://www.mapleprimes.com/questions/200355-Clever-Cutter-3?reply=reply

This message contains two procedures . The first procedure called  LargestIncircle  symbolically looks for the largest circle inscribed in a convex polygon . Polygon must be specified as a list of lists of its vertices . If the polygon does not have parallel sides , the problem has a unique solution , otherwise may be several solutions . It is easy to prove that there is always a maximum circle that touches three sides of the polygon . Procedure code based on this property of the optimal solution.

The second procedure called  MinCoveringCircle  symbolically seeking smallest circle that encloses a given set of points. The set of points can be anyone not necessarily being vertices of a convex polygon. Procedure code based on the following geometric properties of the optimal solution , which can easily be proved :

1) The minimum covering circle is unique.

2) The minimum covering circle of a set Set can be determined by at most three points in  Set  which lie on the boundary of the circle. If it is determined by only two points, then the line segment joining those two points must be a diameter of the minimum circle. If it is determined by three points, then the triangle consisting of those three points is not obtuse.

 

Code of the 1st procedure:

restart;

LargestIncircle:=proc(L::listlist)

local n, x, y, P, S, T, Eqs, IsInside, OC, Pt, E, R, t, Sol, P0, R1, Circle;

uses combinat, geometry;

 

n:=nops(L); _EnvHorizontalName := x; _EnvVerticalName := y;

P:=[seq(point(A||i, L[i]), i=1..n)];

if nops(convexhull(P))<n then error "L should be a convex polygon" fi;

S:={seq(line(l||i,[A||i, A||(i+1)]), i=1..n-1), line(l||n,[A||n, A||1])};

Eqs:=map(lhs,{seq(Equation(l||i), i=1..n)});

T:=choose({seq(l||i, i=1..n)}, 3);

 

IsInside:=proc(Point, OC, Eqs)

convert([seq(is(eval(Eqs[i], {x=Point[1], y=Point[2]})*eval(Eqs[i], {x=OC[1], y=OC[2]})>0), i=1..n)], `and`);

end proc;

 

OC:=[add(L[i,1], i=1..n)/n, add(L[i,2], i=1..n)/n]; 

R:=0; point(Pt,[x,y]);

   for t in T do

     solve([distance(Pt,t[1])=distance(Pt,t[2]),      distance(Pt,t[2])=distance(Pt,t[3])],[x,y]);

     Sol:=map(a->[rhs(a[1]), rhs(a[2])], %);

     P0:=op(select(b->IsInside(b, OC, Eqs), Sol)); if P0<>NULL then R1:=distance(point(E,P0),      t[1]);

     if convert([seq(is(R1<=distance(E, i)), i=S minus t)], `and`) and is(R1>R) then R:=R1;      Circle:=[P0, R] fi; fi;

   od; 

Circle; 

end proc:

 

Code the 2nd procedure:

MinCoveringCircle:=proc(Set::{set, list}(list))

local S, T, t, d, A, B, C, P, R, R1, O1, Coord, L;

uses combinat, geometry; 

if type(Set, list) then S:=convert(Set, set) else S:=Set fi;

T:=choose(S, 2);

   for t in T do

      d:=simplify(distance(point(A, t[1]), point(B, t[2]))); midpoint(C, A, B);

      if convert([seq(is(distance(point(P, p), C)<=d/2), p in S minus {t[1], t[2]})], `and`)   then return            [coordinates(C), d/2] fi;

   od;

T:=choose(S, 3);

R:=infinity;

   for t in T do

      point(A, t[1]); point(B, t[2]); point(C, t[3]);

      if is(distance(A, B)^2<=distance(B, C)^2+distance(A, C)^2 and        distance(A,C)^2<=distance(B,        C)^2+distance(A, B)^2 and distance(B, C)^2 <= distance(A, C)^2 + distance(A, B)^2) then

      circle(c, [A,B,C],'centername'=O1); R1:=radius(c); Coord:=coordinates(O1);

      if convert([seq(is(distance(point(P, p), O1)<=R1), p in S minus {t[1], t[2], t[3]})], `and`) and is(R1<R) then    R:=R1; L:=[Coord, R] fi; fi;

   od; 

L; 

end proc: 

 

Examples of using the first procedure:

L:=[[0,2],[1,4],[4,4],[5,1],[3,0]]:

C:=LargestIncircle(L);

A:=plottools[disk](op(C), color=green):

B:=plottools[polygon](L, style=line, thickness=2):

plots[display](A,B, scaling=constrained);

 

 

The procedure can be used to find the largest circle inscribed in a convex shape, bounded by the curves, if these curves are approximated by broken lines:

L:=[seq([k,k^2], k=-1..2, 0.1)]:

C:=LargestIncircle(L);

A:=plottools[disk](op(C), color=green):

B:=plottools[polygon](L, style=line, thickness=2):

plots[display](A,B, scaling=constrained);

 

 

Examples of using the second procedure:

L:=[[0,2],[1,4],[4,4],[5,1],[3,0]]:

C:=MinCoveringCircle(L);

A:=plottools[circle](op(C), color=red, thickness=2):

B:=plottools[polygon](L, color=cyan):

plots[display](A,B);

 

 

The smallest circle covering 30 random points:

> roll:=rand(1..10):

L:=[seq([roll(), roll()], i=1..30)]:

C:=MinCoveringCircle(L);

A:=plottools[circle](op(C), color=red, thickness=2):

B:=seq(plottools[disk](L[i],0.07,color=blue), i=1..nops(L)):

C1:=plottools[disk](C[1], 0.07, color=red):

T:=plots[textplot]([C[1,1]-0.2, C[1,2]-0.2, "C"], font=[TIMES,ROMAN,16]):

plots[display](A, B, C1, T);

 

 

The attached presentation is the second one of a sequence of three that we want to do on Quantum Mechanics using Computer Algebra. The first presentation was about the equation for a quantum system of identical particles, the Gross-Pitaevskii equation (GPE). This second presentation is about the spectrum of its solutions. The level is that of an advanced undergraduate QM course. The novelty is again in the way these problems can be tackled nowadays in a computer algebra worksheet with Physics.

 

The Gross-Pitaevskii equation and Bogoliubov spectrum
  

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

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

(2) Maplesoft, Canada

 

Departing from the equation for a quantum system of identical boson particles, i.e.the Gross-Pitaevskii equation (GPE), the dispersion relation for plane-wave solutions are derived, as well as the Bogoliubov equations and dispersion relations for small perturbations `&delta;&varphi;` around the GPE stationary solutions.

Stationary and plane-wave solutions to the Gross-Pitaevskii equation

 


Problem: Given the Gross-Pitaevskii equation, NULL

I*`&hbar;`*psi[t] = (G*abs(psi)^2+V)*psi-`&hbar;`^2*%Laplacian(psi)/(2*m)

  

a) Derive a relationship between the chemical potential mu entering the phase of stationary, uniform solutions, the atom-atom interaction constant G and the particle density n = abs(psi)^2 in the absence of an external field (V = 0).

  

b) Derive the dispersion relation for plane-wave solutions as a function of G and n. 

  

 

Background: The Gross-Pitaevskii equation is particularly useful to describe Bose Einstein condensates (BEC) of cold atomic gases [3, 4, 5]. The temperature of these cold atomic gases is typically in the w100 nano-Kelvin range. The atom-atom interaction are repulsive for G > 0 and attractive for G < 0 , where G is the interaction constant. The GPE is also widely used in non-linear optics to model the propagation of light in optical fibers.

Solution

   

The Bogoliubov equations and dispersion relations

 

 

Problem: Given the Gross-Pitaevskii equation,

  

a) Derive the Bogoliubov equations, that is, equations for elementary excitations `&delta;&varphi;` and conjugate(`&delta;&varphi;`)around a GPE stationary solution `&varphi;`(x, y, z), NULL

 

"{[[i `&hbar;` (&PartialD;)/(&PartialD;t) `delta&varphi;`=-(`&hbar;`^2 (&nabla;)^2`delta&varphi;`)/(2 m)+(2 G |`&varphi;`|^2+V-mu) `delta&varphi;`+G `&varphi;`^2 (`delta&varphi;`),,],[i `&hbar;` (&PartialD;)/(&PartialD;t)( `delta&varphi;`)=+(`&hbar;`^2 (&nabla;)^2(`delta&varphi;`))/(2 m)-(2 G |`&varphi;`|^2+V-mu) (`delta&varphi;`)-G `delta&varphi;` ((`&varphi;`))^(2),,]]"

  


b) Show that the dispersion relations of these equations, known as the Bogoliubov spectrum, are given by

  

epsilon[k] = `&hbar;`*omega[k] and `&hbar;`*omega[k] = `&+-`(sqrt(`&hbar;`^4*k^4/(4*m^2)+`&hbar;`^2*k^2*G*n/m)),

  


where k is the wave number of the considered elementary excitation, epsilon[k] its energy or, equivalently, omega[k] its frequency.

Solution

   

NULL

References

NULL

[1] Gross-Pitaevskii equation (wiki)

[2] Continuity equation (wiki)
[3] Bose–Einstein condensate (wiki)

[4] Dispersion relations (wiki)

[5] Advances In Atomic Physics: An Overview, Claude Cohen-Tannoudji and David Guery-Odelin, World Scientific (2011), ISBN-10: 9812774963.

[6] Nonlinear Fiber Optics, Fifth Edition (Optics and Photonics), Govind Agrawal, Academic Press (2012), ISBN-13: 978-0123970237.

 

 

QuantumMechanics.pdf     Download QuantumMechanics2.mw

Edgardo S. Cheb-Terrab
Physics, Maplesoft

MapleSim 6.3 includes substantial improvements to the MapleSim simulation engine, resulting in faster model pre-processing times, more flexible code generation, and expanded support for Modelica-based custom components. 

For more information, see What’s New in MapleSim.

 

eithne

Hi,
Relevant developments in Physics happened during the last month and a 1/2, some of them of interest beyond the use of this package. Among the most exciting things I can mention:

  1. The redefinition of the derivative rule for the complex components (abs, argument, conjugate, Im, Re, signum) together with the introduction of Wirtinger calculus, as an user-option to work with complex variables. In other words: it is now possible to compute taking z and its conjugate as independent variables and in equal footing.
  2. Introduction of textbook mathematical display for all the inert functions of the mathematical language, also for unknown functions f(x).
  3. New options in Physics:-Setup to indicate that some mathematical objects are real (different from assume(x, real), while integrated with `is` and `coulditbe`).
  4. A rather large number of micro developments advancing the integration of Physics with simplify, expand and combine.
  5. Another large number of micro developments for quantum mechanics.
  6. New options in Physics:-Setup to redefine sum as Physics:-Library:-Add, and with that have access to multiindex summation directly from sum, for instance as in sum(f(i, j), i + j <= n), including related typesetting copy & paste.

As usual the latest version of the package is available for download in the Maplesoft Physics: Research & Development webpage  and in the zip there is a worksheet illustrating all these developments. Below I'm copying the section related to the new redefinesum option of Physics:-Setup and multiindex summation.

Thanks to everyone who provided feedback, it has been of great value and at the root of this new round of developments.

December 4

 
• 

New option in Setup: redefinesum, so that the sum command is redefined in such a way that
    a) the sum arguments are processed in a way avoiding premature evaluation and related unexpected results or error interruptions
    b) the sum command includes new functionality present in Physics:-Library:-Add to perform sum over integer values of many indices, as in

"(&sum;)S(i,j)"     or  "(&sum;)S(i,j)" 

restart; with(Physics); Setup(notation = true)

`* Partial match of  'notation' against keyword 'mathematicalnotation'`

 

[mathematicalnotation = true]

(1.1)

New option: redefine sum so that its arguments are processed by the more modern Physics:-Library:-Add and so that it can perform multiindice summation.

 

Example:

By default, the sum command is not redefined, so the value of redefinesum is

Setup(redefinesum)

[redefinesum = false]

(1.2)

Consider this multiindex summation functionality of the Physics:-Library:-Add command

Library:-Add(f[i, j], 1 <= i+j and i+j <= n)

Physics:-Library:-Add(f[i, j], i+j <= n, lowerbound = 1)

(1.3)

For instance, for n = 2,

eval(Physics[Library]:-Add(f[i, j], i+j <= n, lowerbound = 1), n = 2)

f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0]

(1.4)

This functionality can be plugged directly into the sum command. For that purpose, set redefinesum to true

Setup(redefinesum = true)

[redefinesum = true]

(1.5)

You can now compute directly with sum. The left-hand side is inert while the right-hand side is computed

(%sum = sum)(f[i, j], i+j <= 2)

%sum(f[i, j], i+j <= 2) = f[0, 0]+f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0]

(1.6)

(%sum = sum)(f[i, j], 1 <= i+j and i+j <= 2)

%sum(f[i, j], 1 <= i+j and i+j <= 2) = f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0]

(1.7)

value(%sum(f[i, j], 1 <= i+j and i+j <= 2) = f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0])

f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0] = f[0, 1]+f[1, 0]+f[0, 2]+f[1, 1]+f[2, 0]

(1.8)

The formula for the integer power of a sum

(a+b+c)^n = sum(factorial(n)*a^p*b^q*c^r/(factorial(p)*factorial(q)*factorial(r)), p+q+r = n)

(a+b+c)^n = sum(Physics:-`*`(Physics:-`*`(Physics:-`*`(Physics:-`*`(factorial(n), Physics:-`*`(1, Physics:-`^`(Physics:-`*`(Physics:-`*`(factorial(p), factorial(q)), factorial(r)), -1))), Physics:-`^`(a, p)), Physics:-`^`(b, q)), Physics:-`^`(c, r)), p+q+r = n)

(1.9)

eval((a+b+c)^n = sum(Physics[`*`](Physics[`*`](Physics[`*`](Physics[`*`](factorial(n), Physics[`*`](1, Physics[`^`](Physics[`*`](Physics[`*`](factorial(p), factorial(q)), factorial(r)), -1))), Physics[`^`](a, p)), Physics[`^`](b, q)), Physics[`^`](c, r)), p+q+r = n), n = 2)

(a+b+c)^2 = a^2+2*a*b+2*a*c+b^2+2*b*c+c^2

(1.10)

eval((a+b+c)^n = sum(Physics[`*`](Physics[`*`](Physics[`*`](Physics[`*`](factorial(n), Physics[`*`](1, Physics[`^`](Physics[`*`](Physics[`*`](factorial(p), factorial(q)), factorial(r)), -1))), Physics[`^`](a, p)), Physics[`^`](b, q)), Physics[`^`](c, r)), p+q+r = n), n = 3)

(a+b+c)^3 = a^3+3*a^2*b+3*a^2*c+3*a*b^2+6*a*b*c+3*a*c^2+b^3+3*b^2*c+3*b*c^2+c^3

(1.11)

Verify whether this equation is true

(`@`(evalb, expand))((a+b+c)^3 = a^3+3*a^2*b+3*a^2*c+3*a*b^2+6*a*b*c+3*a*c^2+b^3+3*b^2*c+3*b*c^2+c^3)

true

(1.12)

Besides this new functionality, the redefined sum does a more modern handling of its arguments, consider a typical problem posted in Maple primes

a := 1; b := 2; j := 3

1

 

2

 

3

(1.13)

In the following summation, j is a dummy summation index, so the value just assigned, j := 3, is not expected to interfer with the summation. This is the case with the redefined sum

sum(f(j), j = a .. b)

f(1)+f(2)

(1.14)

while without redefining sum the input above is interrupted with an error message. Likely, in this other case also reported in Mapleprimes

g := proc (j) options operator, arrow; if j::odd then G[j] else 0 end if end proc

proc (j) options operator, arrow; if j::odd then G[j] else 0 end if end proc

(1.15)

the following two summations can be performed after having redefining sum:

sum(g(i), i = 1 .. f)

sum(g(i), i = 1 .. f)

(1.16)

For the summation above, without redefining sum, it returns 0 instead of unevaluated, because of a premature evaluation of the function g(i) with an unassigned index i before performing the summation. Returning unevaluated as (1.16) permits evaluate the sum at a latter moment, for instance attributing a value to f

eval(sum(g(i), i = 1 .. f), f = 3)

G[1]+G[3]

(1.17)

And this other sum where f is given from the begining also returns 0 without redefining sum

sum(g(i), i = 1 .. 3)

G[1]+G[3]

(1.18)

Problems like this other one reported in Mapleprimes here also get resolved with this redefinition of sum.

 

 

Download sum_in_physics.mw

Edgardo S. Cheb-Terrab
Physics, Maplesoft

 

The attached presentation is the first one of a sequence of three that we wanted to do on Quantum Mechanics using Computer Algebra. The level is that of an advanced undergraduate QM course. Tackling this topic within a computer algebra worksheet in the way it's done below, however, is an entire novelty, and illustrates well the kind of computations that can be done today with Maple & Physics.

Ground state of a quantum system of identical boson particles
  

Pascal Szriftgiser1 and Edgardo S. Cheb-Terrab2 

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

(2) Maplesoft

 

Departing from the Energy of a quantum system of identical boson particles, the field equation is derived. This is the Gross-Pitaevskii equation (GPE). A continuity equation for this system is also derived, showing that the velocity flow satisfies `&x`(VectorCalculus[Nabla], `#mover(mi("v"),mo("&rarr;"))`) = 0, i.e.: is irrotational.  

The Gross-Pitaevskii equation

 

NULL


Problem: derive the field equation describing the ground state of a quantum system of identical particles (bosons), that is, the Gross-Pitaevskii equation (GPE).

 

Background: The Gross-Pitaevskii equation is particularly useful to describe Bose Einstein condensates (BEC) of cold atomic gases [3, 4, 5], that is, an ensemble of identical quantum boson particles that interact with each other with an interaction constant G. The temperature of these cold atomic gases is typically in the w100 nano-Kelvin range. The atom-atom interactions are repulsive for G > 0 and attractive for G < 0  (which could lead to some instabilities). The GPE is also widely used in non-linear optics to model the propagation of light in optical fibers. In this area, GPE is known as "non-linear Schrödinger equation", and the non-linearity comes from the Kerr effect [6].

Solution

   

Continuity equation for a quantum system of identical particles

   

References

``

[1] Gross-Pitaevskii equation (wiki)

[2] Continuity equation (wiki)
[3] Bose–Einstein condensate (wiki)

[4] Bose-Einstein Condensation in Dilute Gases, C. J. Pethick and H. Smith, Second Edition, Cambridge (2008), ISBN-13: 978-0521846516.

[5] Advances In Atomic Physics: An Overview, Claude Cohen-Tannoudji and David Guery-Odelin, World Scientific (2011), ISBN-10: 9812774963.

[6] Nonlinear Fiber Optics, Fifth Edition (Optics and Photonics), Govind Agrawal, Academic Press (2012), ISBN-13: 978-0123970237.

 


Downlioad: QuantumMechanics1.mw,    QuantumMechanics1.pdf

Edgardo S. Cheb-Terrab
Physics, Maplesoft

The DirectSearch package is a powerful Maple  tool. However, every soft has its advantages and disadvantages. In particular, the DS has problems in the case of a thin feasible set in higher dimensions. Recently a serious bug in the DS was detected by me. Solving an optimization problem, the DirectSearch produces the error communication

Warning, initial point [x1 = 1., x2 = 1., x4 = 2., y1 = 2., y2 = 3., y4 = 2.] does not satisfy the inequality constraints; trying to find a feasible initial point
Error, (in DirectSearch:-Search) cannot find feasible initial point; specify a new one
 while that initial point satisfies the constraints.

 

restart

DirectSearch:-Search(((x2-x1)^2+(y2-y1)^2)*((x4-x1)^2+(y4-y1)^2), {seq(parse(y || j) >= -(2/3)*parse(x || j)+2, j = 1 .. 4), seq(parse(y || j) >= (1/2)*parse(x || j)-3/2, j = 1 .. 4), seq(parse(y || j) <= 4, j = 1 .. 4), seq(parse(y || j) <= -3*parse(x || j)+16, j = 1 .. 4), seq(parse(y || j) <= 2*parse(x || j)+2, j = 1 .. 4), (x2-x1)*(x4-x1)+(y2-y1)*(y4-y1) = 0, (x3-x2)*(x2-x1)+(y3-y2)*(y2-y1) = 0, (x4-x1)*(x4-x3)+(y4-y1)*(y4-y3) = 0, (x4-x3)*(x3-x2)+(y4-y3)*(y3-y2) = 0}, maximize, initialpoint = [x1 = 1, x2 = 1, x3 = 2, x4 = 2, y1 = 2, y2 = 3, y3 = 3, y4 = 2])

Error, (in DirectSearch:-Search) cannot find feasible initial point; specify a new one

 

eval({seq(parse(y || j) >= -(2/3)*parse(x || j)+2, j = 1 .. 4), seq(parse(y || j) >= (1/2)*parse(x || j)-3/2, j = 1 .. 4), seq(parse(y || j) <= 4, j = 1 .. 4), seq(parse(y || j) <= -3*parse(x || j)+16, j = 1 .. 4), seq(parse(y || j) <= 2*parse(x || j)+2, j = 1 .. 4), (x2-x1)*(x4-x1)+(y2-y1)*(y4-y1) = 0, (x3-x2)*(x2-x1)+(y3-y2)*(y2-y1) = 0, (x4-x1)*(x4-x3)+(y4-y1)*(y4-y3) = 0, (x4-x3)*(x3-x2)+(y4-y3)*(y3-y2) = 0}, [x1 = 1, x2 = 1, x3 = 2, x4 = 2, y1 = 2, y2 = 3, y3 = 3, y4 = 2])

{0 = 0, -1 <= 2, -1 <= 3, 2 <= 4, 2 <= 6, 2 <= 10, 2 <= 13, 3 <= 4, 3 <= 6, 3 <= 10, 3 <= 13, -1/2 <= 2, -1/2 <= 3, 2/3 <= 2, 2/3 <= 3, 4/3 <= 2, 4/3 <= 3}

(1)

``

 

Download opti.mw

Greetings to all.

As some of you may remember I made several personal story type posts concerning my progress in solving enumeration problems with the Polya Enumeration Theorem (PET). This theorem would seem to be among the most exciting in mathematics and it is of an amazing simplicity so that I never cease to suggest to mathematics teachers to present it to gifted students even before university. My previous efforts are documented at your site, namely at this MaplePrimes link I and this MaplePrimes link II.

I have been able to do another wonderful cycle index computation using Maple recently and I would like to share the Maple code for this problem, which is posted at Math StackExchange.com (this post includes the code) This time we are trying to compute the cycle index of the automorphism group of the 3-by-3-by-3 cube under rotations and reflections. I suggest you try this problem yourself before you look at my solution. Enjoy!

I mentioned in some of my other posts concerning PET that Maple really ought to come with a library of cycle indices and the functions to manipulate them. I hope progress has been made on this issue. I had positive feedback on this at the time here at your website. Do observe that you have an opportinuity here to do very attractive mathematics if you prepare a worksheet documenting cycle index facilities that you may eventually provide. This is good publicity owing to the fact that you can include images of the many geometric objects that appear which all look quite enticing and moreover potential readers get rewarded quickly as they discover that it takes little effort to master this theorem and proceed to work with symmetries themselves and investigate them. This sort of thing also makes nice slides.

With best wishes for happy combinatorics computing,

Marko Riedel

Here 'show triangle napoleon considering the sintaxis Maple, to be supplemented and explained with Math Apps.

Napoleon_Triangle.mw

 

Lenin Araujo Castillo

Hi
In connection with recent developments in the Physics package, we now have mathematical typesetting for all the inert functions of the mathematical language. Hey! This is within the Physics update available on the Maplesoft Physics: Research & Development webpage

I think this is an interesting development that will concretely change the computational experience with these functions: it is not the same to compute with something you see displayed as %exp(x) instead of the same computation but flowing with it nicely displayed as an exponential function with the e in grey, reflecting that Maple understands this object as the exponential inert function, with known properties (all those of the active exp function), and so Maple can compute with the inert one taking these properties into account while not executing the function itself - and this is the essence of the inert function behaviour.

Introducing mathematical display, copy and paste for all these inert functions of the mathematical language concretely increases the mathematical expressiveness of the system, for teaching, working and also for presenting ideas.

Attached is a brief illustration.

Edgardo S. Cheb-Terrab
Physics, Maplesoft

InertMathematicalFun.mw  InertMathematicalFun.pdf

Hi all,

I seem to have triggered a nasty bug in Maple 17.  Consider the following code:

  BlahObject := module()
    option object;
    export BlahMethod := proc()
    local C, d, i;
      add(C[i]*d[i] + C[i], i=1..4);
    return NULL;
    end proc;
  end module;

It triggers a Maple kernel crash for me when doing object construction:

 B := Object(BlahObject);

The offending line is the one with add( ). It is ok if I add C[i]*d[i], but when the line contains both * and + it causes kernel death every time.  This is strange as the proc is not even being executed... only constructing the object. 

I am running Maple 17.02, it's also present in 17.01.  But interestingly, it runs fine in Maple 16.  Bug in Maple 17? 

Thanks,
Ian.

Maplesoft is a long standing supporter of the Who Wants to Be a Mathematician contest for high school students. For years, we have donated Maple as prizes to winners of the national and regional contests.

This year, being the 25th anniversary of Maplesoft’s incorporation, the company decided to support several projects that encourage the use of math amongst high school students and young adults. We dedicated a bigger budget towards projects that would enable us to make a significant impact on students and impress upon them the need for math and science in their future careers.

One project we undertook this year is giving an extreme makeover to the Who Wants to Be a Mathematician contest! With Maplesoft as a “Technology Sponsor”, the contest that was administered on pen-and-paper moved to a digital format. We donated our testing and assessment tool, Maple T.A. to administer the tests online, making the software accessible to every student that participated. This meant the students took an online test, and were automatically and instantly graded using Maple T.A.

The 2013 competition is underway, and the results are extremely positive:

  • The number of students that participated in the contest doubled this year, with over 2000 students from over 150 schools participating.
  • The competition introduced a second level of tests, making the competition more rigorous. After the first elimination round, eligible contestants moved to a second round with questions of increased difficulty levels.
  • By avoiding much of the paper work and manual corrections, the organizers saw significant savings in time and money.

Custom test questions were created in Maple T.A., which were accessed by students from a server hosted by Maplesoft. The simple and easy to use interface of Maple T.A. enabled the students to take the test without spending time learning the tool. Maple T.A. supports the use of standard mathematical notation in both the question text and student responses. Maple T.A. also allows free-response questions, including questions that have more than one correct answer.

Who Wants to Be a Mathematician is a math contest for high school students, organized by the American Mathematical Society (AMS), as part of its Public Awareness Program. Ten students will be chosen for the semifinals and two will qualify for the finals to be held at the Joint Math Meetings in January 2014.

More information about the contest that is currently in progress can be found on the AMS website

 

Just came across this

Press esc twice then enter.  Maple becomes unresponsive. 

 

 

I made a small change to the Task Filtering code I uploaded a few weeks ago.  The new code has better memory performance and, most importantly has more stable memory usage which means it can actually run very large examples.  Here is the new version of the code:

FilterCombPara := module( )
    local ModuleApply,
            doSplit,
            splitCombs,
            makeNewPrefix,
            lessThanX,
            filterCombs;

    lessThanX := proc( x, i ) x<=i; end;

    doSplit := proc( i::integer, prefix::set(posint), rest::set(posint),
                                                k::posint, filter::appliable, $ )
        splitCombs( prefix union {i}, remove( lessThanX, rest, i ), k-1, filter );
    end;

    splitCombs := proc( prefix::set(posint), rest::set(posint), k::posint,
                                                                filter::appliable, $ )
        if ( numelems( rest ) < k ) then
            NULL;
        elif ( k = 1 ) then
            filterCombs( prefix, rest, filter );
        else
            op( Threads:-Map( doSplit, rest, prefix, rest, k, filter ) );
        end;
    end;

    makeNewPrefix := proc( i, prefix ) { i, op( prefix ) } end;
    filterCombs := proc( prefix::set(posint), rest::set(posint), filter::appliable, $ )
        local i, f;

        op(select( filter, map( makeNewPrefix, rest, prefix ) )):
    end;

    ModuleApply := proc( n::posint, k::posint, filter::appliable, $ )
        [ splitCombs( {}, {seq( i,i=1..n )}, k, filter ) ];
    end;

end:

This code has the small mapping functions as module members instead of declared inline.  This means that less memory is churned as this code is excuted.  For a long runs, this helps keeps the memory stable.

As an example, I ran the following example:

> CodeTools:-Usage( FilterCombPara( 113,7, x->false ) );
memory used=17.39TiB, alloc change=460.02MiB, cpu time=88.52h, real time=20.15h
                                                  []

It used 88 CPU hours to run, but only 20 hours of real time (go parallelism!)  It used 17 Terabytes of memory, but only allocated 500 M.  This example is pretty trival, as the filter returned false for all combinations, so it did not collect any matches during the run.  However as long as the number of matches is small, that shouldn't be an issue.  If the number of matches is too large to fit in memory, then this code may need to be modified to write the matches out to disk instead of trying to hold them all in memory at once.

Darin

-- Kernel Developer Maplesoft

FilterComb.mw

Good morning to all our Mapleprimes members.

 

It is very helpful to many persons who are very passion and dedicated to teach Mathematics using Maple technology if the software package is loaded with updated maple procedures of all the topics.

I am being of them, request the technical authorities and the eminant professors to support and develop this requirement.It becomes an open door to many people to enter and aquire the immence knowledge in Maple.

 

 

With thanks & Regards

 

M.Anand

Assistant Professor in Mathematics

SR International Institute of Technology,

Hyderabad, Andhra Pradesh, INDIA.

First 8 9 10 11 12 13 14 Last Page 10 of 226