Hi

It's been 3+ months since we launched this new, experimental, Maple Physics: Research & Development webpage, containing fixes and new developments around the clock made available to everybody. Today we are extending this experience to Differential Equations and Mathematical functions, launching the Maple Differential Equations and Mathematical Functions: Research & Development Maplesoft webpage. Hey!

With these pages we intend to move the focus of developments directly into the topics people are actually working on. The experience so far has been really good, putting our development at high RPM, an exciting roller-coast of exchange and activity.

As with the Research version of Physics, when suggestions about DEs or Mathematical Functions are implemented or issues are fixed, typically within a couple of days when that is possible, the changes will be made available to everybody directly in this new Maplesoft webpage. One word of clarification: for now, these updates will not include numerical ODE or numerical PDE solutions nor their numerical plotting. Sorry guys. One step at a time :)

This first update today concerns Differential Equations: dsolve and pdsolve can now handle linear systems of equations also when entered in Vector notation (Matrices and Vectors), related to a post in Mapleprimes from October/29. Attached is a demo illustrating the idea.

Everybody is welcome to bring suggestions and post issues. You can do that directly in Mapleprimes or writing to physics@maplesoft.com. While Differential Equations and Mathematical Functions are two areas where the Maple system is currently more mature than in Physics, these two areas cover so many subjects, including that there are the Research and the Education perspectives, that the number of possible topics is immense. 

DEsAndMathematicalFu.pdf   DEsAndMathematicalFu.mw

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

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.

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.

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.

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.

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

Napoleon_Triangle.mw

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 25^th 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