Product Tips & Techniques

Tips and Tricks on how to get the most about Maple and MapleSim

We’ve been working hard on Maple Learn since its release, and we wanted to share some of the many updates we’ve made. If there was a feature you were looking for that we didn’t have, it might be time to check again! Here’s just a taste of some of the things we’ve been working on.

Given its name, perhaps it’s not surprising that our focus with Maple Learn is to help students learn math. That’s why we’ve improved many of Maple Learn’s math capabilities, to give students the best experience we can. We’ve added support for piecewise functions and vector norms/magnitudes, and made many improvements to tables based on user feedback. Are you more of a statistician? Well, you’re in luck, because we’ve also added various statistics options to the Context Panel, which allow you to calculate mean, median, linear regression, and more. We’ve also made a handful of improvements to evaluation and assignment that we hope will make Maple Learn more intuitive for users.

Maple Learn isn’t just about math, though—it’s about making math accessible. That means communicating clearly, so luckily, we’ve added several new text editing features to help you do just that. You can now use bold, italics, underline, hyperlinks, and changeable font sizes and colours. You can even collapse the plot window and Context Panel if you need a larger workspace or if your problem doesn’t require them. Now your documents will be both easy to follow and stylish!

Speaking of stylish documents, we’ve also made various improvements to how functions can be visualized. There are a couple I’d like to point out to you: You can plot points by adding values to a table! What’s more, you can then move these points around the plot and your table will update automatically. You can also add points and other geometric plot primitives like line segments and vectors using the commands Point, Segment, and Vector. As well, if you have multiple functions plotted, you can see the intersection points by clicking the “Show special points” button. If points aren’t your style, we’ve also added support for some more types of plots, such as parametric plots. When working with differential equations, you can also plot the vector field for that equation. To learn how to use these features and more, check out the “How To” section at the bottom of our Example Gallery. We’re working on more help documentation everyday to help you use Maple Learn to its full potential.

Finally, we’ve made a handful of miscellaneous changes that should help improve your overall experience with Maple Learn. For example, users can now save a copy of their document. We’ve also translated many of our examples to different languages, and are working on translating more everyday. We hope that all these changes and updates will help you get the most out of Maple Learn. If there are features you’d like to see, don’t hesitate to let us know. We add improvements to Maple Learn regularly, so keep an eye out for future updates on Primes!

We have just released an update to Maple, Maple 2021.1.

Maple 2021.1 includes improvements to plotting, export to PDF and LaTeX, the user interface, the mathematics engine, and more. We strongly recommend that all Maple 2021 users install these updates.

This update is available through Tools>Check for Updates in Maple, and is also available from our website on the Maple 2021.1 download page, where you can also find more details.

In particular, please note that this update includes fixes to the sometimes missing plotting toolbar, the misplaced plot annotations on export, and a workbook saving problem, all reported on MaplePrimes.

Thanks for the feedback!

 

We’re excited to announce the release of MapleSim 2021! The MapleSim 2021 family of products lets you build and explore models more easily than ever, with improved simulation performance and 3-D visualizations, new ways to share models with those who don’t use MapleSim, and a host of new and expanded component libraries. Improvements include:

  • Improved performance for large models that allows you to take advantage of the fastest simulations yet – no matter how complex your design is.
  • More realistic 3-D visualizations with the ability to define dynamic shape sizes, such as spheres and cylinders that expand or contract over the course of the simulation, so components are realistically represented throughout.
  • Expanded modeling scope for machine builders, with a new pneumatics component library and expanded hydraulics support, as well as improved visualizations in the MapleSim Ropes and Pulleys Library add-on.
  • New simulation and analysis features in MapleSim Insight, a standalone product in the MapleSim family that provides anyone in your organization with access to powerful simulation-based debugging and 3-D visualization capabilities that connect directly to common automation platforms.

See What’s New in MapleSim 2021 for more information about these and other improvements!
 

When we first launched Maple Learn in January, there were only a handful of examples in the Example Gallery. Today, due to customer requests, we have 57 examples and the number grows every week. You can check out the gallery here: https://www.maplesoft.com/products/learn/examples/

The gallery is full of both practical and fun examples showing how you can use Maple Learn to work with all kinds of math. One great example is this worksheet on Logarithmic and Archimedean spirals made by our Sales Account Manager, @Oliver K. You can learn a bit about each type of spiral and adjust the sliders to see how the different parameters change the visualization. It’s a great tool for introducing students (or anyone who likes cool graphs!) to these types of spirals and for helping them understand the math behind them.

We’ve got a whole team of people, led by Senior Architect @pchin, who are working every day to make more examples like these. If there’s something you’d like to see, leave us a comment! We’d love to hear your ideas.

If you’re feeling inspired by all these examples and want to try your hand at creating something of your own using Maple Learn, check out the “How to Use Maple Learn” section at the end of the example gallery. Here you’ll find a collection of worksheets that will take you through the basic features of Learn, including “Using Sliders”, “Difference Between Equations and Assignments”, and “What Does the Light Bulb Do?”. With all this knowledge at your fingertips, you’ll be all set to create to your heart’s content!

Yesterday, user @lcz , while responding as a third party to one of my Answers regarding GraphTheory, asked about breadth-first search. So, I decided to write a more-interesting example of it than the relatively simple example that was used in that Answer. I think that this is general enough to be worthy of a Post.

This application generates all maximal paths in a graph that begin with a given vertex. (I'm calling a path maximal if it cannot be extended and remain a path.) This code requires Maple 2019 or later and 1D input. This works for both directed and undirected graphs. Weights, if present. are ignored.

restart:

AllMaximalPaths:= proc(G::GRAPHLN, v)
description 
    "All maximal paths of G starting at v by breadth-first search"
;
option `Author: Carl Love <carl.j.love@gmail.com> 2021-Mar-17`;
uses GT= GraphTheory;
local 
    P:= [rtable([v])], R:= rtable(1..0),
    VL:= GT:-Vertices(G), V:= table(VL=~ [$1..nops(VL)]),
    Departures:= {op}~(GT:-Departures(G))
;
    while nops(P) <> 0 do
        P:= [
            for local p in P do
                local New:= Departures[V[p[-1]]] minus {seq}(p);
                if New={} then R,= [seq](p); next fi;                
                (
                    for local u in New do 
                        local p1:= rtable(p); p1,= u
                    od
                )       
            od
        ]
    od;
    {seq}(R)  
end proc
:
#large example:
GT:= GraphTheory:
K9:= GT:-CompleteGraph(9):
Pa:= CodeTools:-Usage(AllMaximalPaths(K9,1)):
memory used=212.56MiB, alloc change=32.00MiB, 
cpu time=937.00ms, real time=804.00ms, gc time=312.50ms

nops(Pa);
                             40320
#fun example:
P:= GT:-SpecialGraphs:-PetersenGraph():
Pa:= CodeTools:-Usage(AllMaximalPaths(P,1)):
memory used=0.52MiB, alloc change=0 bytes, 
cpu time=0ns, real time=3.00ms, gc time=0ns

nops(Pa);
                               72

Pa[..9]; #sample paths
    {[1, 2, 3, 4, 10, 9, 8, 5], [1, 2, 3, 7, 8, 9, 10, 6], 
      [1, 2, 9, 8, 7, 3, 4, 5], [1, 2, 9, 10, 4, 3, 7, 6], 
      [1, 5, 4, 3, 7, 8, 9, 2], [1, 5, 4, 10, 9, 8, 7, 6], 
      [1, 5, 8, 7, 3, 4, 10, 6], [1, 5, 8, 9, 10, 4, 3, 2], 
      [1, 6, 7, 3, 4, 10, 9, 2]}

Notes on the procedure:

The two dynamic data structures are

  • P: a list of vectors of vertices. Each vector contains a path which we'll attempt to extend.
  • R: a vector of lists of vertices. Each list is a maximal path to be returned.

The static data structures are

  • V: a table mapping vertices (which may be named) to their index numbers.
  • Departures: a list of sets of vertices whose kth set is the possible next vertices from vertex number k.

On each iteration of the outer loop, P is completely reconstructed because each of its entries, a path p, is either determined to be maximal or it's extended. The set New is the vertices that can be appended to the (connected to vertex p[-1]). If New is empty, then p is maximal, and it gets moved to R


The following code constructs an array plot of all the maximal paths in the Petersen graph. I can't post the array plot, but you can see it in the attached worksheet: BreadthFirst.mw

#Do an array plot of each path embedded in the graph:
n:= nops(Pa):
c:= 9: 
plots:-display(
    (PA:= rtable(
        (1..ceil(n/c), 1..c),
        (i,j)-> 
            if (local k:= (i-1)*ceil(n/c) + j) > n then 
                plot(axes= none)
            else 
                GT:-DrawGraph(
                    GT:-HighlightTrail(P, Pa[k], inplace= false), 
                    stylesheet= "legacy", title= typeset(Pa[k])
                )
            fi
    )),
    titlefont= [Times, Bold, 12]
);

#And recast that as an animation so that I can post it:
plots:-display(
    [seq](`$`~(plots:-display~(PA), 5)),
    insequence
); 

 

Wirtinger Derivatives in Maple 2021

Generally speaking, there are two contexts for differentiating complex functions with respect to complex variables. In the first context, called the classical complex analysis, the derivatives of the complex components ( abs , argument , conjugate , Im , Re , signum ) with respect to complex variables do not exist (do not satisfy the Cauchy-Riemann conditions), with the exception of when they are holomorphic functions. All computer algebra systems implement the complex components in this context, and computationally represent all of abs(z), argument(z), conjugate(z), Im(z), Re(z), signum(z) as functions of z . Then, viewed as functions of z, none of them are analytic, so differentiability becomes an issue.

 

In the second context, first introduced by Poincare (also called Wirtinger calculus), in brief z and its conjugate conjugate(z) are taken as independent variables, and all the six derivatives of the complex components become computable, also with respect to conjugate(z). Technically speaking, Wirtinger calculus permits extending complex differentiation to non-holomorphic functions provided that they are ℝ-differentiable (i.e. differentiable functions of real and imaginary parts, taking f(z) = f(x, y) as a mapping "`&Ropf;`^(2)->`&Ropf;`^()").

 

In simpler terms, this subject is relevant because, in mathematical-physics formulations using paper and pencil, we frequently use Wirtinger calculus automatically. We take z and its conjugate conjugate(z) as independent variables, with that d*conjugate(z)*(1/(d*z)) = 0, d*z*(1/(d*conjugate(z))) = 0, and we compute with the operators "(&PartialD;)/(&PartialD; z)", "(&PartialD;)/(&PartialD; (z))" as partial differential operators that behave as ordinary derivatives. With that, all of abs(z), argument(z), conjugate(z), Im(z), Re(z), signum(z), become differentiable, since they are all expressible as functions of z and conjugate(z).

 

 

Wirtinger derivatives were implemented in Maple 18 , years ago, in the context of the Physics package. There is a setting, Physics:-Setup(wirtingerderivatives), that when set to true - an that is the default value when Physics is loaded - redefines the differentiation rules turning on Wirtinger calculus. The implementation, however, was incomplete, and the subject escaped through the cracks till recently mentioned in this Mapleprimes post.

 

Long intro. This post is to present the completion of Wirtinger calculus in Maple, distributed for everybody using Maple 2021 within the Maplesoft Physics Updates v.929 or newer. Load Physics and set the imaginary unit to be represented by I

 

with(Physics); interface(imaginaryunit = I)

 

The complex components are represented by the computer algebra functions

(FunctionAdvisor(complex_components))(z)

[Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)]

(1)

They can all be expressed in terms of z and conjugate(z)

map(proc (u) options operator, arrow; u = convert(u, conjugate) end proc, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)])

[Im(z) = ((1/2)*I)*(-z+conjugate(z)), Re(z) = (1/2)*z+(1/2)*conjugate(z), abs(z) = (z*conjugate(z))^(1/2), argument(z) = -I*ln(z/(z*conjugate(z))^(1/2)), conjugate(z) = conjugate(z), signum(z) = z/(z*conjugate(z))^(1/2)]

(2)

The main differentiation rules in the context of Wirtinger derivatives, that is, taking z and conjugate(z) as independent variables, are

map(%diff = diff, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)], z)

[%diff(Im(z), z) = -(1/2)*I, %diff(Re(z), z) = 1/2, %diff(abs(z), z) = (1/2)*conjugate(z)/abs(z), %diff(argument(z), z) = -((1/2)*I)/z, %diff(conjugate(z), z) = 0, %diff(signum(z), z) = (1/2)/abs(z)]

(3)

Since in this context conjugate(z) is taken as - say - a mathematically-atomic variable (the computational representation is still the function conjugate(z)) we can differentiate all the complex components also with respect to  conjugate(z)

map(%diff = diff, [Im(z), Re(z), abs(z), argument(z), conjugate(z), signum(z)], conjugate(z))

[%diff(Im(z), conjugate(z)) = (1/2)*I, %diff(Re(z), conjugate(z)) = 1/2, %diff(abs(z), conjugate(z)) = (1/2)*z/abs(z), %diff(argument(z), conjugate(z)) = ((1/2)*I)*z/abs(z)^2, %diff(conjugate(z), conjugate(z)) = 1, %diff(signum(z), conjugate(z)) = -(1/2)*z^2/abs(z)^3]

(4)

For example, consider the following algebraic expression, starting with conjugate

eq__1 := conjugate(z)+z*conjugate(z)^2

conjugate(z)+z*conjugate(z)^2

(5)

Differentiating this expression with respect to z and conjugate(z) taking them as independent variables, is new, and in this example trivial

(%diff = diff)(eq__1, z)

%diff(conjugate(z)+z*conjugate(z)^2, z) = conjugate(z)^2

(6)

(%diff = diff)(eq__1, conjugate(z))

%diff(conjugate(z)+z*conjugate(z)^2, conjugate(z)) = 1+2*z*conjugate(z)

(7)

Switch to something less trivial, replace conjugate by the real part ReNULL

eq__2 := eval(eq__1, conjugate = Re)

Re(z)+z*Re(z)^2

(8)

To verify results further below, also express eq__2 in terms of conjugate

eq__22 := simplify(convert(eq__2, conjugate), size)

(1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z))

(9)

New: differentiate eq__2 with respect to z and  conjugate(z)

(%diff = diff)(eq__2, z)

%diff(Re(z)+z*Re(z)^2, z) = 1/2+Re(z)^2+z*Re(z)

(10)

(%diff = diff)(eq__2, conjugate(z))

%diff(Re(z)+z*Re(z)^2, conjugate(z)) = 1/2+z*Re(z)

(11)

Note these results (10) and (11) are expressed in terms of Re(z), not conjugate(z). Let's compare with the derivative of eq__22 where everything is expressed in terms of z and conjugate(z). Take for instance the derivative with respect to z

(%diff = diff)(eq__22, z)

%diff((1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z)), z) = (1/4)*(2*z+conjugate(z))*(z+conjugate(z))+(1/4)*z^2+(1/4)*z*conjugate(z)+1/2

(12)

To verify this result is mathematically equal to (10) expressed in terms of Re(z) take the difference of the right-hand sides

rhs((%diff(Re(z)+z*Re(z)^2, z) = 1/2+Re(z)^2+z*Re(z))-(%diff((1/4)*(z^2+z*conjugate(z)+2)*(z+conjugate(z)), z) = (1/4)*(2*z+conjugate(z))*(z+conjugate(z))+(1/4)*z^2+(1/4)*z*conjugate(z)+1/2)) = 0

Re(z)^2+z*Re(z)-(1/4)*(2*z+conjugate(z))*(z+conjugate(z))-(1/4)*z^2-(1/4)*z*conjugate(z) = 0

(13)

One quick way to verify the value of expressions like this one is to replace z = a+I*b and simplify "assuming" a andNULLb are realNULL

`assuming`([eval(Re(z)^2+z*Re(z)-(1/4)*(2*z+conjugate(z))*(z+conjugate(z))-(1/4)*z^2-(1/4)*z*conjugate(z) = 0, z = a+I*b)], [a::real, b::real])

a^2+(a+I*b)*a-(1/2)*(3*a+I*b)*a-(1/4)*(a+I*b)^2-(1/4)*(a+I*b)*(a-I*b) = 0

(14)

normal(a^2+(a+I*b)*a-(1/2)*(3*a+I*b)*a-(1/4)*(a+I*b)^2-(1/4)*(a+I*b)*(a-I*b) = 0)

0 = 0

(15)

The equivalent differentiation, this time replacing in eq__1 conjugate by abs; construct also the equivalent expression in terms of z and  conjugate(z) for verifying results

eq__3 := eval(eq__1, conjugate = abs)

abs(z)+abs(z)^2*z

(16)

eq__33 := simplify(convert(eq__3, conjugate), size)

(z*conjugate(z))^(1/2)+conjugate(z)*z^2

(17)

Since these two expressions are mathematically equal, their derivatives should be too, and the derivatives of eq__33 can be verified by eye since z and  conjugate(z) are taken as independent variables

(%diff = diff)(eq__3, z)

%diff(abs(z)+abs(z)^2*z, z) = (1/2)*conjugate(z)/abs(z)+z*conjugate(z)+abs(z)^2

(18)

(%diff = diff)(eq__33, z)

%diff((z*conjugate(z))^(1/2)+conjugate(z)*z^2, z) = (1/2)*conjugate(z)/(z*conjugate(z))^(1/2)+2*z*conjugate(z)

(19)

Eq (18) is expressed in terms of abs(z) = abs(z) while (19) is in terms of conjugate(z) = conjugate(z). Comparing as done in (14)

rhs((%diff(abs(z)+abs(z)^2*z, z) = (1/2)*conjugate(z)/abs(z)+z*conjugate(z)+abs(z)^2)-(%diff((z*conjugate(z))^(1/2)+conjugate(z)*z^2, z) = (1/2)*conjugate(z)/(z*conjugate(z))^(1/2)+2*z*conjugate(z))) = 0

(1/2)*conjugate(z)/abs(z)-z*conjugate(z)+abs(z)^2-(1/2)*conjugate(z)/(z*conjugate(z))^(1/2) = 0

(20)

`assuming`([eval((1/2)*conjugate(z)/abs(z)-z*conjugate(z)+abs(z)^2-(1/2)*conjugate(z)/(z*conjugate(z))^(1/2) = 0, z = a+I*b)], [a::real, b::real])

(1/2)*(a-I*b)/(a^2+b^2)^(1/2)-(a+I*b)*(a-I*b)+a^2+b^2-(1/2)*(a-I*b)/((a+I*b)*(a-I*b))^(1/2) = 0

(21)

simplify((1/2)*(a-I*b)/(a^2+b^2)^(1/2)-(a+I*b)*(a-I*b)+a^2+b^2-(1/2)*(a-I*b)/((a+I*b)*(a-I*b))^(1/2) = 0)

0 = 0

(22)

To mention but one not so famliar case, consider the derivative of the sign of a complex number, represented in Maple by signum(z). So our testing expression is

eq__4 := eval(eq__1, conjugate = signum)

signum(z)+z*signum(z)^2

(23)

This expression can also be rewritten in terms of z and  conjugate(z) 

eq__44 := simplify(convert(eq__4, conjugate), size)

z/(z*conjugate(z))^(1/2)+z^2/conjugate(z)

(24)

This time differentiate with respect to conjugate(z),

(%diff = diff)(eq__4, conjugate(z))

%diff(signum(z)+z*signum(z)^2, conjugate(z)) = -(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3

(25)

Here again, the differentiation of eq__44, that is expressed entirely in terms of z and  conjugate(z), can be computed by eye

(%diff = diff)(eq__44, conjugate(z))

%diff(z/(z*conjugate(z))^(1/2)+z^2/conjugate(z), conjugate(z)) = -(1/2)*z^2/(z*conjugate(z))^(3/2)-z^2/conjugate(z)^2

(26)

Eq (25) is expressed in terms of abs(z) = abs(z) while (26) is in terms of conjugate(z) = conjugate(z). Comparing as done in (14),

rhs((%diff(signum(z)+z*signum(z)^2, conjugate(z)) = -(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3)-(%diff(z/(z*conjugate(z))^(1/2)+z^2/conjugate(z), conjugate(z)) = -(1/2)*z^2/(z*conjugate(z))^(3/2)-z^2/conjugate(z)^2)) = 0

-(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3+(1/2)*z^2/(z*conjugate(z))^(3/2)+z^2/conjugate(z)^2 = 0

(27)

`assuming`([eval(-(1/2)*z^2/abs(z)^3-z^3*signum(z)/abs(z)^3+(1/2)*z^2/(z*conjugate(z))^(3/2)+z^2/conjugate(z)^2 = 0, z = a+I*b)], [a::real, b::real])

-(1/2)*(a+I*b)^2/(a^2+b^2)^(3/2)-(a+I*b)^4/(a^2+b^2)^2+(1/2)*(a+I*b)^2/((a+I*b)*(a-I*b))^(3/2)+(a+I*b)^2/(a-I*b)^2 = 0

(28)

simplify(-(1/2)*(a+I*b)^2/(a^2+b^2)^(3/2)-(a+I*b)^4/(a^2+b^2)^2+(1/2)*(a+I*b)^2/((a+I*b)*(a-I*b))^(3/2)+(a+I*b)^2/(a-I*b)^2 = 0)

0 = 0

(29)

NULL


 

Download Wirtinger_Derivatives.mw

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

 

I’ll admit it. There are times when I don't fully understand every mathematical advancement each release of Maple brings. Given the breadth of what Maple does, I guess that isn't surprising.

In development meetings, I make the pretence of keeping up by looking serious, nodding knowingly and occasionally asking to go back to the previous slide “for a minute”. I’ve been doing this since 2008 and no one’s caught on yet.

But I do understand

  • the joy on a user’s (Zoom) face when they finally solve a complex problem with a new version of Maple
  • the smiley emojis that students send us when they understand a tricky math concept with the help of an improved Maple tutor
  • and the wry smile on a developer’s face when they get to work on a project they really want to work on, and the bigger smile when that project gets positive feedback

These are all moments that give me that magic dopamine hit.

The job that Karishma and I have is to make users happy. We don’t have to be top-flight mathematicians, engineers or computer scientists to do that. We just have to know what itch to scratch.

Here’s some things I think might give you that dopamine hit when you get your hands on Maple 2021. You can also explore the new release yourself at What’s New in Maple 2021.

Worksheet mode has been my go-to interface for when I just want to get stuff done. This is mostly because worksheet mode always felt like a more structured environment for developing math when I didn’t have all the steps planned out in advance, and I found that structure helpful. I’d use Document mode when I needed to use the Context Panel for math operations and didn’t want to see the commands, or I needed to create a nice looking document without input carets. And this was fine – each mode has its own strengths and uses – but I what I really wanted was the best of both worlds in a single environment.

This year, we’ve made one change that has let me transition far more of my work into Document mode.

In Document Mode, pressing Enter in a document block (math input) now always moves the cursor to the next math input (in previous releases, the cursor may have moved to the start of the next line of text).

This means you can now quickly update parameters and see the downstream effects with just the Enter key – previously, a key benefit of worksheet mode only.

There’s another small change we’ve made - inserting new math inputs.  In previous releases of Maple, you could only insert new document blocks above the in-focus block using a menu item or a three-key shortcut.

In Maple 2021, if you move the insertion point to the left of a document block (Home position), the cursor is now bold, as illustrated here:

Now, if you press Enter, the in-focus prompt is moved down and a new empty math input is created.

Once you get used to this change, Ctrl+Shift+K seems like a distance memory!

@Scot Gould logged a request that Maple numerically solve a group of differential equations collected together in a vector. And now you can!

Before Maple 2021, this expression was unchanged after evaluation. Now, it is satisfyingly simpler.

We’ve dramatically increased the scope of the signal processing package.             

My favorite addition is the MUSIC function. With some careful tuning, you can generate a pseudo power spectrum at frequencies smaller than one sample.

First generate a noisy data set with three frequencies (two frequencies are closer than one DFT bin).

with(SignalProcessing): 
num_points:= 2^8: 
sample_rate := 100.0:
T := Vector( num_points, k -> 2 * Pi * (k-1) / sample_rate, 'datatype' = 'float[8]' ): 
noisy_signal:=Vector( num_points, k -> 5 * sin( 10.25 * T[k] ) + 3 * sin( 10.40 * T[k] ) - 7 * sin( 20.35 * T[k] )) + LinearAlgebra:-RandomVector(num_points, generator=-10..10):
dataplot(noisy_signal, size = [ 800, 400 ], style = line)

 

Now generate a standard periodogram

Periodogram( noisy_signal, samplerate = sample_rate, size = [800, 400] )

This approach can’t discriminate between the two closely spaced frequencies.

And now the MUSIC pseudo spectrum

MUSIC( noisy_signal, samplerate = sample_rate, dimension = 6, output = plot );

The Maple Quantum Chemistry Toolbox from RDMChem, a separate add-on product to Maple, is a powerful environment for the computation and visualization of the electronic structure of molecules. I don’t pretend to understand most of what it does (more knowing nods are required). But I did get a kick out of its new molecular dictionary. Did you know that caffeine binds to adenosine receptors in the central nervous system (CNS), which inhibits adenosine binding? Want to know more about the antiviral drug remdesivir? Apparently it looks like this:

We put a lot of work into resources for students and educators in this release, including incorporating study guides for Calculus, Precalculus, and Multivariate Calculus, a new student package for ODEs, and the ability to obtain step-by-step solutions to even more problems.  But my favourite thing out of all this work is the new SolvePractice command in the Grading Tools package.  Because it lets you build an application that does this:

I like this for three main reasons:

  1. It lets students practise solving equations in a way that actually helps them figure out what they’ve done wrong, saving them from a spiral of frustration and despair
  2. The same application can be shared via Maple Learn for students to use in that environment if they don’t have Maple
  3. The work we did to create that “new math entry box” can also be used to create other Maple applications with unknown numbers of inputs (see DocumentTools). I’m definitely planning on using this feature in my own applications.

Okay, yes, we know. Up until recently, our LaTeX export has been sadly lacking. It definitely got better last year, but we knew it still wasn’t good enough. This year, it’s good. It’s easy. It works.  And it’s not just me saying this. The feedback we got during the beta period on this feature was overwhelmingly positive.

That’s just the tip of the Maple 2021 iceberg of course. You can find out more at What’s New in Maple 2021.  Enjoy!

 

 

Download FeynmanIntegrals.mw

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

I make a maple worksheet for generating Pythagorean Triples Ternary Tree :

Around 10,000 records in the matrix currently !

You can set your desire size or export the Matrix as text ...

But yet ! I wish to understand from you better techniques If you have some suggestion ?

the mapleprimes Don't load my worksheet for preview so i put a screenshot !

Pythagoras_ternary.mw

Pythagoras_ternary_data.mw

Pythagoras_ternary_maple.mw

 

 

 

This doc is just an example for uploading with my post.

DocumentsAttachmentUsingLinks_in_MaplePrimes_Post.mw

The above doc/worksheet can be clicked and viewed.

Youtube URL is given below. This also can be clicked and viewed. Thanks to Carl Love's suggestion, I modified using the chain link in the editor.

https://youtu.be/0pDa4FWMSQo

 

 

 

 

 

The order in which expressions evaluate in Maple is something that occasionally causes even advanced users to make syntax errors.

I recently saw a single line of Maple code that provided a good example of a command not evaluating in the order the user desired.

The command in question (after calling with(plots):) was

animate(display, [arrow(<cos(t), sin(t)>)], t = 0 .. 2*Pi)

This resulted in the error:

Error, (in plots/arrow) invalid input: plottools:-arrow expects its 3rd argument, pv, to be of type {Vector, list, vector, complexcons, realcons}, but received 0.5000000000e-1*(cos(t)^2+sin(t)^2)^(1/2)
 

This error indicates that the issue in the animation is the arrow command

arrow(<cos(t), sin(t)>)

on its own, the above command would give the same error. However, the animate command takes values of t from 0 to 2*Pi and substitutes them in, so at first glance, you wouldn't expect the same error to occur.

What is happening is that the command 

arrow(<cos(t), sin(t)>)

in the animate expression is evaluating fully, BEFORE the call to animate is happening. This is due to Maple's automatic simplification (since if this expression contained large expressions, or the values were calculated from other function calls, that could be simplified down, you'd want that to happen first to prevent unneeded calculation time at each step).

So the question is how do we stop it evaluating ahead of time since that isn't what we want to happen in this case?

In order to do this we can use uneval quotes (the single quotes on the keyboard - not to be confused with the backticks). 

animate(display, ['arrow'(<cos(t), sin(t)>)], t = 0 .. 2*Pi)

By surrounding the arrow function call in the uneval quotes, the evaluation is delayed by a level, allowing the animate call to happen first so that each value of t is then substituted before the arrow command is called.

Maple_Evaluation_Order_Example.mw

As a continuation of the posts:
https://www.mapleprimes.com/posts/208958-Determination-Of-The-Angles-Of-The-Manipulator
https://www.mapleprimes.com/posts/209255-The-Use-Of-Manipulators-As-Multiaxis
https://www.mapleprimes.com/posts/210003-Manipulator-With-Variable-Length-Of
But this time without Draghilev's method.
Motion along straight lines can replace motion along any spatial path (with any practical precision), which means that solving the inverse problem of the manipulator's kinematics can be reduced to solving the movement along a sequential set of segments. Thus, another general method for solving the manipulator inverse problem is proposed.
An example of a three-link manipulator with 5 degrees of freedom. Its last link, like the first link, geometrically corresponds to the radius of the sphere. We calculate the coordinates of the ends of its links when passing a straight line segment. We do this in a loop for interior points of the segment using the procedure for finding real roots of polynomial systems of equations RootFinding [Isolate]. First, we “remove” two “extra” degrees of freedom by adding two equations to the system. There can be an infinite set of options for additional equations - if only they correspond to the technical capabilities of the device. In this case, two maximally easy conditions were taken: one equation corresponds to the perpendicularity of the last (third) link directly to the segment of the trajectory itself, and the second equation corresponds to the perpendicularity to the vector with coordinates <1,1,1>. As a result, we got four ways to move the manipulator for the same