## Transformation with animation

by:

Transformation and
rotation.

transformation.mw

## Putnam done with Maple

Maple

The William Lowell Putnam Mathematical Competition, often abbreviated to the Putnam Competition, is an annual mathematics competition for undergraduate college students enrolled at institutions of higher learning in the world (regardless of the students' nationalities). One can see some problems and answers here. I find it remarkable that a lot of these problems can be done with Maple. Here is a sample (The DirectSearch package should be downloaded from http://www.maplesoft.com/applications/view.aspx?SID=101333 and installed in your Maple.).

rsolve({a(k)=a(k-1)^2-2,a(0)=5/2},a)#2014,A-3

 (1)
 (2)

 (3)

 (4)

 (5)

 (6)

 (7)

 (8)

 (9)

 (10)

 (11)

 (12)

 (13)

 (14)

Hope the reader will try to continue the above.

## when Maple meets a major holiday

by:

Ever year about this time, somewhat geeky holiday-themed content makes the rounds on the internet.  And I realized that even though I have seen much of this content already, I still enjoy seeing it again. (Why wouldn’t I want to see a Dalek Christmas tree every year?)

So in the spirit of internet recycling, here are a couple of older-but-still-fun Maple applications with a Christmas/holiday theme for your enjoyment.

Talkin’ Turkey

The Physics of Santa Claus

Other examples (old or new) are most welcome, if anyone wants to share.

eithne

## Automatic simplification and a new Assume (as...

by:

Hi
Two new things recently added to the latest version of Physics available on Maplesoft's R&D Physics webpage are worth mentioning outside the framework of Physics.

• automaticsimplification. This means that after "Physics:-Setup(automaticsimplification=true)", the output corresponding to every single input (literally) gets automatically simplified in size before being returned to the screen. This is fantastically convenient for interactive work in most situations.

• Add Physics:-Library:-Assume, to perform the same operations one typically performs with the  assume command, but without the side effect that the variables get redefined. So the variables do not get redefined, they only receive assumptions.

This new Assume implements the concept of an "extended assuming". It permits re-using expressions involving the variables being assumed, expressions that were entered before the assumptions were placed, as well as reusing all the expressions computed while the variables had assumptions, even after removing the variable's assumptions. None of this is possible when placing assumptions using the standard assume. The new routine also permits placing assumptions on global variables that have special meaning, that cannot be redefined, e.g. the cartesian, cylindrical or spherical coordinates sets, or the coordinates of a coordinate spacetime system within the Physics package, etc.

Examples:

 >

This is Physics from today:

 >
 (1.1)
 • Automatic simplification is here. At this point automaticsimplification is OFF by default.
 >
 (1.2)

Hence, for instance, if you input the following expression, the computer just echoes your input:

 >
 (1.3)

There is however some structure behind (1.3) and, in most situations, it is convenient to have these structures
apparent, in part because they frequently provide hints on how to proceed ahead, but also because a more
compact expression is, roughly speaking, simpler to understand. To see this
automaticsimplification in action,
turn it ON:

 >
 (1.4)

Recall this same expression (you could input it with the equation label (1.3) as well)

 >
 (1.5)

What happened: this output, as everything else after you set  and with no
exceptions, is now further processed with simplify/size before being returned. And enjoy computing with frankly
shorter expressions all around! And no need anymore for "simplify(%, size)" every three or four input lines.

Another  example, typical in computer algebra where expressions become uncomfortably large and difficult to
read: convert the following input to 2D math input mode first, in order to compare what is being entered with the
automatically simplified output on the screen

 >
 (1.6)

You can turn automaticsimplification OFF the same way

 >
 (1.7)
 • New  facility; welcome to the world of "extended assuming" :)

Consider a generic variable, x. Nothing is known about it

 >

Each variable has associated a number that depends on the session, and the computer (internally) uses this
number to refer to the variable.

 >
 (1.8)

When using the assume  command to place assumptions on a variable, this number, associated to it, changes,
for example:

 >
 >
 (1.9)

Indeed, the variable x got redefined and renamed, it is not anymore the variable x referenced in (1.8).

 >
 Originally x, renamed x~:   is assumed to be: RealRange(Open(0),Open(1/2*Pi))

The semantics may seem confusing but that is what happened, you enter x and the computer thinks x~, not x
anymore.This means two things:

1) all the equations/expressions, entered before placing the assumptions on x using assume, involve a variable x
that is different than the one that exists after placing the assumptions, and so these previous expressions
cannot
be reused
. They involve a different variable.

2) Also, because, after placing the assumptions using assume, x refers to a different object, programs that depend
on the
x that existed before placing the assumptions will not recognize the new x redefined by assume .

For example, if x was part of a coordinate system and the spacetime metric depends on it, the new variable x
redefined within assume, being a different symbol, will not be recognized as part of the dependency of  This
posed constant obstacles to working with curved spacetimes that depend on parameters or on coordinates that
have a restricted range. These problems are resolved entirely with this new
Library:-Assume, because it does not
redefine the variables. It only places assumptions on them, and in this sense it works like
assuming , not assume .
As another example, all the
Physics:-Vectors commands look for the cartesian, cylindrical or spherical coordinates
sets
in order to determine how to proceed, but these variables disappear if you use
assume to place assumptions on them. For that reason, only assuming  was fully compatible with Physics, not assume.

To undo assumptions placed using the assume command one reassigns the variable x to itself:

 >
 (1.10)

Check the numerical address: it is again equal to (1.8)

 >
 (1.11)

·All these issues get resolved with the new Library:-Assume, that uses all the implementation of the existing
assume command but with a different approach: the variables being assumed do not get redefined, and hence:
a) you can reuse expressions/equations entered before placing the assumptions, you can also undo the
assumptions and reuse results obtained with assumptions. This is the concept of an
extended assuming. Also,
commands that depend on these assumed variables will all continue to work normally, before, during or after
placing the assumption, because
the variables do not get redefined.

Example:

 >

So this simplification attempt accomplishes nothing

 >
 (1.12)

Let's assume now that

 >
 (1.13)

The new command echoes the internal format representing the assumption placed.

a) The address is still the same as (1.8)

 >
 (1.14)

So the variable did not get redefined. The system however knows about the assumption - all the machinery of the
assume command is being used

 >
 Originally x, renamed x:   is assumed to be: RealRange(Open(0),Open(1/2*Pi))

Note that the renaming is to the variable itself - i.e. no renaming.

Hence, expressions entered before placing assumptions can be reused. For example, for (1.12), we now have

 >
 (1.15)

To clear the assumptions on x, you can use either of Library:-Assume(x=x) or Library:-Assume(clear = {x, ...}) in
the case of many variables being cleared in one go, or in the case of a single variable being cleared:

 >
 >

The implementation includes the additionally functionality, for that purpose add the keyword
anywhere in the calling sequence. For example:

 >
 (1.16)
 >
 Originally x, renamed x:   is assumed to be: RealRange(Open(0),infinity)
 >
 (1.17)
 >

In summary, the new Library:-Assume command implements the concept of an extended assuming, that can be
turned ON and OFF at will at any moment without changing the variables involved.

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

## Branch Cuts for a Product of Two Square Roots

Naive simplification of  to results in a pair of functions that agree on only part of the complex plane. In this application, the enhanced ability of Maple 18 to find and display branch cuts of composite functions is used to explore the branch cuts and regions of agreement/disagreement of f and F.

The algorithm by which Maple calculates branch cuts for square-root functions involves squaring, to remove the square root, and solving appropriate equations and inequalities. Unfortunately, this process is inherently prone to introducing spurious solutions, in which case the returned branch cut is not correct. One such instance in which a spurious solution arises is in the calculation of the branch cut for f; a best suggestion for dealing with such errors is found in the application.

Application: Branch Cuts for a Product of Two Square Roots

For those interested in learning more, the design for the new branch-cut facility in Maple 18 is inspired by the following paper:

England, M., Bradford, R., Davenport, J. H., and Wilson, D. 2013.  Understanding branch cuts of expressions. In: Carette, J., Aspinall, D., Lange, C., Sojka, P. and Windsteiger, W., eds.  Intelligent Computer Mathematics. Berlin: Springer, pp. 136-151. (Lecture Notes in Computer Science; 7961)

## Exploration Mathematics with Maple through Embedded...

Maple 18

Today science professionals in engineering software used to only work on the desktop and even just looking to download and use mobile apps math; but they are not able to design their own applications.Maplesoft to set the solution to it through its Maple package; software supports desktop and mobile; solves problems of analysis and calculation with Embedded Components. To show this we have taken the area of different mathematical topics; fixed horizontally to a certain range of parameters and not just a constant as it is customary to develop. This paper shows how the Embedded Components allow us to develop mathematics in all areas. Achieving build applications that are interactive in mobile devices such as tablets; which are used at any time. Maple gives us design according to our university or research need, based on contemporary and modern mathematics.With this method we encourage students, teachers and researchers to use graphics algorithms.

CSMP_PUCP_2014.pdf

Coloquio_PUCP.mw

Lenin Araujo Castillo

Physics Pure

Computer Science

## Add to the Physics:-Simplify and Physics:-Library:...

by: Maple

Partial rectification for the Physics:-Simplify and Physics:-Library:-SortProducts procedures dealing with Fermi annihilation/creation operators

This post will be useful for physicists dealing with Fermi annihilation/creation operators. Physics Package provides plenty of powerful tools for quantum operators handling, however some of them often fail to render correct result.  In particular incorrect behaviour with respect to Fermi annihilation/creation operators is observed for routines Simplify and SortProducts.  In this post I present my procedures  and  which partially solve these issues.

 Problems with Physics Package routines
 Short explanation of custom routines  and
 Weak points
 Final notes

## How to grow and prune a classification tree

Maple

I'd like to pay attention to the article of David Austin "How to Grow and Prune a Classification Tree"

Here is its introduction:

"

It's easy to collect data these days; making sense of it is more work. This article explains a construction in machine learning and data mining called a classification tree. Let's consider an example.

In the late 1970's, researchers at the University of California, San Diego Medical Center performed a study in which they monitored 215 patients following a heart attack. For each patient, 19 variables, such as age and blood pressure, were recorded. Patients were then grouped into two classes, depending on whether or not they survived more than 30 days following the heart attack.

Assuming the patients studied were representative of the more general population of heart attack patients, the researchers aimed to distill all this data into a simple test to identify new patients at risk of dying within 30 days of a heart attack.

By applying the algorithm described here, Breiman, Freidman, Olshen, and Stone, created a test consisting of only three questions---what is the patient's minimum systolic blood pressure within 24 hours of being admitted to the hospital, what is the patient's age, does the patient exhibit sinus tachycardia---to identify patients at risk. In spite of its simplicity, this test proved to be more accurate than any other known test. In addition, the importance of these three questions indicate that, among all 19 variables, these three factors play an important role in determining a patient's chance of surviving.

Besides medicine, these ideas are applicable to a wide range of problems, such as identifying which loan applicants are likely to default and which voters are likely to vote for a particular political party.

In what follows, we will describe the work of Breiman and his colleagues as set out in their seminal book Classification and Regression Trees. Theirs is a very rich story, and we will concentrate on only the essential ideas"

It would be interesting to compare this approach with discriminant analysis. Hope somebody of  the Maple developers will give a concrete example on this theme with Maple.

## Games with numbers

by:

The procedure  NumbersGame  generalizes the well-known 24 game  (implementation in Maple see here), as well as related issues (see here and here).

Required parameters of the procedure:

Result is an integer or a fraction of any sign.

Numbers is a list of positive integers.

Optional parameters:

Operators is a list of permitted arithmetic operations. By default  Operators is  ["+","-","*","/"]

NumbersOrder is a string. It is equal to "strict order" or "arbitrary order" . By default  NumbersOrder is "strict order"

Parentheses is a symbol  no  or  yes . By default  Parentheses is  no

The procedure puts the signs of operations from the list  Operators  between the numbers from  Numbers  so that the result is equal to Result. The procedure finds all possible solutions. The global  M  saves the list of the all solutions.

Code the procedure:

restart;

NumbersGame:=proc(Result::{integer,fraction}, Numbers::list(posint), Operators::list:=["+","-","*","/"], NumbersOrder::string:="strict order", Parentheses::symbol:=no)

local MyHandler, It, K, i, P, S, n, s, L, c;

global M;

uses StringTools, ListTools, combinat;

MyHandler := proc(operator,operands,default_value)

NumericStatus( division_by_zero = false );

return infinity;

end proc;

NumericEventHandler(division_by_zero=MyHandler);

if Parentheses=yes then

It:=proc(L1,L2)

local i, j, L;

for i in L1 do

for j in L2 do

L[i,j]:=seq(Substitute(Substitute(Substitute("( i Op j )","i",convert(i,string)),"j",convert(j,string)),"Op",Operators[k]), k=1..nops(Operators));

od; od;

L:=convert(L, list);

end proc;

P:=proc(L::list)

local n, K, i, M1, M2, S;

n:=nops(L);

if n=1 then return L else

for i to n-1 do

M1:=P(L[1..i]); M2:=P(L[i+1..n]);

K[i]:=seq(seq(It(M1[j], M2[k]), k=1..nops(M2)), j=1..nops(M1))

od; fi;

K:=convert(K,list);

end proc;

if NumbersOrder="arbitrary order" then S:=permute(Numbers); K:=[seq(op(Flatten([op(P(s))])), s=S)] else  K:=[op(Flatten([op(P(Numbers))]))] fi;

else

if NumbersOrder="strict order" then

K:=[convert(Numbers[1],string)];

for i in Numbers[2..-1] do

K:=[seq(seq(cat(k, Substitute(Substitute(" j i","j",convert(j,string)),"i",convert(i,string))), k in K), j in Operators)]

od;   else

S:=permute(Numbers);

for s in S do

L:=[convert(s[1],string)];

for i in s[2..-1] do

L:=[seq(seq(cat(k, Substitute(Substitute(" j i","j",convert(j,string)),"i",convert(i,string))), k in L), j in Operators)]

od; K[s]:=op(L) od; K:=convert(K,list) fi;

fi;

M:='M'; c:=0;

for i in K do

if parse(i)=Result then c:=c+1; if Parentheses=yes then M[i]:= convert(SubString(i,2..length(i)-1),symbol)=convert(Result,symbol) else M[i]:=convert(i,symbol)=convert(Result,symbol) fi; fi;

od;

if c=0 then M:=[]; return `No solutions` else M:=convert(M,list);  op(M) fi;

end proc:

Examples of use.

Example 1:

NumbersGame(1/20, [\$ 1..9]);

1 * 2 - 3 + 4 / 5 / 6 * 7 / 8 * 9 = 1/20

Example 2. Numbers in the list  Numbers  may be repeated and permitted operations can be reduced:

NumbersGame(15, [3,3,5,5,5], ["+","-"]);

3 - 3 + 5 + 5 + 5 = 15

Example 3.

NumbersGame(10, [1,2,3,4,5]);

1 + 2 + 3 * 4 - 5 = 10

If the order of the number in Numbers is arbitrary, then the number of solutions is greatly increased (10 solutions displayed):

NumbersGame(10, [1,2,3,4,5], "arbitrary order"):

nops(M);

for i to 10 do

M[1+50*(i-1)] od;

If you use the parentheses, the number of solutions will increase significantly more (10 solutions displayed):

NumbersGame(10, [1,2,3,4,5], "arbitrary order", yes):

nops(M);

for i to 10 do

M[1+600*(i-1)] od;

Game.mws

## update to Clickable Calculus Study Guide

by: Maple

For those who have the Clickable Calculus Study Guide for Maple 18, please note that we have released an update to this ebook, which provides corrections and improvements to the text and examples.

eithne

by: MaplePrimes

Earlier this morning, we published an update to MaplePrimes that includes two new features as well as some significant efficiency improvements. Highlights of this update include:

Of all the feature requests that we receive, this has been the most popular, and we're excited to see how it is used! Simply, this new capability allows a member to select the 'best answer' from a list of many. This best answer, selected by clicking on a new trophy icon, will always always appear at the top of the list of answers.

Tag Management

Improving how tags are managed within MaplePrimes has been another long time request from members, and we have made some significant improvements. The first thing that many will notice is that the interface for adding tags to a post or question is now easier to use and (hopefully) faster.

More importantly, however, are the new management features. For starters, only members with a reputation of at least 100 can add brand new tags. If your reputation is less than 100, you can only select from the extensive list of pre-existing keywords. In addition, members with a reputation of at least 50 can now manage tags for existing content by clicking on the new 'Manage Tags' button. It is our hope that this feature will help increase the value of tagging within MaplePrimes by optimizing the commonly-used keywords, and we encourage everyone to take advantage of this new capability!

Efficiency and Stability Improvements

You should notice significant speed increases across all pages within MaplePrimes. On average, page load times have sped up by a factor of 2x, and many times higher in some cases. In addition, interface changes and optimizations have dramatically reduced the file size of many pages, which will make them more responsive in general.

As always, thank you for making MaplePrimes the amazing community that it is! We are hopeful that you will enjoy these improvements, and we look forward to your comments and suggestions.

## mapleprimes update - links broken pics missing

MaplePrimes

Looks like mapleprimes was just updated.  I'm finding links broken and pictures missing.

## Maple T.A. Training Videos: Question Creation

by:

I am very happy to announce the addition of 36 new videos to the Maple T.A. Tutorial section on the Maplesoft website. These videos demonstrate how to create questions using each of the different question types in Maple T.A. You’ll find videos for multiple choice, true and false, maple-graded, mathematical formula, and much more, including the new graph sketching and free-body diagram questions introduced in Maple T.A. 10.

Jonny
Maplesoft Product Manager, Maple T.A.

## Draghilev’s method. Rolling without slipping....

by:

On the basis of the Draghilev’s method. Equations: x1^2 + x2^2 – 1 = 0 and  x1^4 + x2^4 - 0.12^4 = 0.
Rolling without slipping is nonholonomic constraint.

ROLLING.mw

## New release of Placement Test Suite

by:

A new release of the Maple T.A. MAA Placement Test Suite  is now available.

The latest release takes advantage of the streamlined interface, accessibility from tablets, and other new features of Maple T.A. 10. It also includes new testing content to determine if your students understand the concepts needed for success in their algebra and precalculus courses; new parallel versions of the calculus concepts readiness test; and improved searching and browsing of testing content.

To learn more, visit What’s New in Maple T.A. MAA Placement Test Suite 10.

eithne

 First 70 71 72 73 74 75 76 Last Page 72 of 296
﻿