MapleSim 2016 is here!

MapleSim 2016 provides variety of improvements to streamline the user experience, expand modeling scope, and enhance connectivity with other tools. Here are some highlights:

• Collapsible task panes provide a larger model workspace, so you can see more of your model at once.
• Improved layout ensures the tools you need for your current task are available at your fingertips.
• The expanded Multibody component library now supports contact modeling.
• A new add-on library, the MapleSim Pneumatics Library from Modelon, supports the modeling and simulation of pneumatic systems.
• The MapleSim CAD Toolbox has been extended to support the latest versions of Inventor®, NX®, SOLIDWORKS®, CATIA® V5, Solid Edge®, PTC® Creo Parametric™, and more.
• The MapleSim Connector, which provides connectivity to Simulink®, now supports single precision export of S-functions so you can run your MapleSim models on hardware that only supports single precision.

See What’s New in MapleSim 2016 for more information about these and other improvements.

eithne

New color schemes for plotting have been added to Maple 2016. They are summarized here. You can also see more details on the plot/colorscheme help pages, which have been reworked (hopefully in a way that makes them more useful to you).

We released a new video a few weeks ago describing one of these features: coloring by value. The worksheet I used for the video is available here: ColorByValueWebinar.mw

According to Sphere Packing Solved in Higher Dimensions, the best way, i.e., most compact way, to pack spheres in dimensions 8 and 24 are done with the E8 lattice and Leech lattice, respectively. According to the Wikipedia article Leech lattice, the number of spheres that can be packed around any one sphere is 240 and 196,560 (!), respectively, the latter number of spheres counter-intuitively large. It inspired me to try to check that there is indeed room in these lattices for (at least) this number of spheres.

Starting with the E8 lattice: It is generated by the sum (over the integers) of all the 240 roots of E8. Following the prescription given in the subsection 'Construction' in the Wikipedia article E₈ (mathematics), these roots may be constructed as follows:

ROOTS := map(x -> Vector(x),[
   # Coordinates all integers: 112 roots
   combinat[permute]([+1,+1,0,0,0,0,0,0])[],
   combinat[permute]([+1,-1,0,0,0,0,0,0])[],
   combinat[permute]([-1,-1,0,0,0,0,0,0])[],
   # Coordinates all half-integers: 128 roots
   seq(combinat[permute]([
      (+1/2)$(  2*n),   # Even number of +1/2
      (-1/2)$(8-2*n)    # Even number of -1/2
   ])[],n = 0..4)
]):

This Maple code gives a list of 240 eight-dimensional vectors. All these roots have the same length (the lattice thus being simply laced):

convert(map(x -> Norm(x,2),ROOTS),set)[];

If the distance between any pair of different roots is at least this length, then there will be room for 240 spheres of radius equal to this length around any one single sphere. And that is indeed the case:

DIST_ROOTS := Matrix(nops(ROOTS)$2,(i,j) ->
   Norm(ROOTS[i] - ROOTS[j],2)
,shape = symmetric):
min(convert(DIST_ROOTS,set) minus {0});

Using the above method for the Leech lattice will fail on grounds of hopeless performance, not the least because DIST_ROOTS will take ages to calculate, if at all possible. So any reader is welcome to weigh in with ideas on how to check the Leech lattice case.

PS: By the way, I was surprised to find that the three exceptional Lie algebras E6, E7, and E8 are seemingly not accessible through the Maple command SimpleLieAlgebraData, see its help page. Only the four infinite families A,B,C,D, as well as the two exceptional Lie algebras G2 and F4 are. Using Maple 17, I would like to know if that has been changed in Maple 17+, and if not, why not.

In a recent post, the following inequality was proved with Maple:

(a,b,c,d >= 0).

Here is another direct proof attempt.

f:=(a+b+c+d)^2*(a*b+a*c+a*d+b*c+b*d+c*d)^2-144*(a^2+b^2+c^2+d^2)*a*b*c*d:
g:=expand(eval(f,d=1)):
s:=minimize(g, [a=0..infinity,b=0..infinity,c=0..infinity]):
length(s);   # huge
        304856
map(evalf@evalf[500],s);

map(evalf@evalf[1000],s);

So, Maple returns the expression

min(0,r1,r2,r3)

where r1,r2,r3 are huge expressions containing RootOfs. In order to evaluate them, several hundreds of digits are needed.
The solution seems to be correct, but the question is: may we (mathematically) accept it? What do you think?

I’m pleased to announce the release of Maple T.A. 2016, our online assessment system.

For this release, we put a lot of effort into streamlining the authoring experience. We worked closely with customers to find out how they authored content, the places where they found the interface awkward, the tasks that took longer than they should have, and what they’d like to see changed. Then we made it better.

Right away you’ll notice that questions and assignments are no longer in separate places in Maple T.A. All your content is stored in a convenient location that makes it simple to browse your content. Contextual navigation, filtering options, sorting tools, question details, drag and drop organization, combined import feature, and more make it easier than ever to find and organize your content. The Maple T.A. Cloud also sees improvements. Not only can questions be shared, but assignments and entire course modules can be as well.

For question creation, we consolidated all question authoring into the question designer, so you have a single starting point no matter what kind of question you want to create. We have also refined the text editor to help authors find the tools they need to modify their questions. This includes embedding external content, importing questions from the repository, text formatting options, and more.

Of course, once you have questions, you’ll want to put them into an assignment, and assignment creation is now easier than ever. A key change is that you can now create and modify questions while you are creating an assignment, without having to leave the assignment editor. There are also changes to how you preview questions, set properties, and even save your assignments, all of which contribute to making assignment creation simpler and faster.

Of course, there’s more than just a significantly improved author workflow. Here are some highlights:

• Assignment groups for efficient organization, both in the content repository and on the class homepage.
• Easy-to-create sorting questions – no coding required!
• HTML questions, which can be authored directly in the question designer.
• Clickable image questions are Java-free and easier to author.
• Maximum word counts and other improvements to the essay question type.
• A new scanned document feature lets instructors upload and even grade scanned documents.
• Officially certified LTI integration for connectivity with a wide range of course management systems

See What’s New in Maple T.A. 2016 for more information on these and other new features.

Jonny Zivku
Maplesoft Product Manager, Online Education Products

 inequality.mw

A wealth of knowledge is on display in MaplePrimes as our contributors share their expertise and step up to answer others’ queries. This post picks out one such response and further elucidates the answers to the posted question. I hope these explanations appeal to those of our readers who might not be familiar with the techniques embedded in the original responses.

The Question: Transforming functions to names

Bendesarts wanted to know how to make programmatic changes to characters in a list. He wrote:

I have this list :

T:=[alpha(t),beta(t)]

I would like to create this list automatically:

Tmod:=[alpha_,beta_]

In other words, how can I remove the 3 characters "(t)" and replace it by "_"

Do you have ideas to do so ?

Thanks a lot for your help

Joe Riel provided a complete answer that had three different approaches. He wrote:

Map, over the list, a procedure that extracts the name of the function and catenates an underscore to it. The function name is extracted via the op procedure, e.g. op(0,f(a,b,c)) evaluates to f. Thus 

map(f->cat(op(0,f),_),T);

Note that this fails if the name of a function is indexed, e.g. f[2](a). No error is generated but the catenation doesn't evaluate to a symbol. Presumably that isn't an issue here.  One way to handle that case is to first convert the indexed name to a symbol, then catenate the underscore.  So a more robust version is

map(f->cat(convert(op(0,f),'symbol'),_),T);

However, if you are actually dealing with indexed names you might want a different result. Another way to do the conversion, and combine it with the catenation, is to use nprintf, which generates a name (symbol). Thus

map(f -> nprintf("%a_", op(0,f)),T);

Let’s discuss each approach by understanding the definitions and functionalities of the commands used. 

The map command, map(fcn, expr, arg1, ..., argN) applies a procedure or name, fcn, to the operands or elements of an expression, expr. The result of a call to map is a copy of expr with the ith operand of expr replaced by the result of applying fcn to the ith operand.  This concept is easier to grasp by looking at a few examples related to the usage of map in this question.

Example 1.  map(x-> x²,x+y)         returns     x²+y²                    

Example 2. map(a -> a-b, sin(x))    returns     sin(x-b)

The cat function, cat(a,b,c,…), is commonly used to concatenate (or join) string and names together. This function’s parameters: a,b,c…, can be any expressions.

Example 1. cat(a,2)                      returns     a2

Example 2.  cat(“a”,3,sin(x))          returns    “a3sin(x)”

The op function, op(i..j,e), extracts operands from an expression. The parameters i and j are the integers indicating positions of the operands and e is the expression. For functions, as in this example, op(0,e) is the name of the function.

Example 1.  op(0,alpha(t))            returns   the symbol alpha

Example 2.  op(0, sin(x))              returns    sin

Now analyzing Joe Riel's code will be easier.

1. map(f->cat(op(0,f),_),T);

In this approach Joe is extracting the name of the functions, alpha and beta, and then concatenating it to the underscore symbol. Then using the mapping function he applies the previous procedure to the list T.

1. map(f->cat(convert(op(0,f),'symbol'),_),T);

This approach is a lot similar to the previous one, but he added the convert function in case the function inside of map was indexed. Convert(expr, form, arg3,..), is used to change an expression from one form to another. In this example op(0,f) has been changed from type name to type symbol.

1. map(f -> nprintf("%a_", op(0,f)),T);

Again this is a similar approach but it uses nprintf. This command, nprintf(fmt,x1,..xn), is based on a C standard library command of the same name. It uses the format specifications in the fmt string to format and writes the expression into a Maple symbol, which is returned. In this example the format specified is the algebraic format “%a”.

This blog was written by Maplesoft’s intern Pia under the supervision of Dr. Robert Lopez. We both hope that you find this useful. If there is a particular question on MaplePrimes that you would like further explained, please let us know. 

The mechanism of transport of the material of the sewing machine M 1022 class: mathematical animation.   BELORUS.mw 

 PS. I see my proof needs an additional explanation. The DirectSearch command establishes the only both local and global  maximum of F is located at z= -1.98*10^(-13) up to default error 10^(-9). After that  the series command confirms a local maximum at z=0. Combining these, one draws the conclusion that the global maximum is placed exactly at z=0 and equals 2. In order to confirm that the only real root of F=2 at z=0  is found approximately and exactly by the DirectSearch.

Download maxi.mw

I thought I would share some code for computing sparse matrix products in Maple.  For floating point matrices this is done quickly, but for algebraic datatypes there is a performance problem with the builtin routines, as noted in http://www.mapleprimes.com/questions/205739-How-Do-I-Improve-The-Performance-Of

Download spm.txt

The code is fairly straightforward in that it uses op(1,A) to extract the dimensions and op(2,A) to extract the non-zero elements of a Matrix or Vector, and then loops over those elements.  I included a sparse map function for cases where you want to map a function (like expand) over non-zero elements only.

# sparse matrix vector product
spmv := proc(A::Matrix,V::Vector)
local m,n,Ae,Ve,Vi,R,e;
  n, m := op(1,A);
  if op(1,V) <> m then error "incompatible dimensions"; end if;
  Ae := op(2,A);
  Ve := op(2,V);
  Vi := map2(op,1,Ve);
  R := Vector(n, storage=sparse);
  for e in Ae do
    n, m := op(1,e);
    if member(m, Vi) then R[n] := R[n] + A[n,m]*V[m]; end if;
  end do;
  return R;
end proc:

# sparse matrix product
spmm := proc(A::Matrix, B::Matrix)
local m,n,Ae,Be,Bi,R,l,e,i;
  n, m := op(1,A);
  i, l := op(1,B);
  if i <> m then error "incompatible dimensions"; end if;
  Ae := op(2,A);
  Be := op(2,B);
  R := Matrix(n,l,storage=sparse);
  for i from 1 to l do
    Bi, Be := selectremove(type, Be, (anything,i)=anything);
    Bi := map2(op,[1,1],Bi);
    for e in Ae do
      n, m := op(1,e);
      if member(m, Bi) then R[n,i] := R[n,i] + A[n,m]*B[m,i]; end if;
    end do;
  end do;
  return R;
end proc:

# sparse map
smap := proc(f, A::{Matrix,Vector})
local B, Ae, e;
  if A::Vector then
    B := Vector(op(1,A),storage=sparse):
  else
    B := Matrix(op(1,A),storage=sparse):
  end if;
  Ae := op(2,A);
  for e in Ae do
    B[op(1,e)] := f(op(2,e),args[3..nargs]);
  end do;
  return B;
end proc:

As for how it performs, here is a demo inspired by the original post.

n := 674;
k := 6;

A := Matrix(n,n,storage=sparse):
for i to n do
  for j to k do
    A[i,irem(rand(),n)+1] := randpoly(x):
  end do:
end do:

V := Vector(n):
for i to k do
  V[irem(rand(),n)+1] := randpoly(x):
end do:

C := CodeTools:-Usage( spmv(A,V) ):  # 7ms, 25x faster
CodeTools:-Usage( A.V ):  # 174 ms

B := Matrix(n,n,storage=sparse):
for i to n do
  for j to k do
    B[i,irem(rand(),n)+1] := randpoly(x):
  end do:
end do:

C := CodeTools:-Usage( spmm(A,B) ):  # 2.74 sec, 50x faster
CodeTools:-Usage( A.B ):  # 2.44 min

# expand and collect like terms
C := CodeTools:-Usage( smap(expand, C) ):

CameraProfiler.mw

D700_Profile.xlsx

This Application uses the xrite color checker to obtain Forward and Color Matrices as defined by Adobe.

It compares the camera gamut based on the above matrices to the 1931 Standard Observer using LEDs.

  Continuation.
  One way to get rolling without slipping animation in 3d. The trajectory and circle are divided into segments of equal length. In the next segment of the trajectory we construct circle, taking into account the fact that it turned on one segment. Rolling sphere or cylinder can be simulated, if we take plottools templates of the same radius, and replace them on the site of our circle.

ROLLING_WITHOUT_3d.mw

Maple is a scientific software based on Computational Algebraic System (SAC) which has enabled this work entirely solve applied to Civil Engineering, Mechanical and Mecatrónica.The present problems in education, research and engineering are developed with static work sheets ie coding used innecesaria.Maple proposed models are shown below with an innovative structure; with the method of graphics algorithms and embedded components; putting aside the traditional and obsolete syntax; using dynamic worksheets as viable and optimal solutions to interpret and explain problems Ingineering.Design Advanced Analysis Tools (Applied Mathematics) Sophisticated Applications (efficient algorithms) and Multiple deployment options (different styles); this allowed generate math apps (applications engineering); can be interactive on the internet without the need to have the software installed on our computer; This way our projects can be used with a vision of sustainability around the world. Resulting in the generation of data and curves; which in turn will help you make better decisions analytical and predictive modeling in manufacturing and 3D objects; which would lead to new patterns of contrasting solutions.

ECI_2016.pdf

ECI_2016v_full.mw

Lenin Araujo Castillo

Ambassador of Maple - Perú

A wealth of knowledge is on display in MaplePrimes as our contributors share their expertise and step up to answer others’ queries. This post picks out one such response and further elucidates the answers to the posted question. I hope these explanations appeal to those of our readers who might not be familiar with the techniques embedded in the original responses.

The Question: How to sketch a line in space?

vahid65 wanted to know how to sketch the line with equation (x-2)/3 = (y-1)/4 = (z-3)/3 in a three-dimensional space.

This question was answered using two different approaches that we will discuss.

The first approach, given by Preben Alsholm, suggested using these commands: solve, subs, and plots:-spacecurve.

Preben provided the following lines of code:

1. {(x-2)/3 , (y-1)/4 , (z-3)/3} =~t;
2. solve(%,{x,y,z});
3. L:=subs(%,[x,y,z]);
4. plots:-spacecurve(L,t=-5..5,thickness=3,color=red);

The first line sets the three expressions equal to t using the element wise operator =~.  This distributes the operation of equality over the elements of the set of expressions, forming a set of equations.

Result-1: {(x-2)/3=t, (y-1)/4=t, (z-3)/3=t}

The second line invokes the solve command. The solve command, solve(equations, variables), solves one or more equations or inequalities for their unknowns. So in this line, this command was used to solve each expression for its corresponding unknown.

Result-2: {(x= 2+3t, y=1+4t, z= 3+3t}

You may have noticed that the % symbol is used within the command. This symbol is referring to the equation label that was created chronologically last. 

The third line uses the subs command. The subs command, subs(x=a,expr), substitutes “a” for “x” in the expression expr. In this case, “a” is the reference to the equation label referenced by (%) and expr is the sequence of variables x,y,z. The square brackets around expr forms a list, and the replacement imposed by the subs command replaces each of the three names x, y, and z with their equivalents in the set of equations returned by the solve command.

Result-3: [2+3t,1+4t, 3+3t ]

Finally the last line uses the plots:-spacecurve function.  This function, spacecurve(sc,r,opts),  graphs a parametrically defined curve in three-dimensional Cartesian space. 

In this example the first parameter, sc, is replaced by L since L has the properties of a list. The parameter  r is an equation containing the parameter name and the parameter range; here it is the equation t=-5..5. Last but not least, the opts parameter (which is optional) gives the user the opportunity to specify the optional properties of the graph, properties such as thickness and color of the space curve. 

Result 4: 

Another contributer, Carl Love, suggested that these commands could be combined using the zip function, zip( f, u, v), which is an unusual application of it. The zip command applies elementwise to corresponding members of the two lists u and v, the binary function f, creating a new list r, whose members are f(u_k,v_k).

Carl provided the following code:

plots:-spacecurve(  zip(solve, [(x-2)/3 , (y-1)/4 , (z-3)/3] =~ t, [x,y,z]),  t= -5..5, thickness= 3, color= red, axes= normal);

In this case zip is applying solve to u, a list of equations, and v, a list of variables. The equations in u are those in Result-1. The zip function returns the solution of each equation for the indicated variable, that is, the new list r is the list in Result-3. This list is the first argument of plots:-spacecurve. Finally, the parameter range and opts are up to the user’s preferences.

A second approach was suggested by Kitonum. The difference between this approach and the first one is that here we are not using the solve command. Instead, we are treating the line as an intersection of two planes.

Kitonum's code is as follows:

1. L := [(x-2)*(1/3), (y-1)*(1/4), (z-3)*(1/3)]:
2. plots[intersectplot](L[1]-L[2], L[2]-L[3], x = -4 .. 4, y = -4 .. 4, z = -4 .. 4, linestyle = 1, thickness = 3, axes = normal, orientation = [60, 75], view = [-1 .. 3, -4 .. 2, -1 .. 4]);

The first statement initializes a list L that contains all the desired expressions in the given symmetric form of the line.

In the second statement Kionum used the plots[intersectplot] command. This command graphs, in three-dimensional Cartesian space, the intersection of a pair of surfaces. This example uses the calling sequence: intersectplot(expr1, expr2, x=a..b, y=c..d, z= e..f, options). 

What are expr1 and expr2 used in Kitonum’s solution? The pairwise differences of L[1] and L[2], and L[2] and L[3] are planes, the intersection of which is the desired line in space.

expr1 = L[1] – L[2] = (x-2)*(1/3)- (y-1)*(1/4)

expr2= L[2] - L[3] = (y-1)*(1/4)-(z-3)*(1/3)

The variables x,y, and z are the coordinate names and define the axes, whereas a, b, c, d, e, f define the ranges. In this case they were taken as -4 or 4.

In the options parameter Kitonum used linestyle, thickness, axes, orientation, and  view. The help page “plot3d,option” details these and other options that apply.

This blog was written by our intern Pia under the supervision of Dr. Robert Lopez. We both hope that you find this useful. If there is a particular question on MaplePrimes that you would like further explained, please let us know. 

eulermac(1/(n*ln(n)^2),n=2..N,1);  #Error
Error, (in SumTools:-DefiniteSum:-ClosedForm) summand is singular in the interval of summation


eulermac(1/(n*ln(n)^2+1),n=2..N,1);  #nonsense