Education

Maple T.A. course materials – Engineering Mechanics...

by: jzivku 640

August 30 2016

0 0

Hanze University of Applied Sciences Groningen has created 105 questions related to engineering mechanics for structures (statics/construction). These 105 randomised questions with graphics are used for first year students in civil engineering, structural engineering, architectural engineering and building engineering.

The topics of the course modules are as follows:
- Force Vectors (10)
- Support Reactions (26)
- Internal Forces (31)
- Stress (21)
- Trusses (17)

All questions have a translation button which makes it easy to switch from English to any other language. The questions are first shown in Dutch [NL] but by clicking [UK] in the Preview, the English version is shown. The text can easily be edited and changed into the language of choice in the Maple T.A. question editor. Only the button needs adjustment in the question source.

60 questions are “exercises“ which means that these questions have extended feedback. The remaining questions (45) are “tests” meaning that the questions include no feedback.

Cone.zip - construction exercises (60 questions)

Cont.zip - construction tests (45 questions)

Jonny
Maplesoft Product Manager, Online Education Products

Defining a quantum operator as a tensor – And...

by: Pascal4QM 478 Product: Maple 2016

August 24 2016

2 2

Hi,

In the following example I introduce some commutation rules that are standard in Quantum Mechanics. A major feature of the Maple Physics Package, is that it is possible to define tensors as Quantum Operators. This is of great interest because powerful tensor simplification rules can then be used in Quantum Mechanics. For an example, see the commutation rules of the components of the angular momentum operator in ?Physics,Examples. Here, I focus on a possible issue: when destroying all quantum operators, the pre-defined commutation rules still apply, which should not be the case. As shown in the post, this is link to the fact that these operators are also tensors.

>

(1)

>

First, set a 3D Euclidian space

>

(2)

Define two rank 1 tensors

>

${Physics:-Dgamma[a], Physics:-Psigma[a], Physics:-d_[a], Physics:-g_[a, b], p[k], x[k], Physics:-KroneckerDelta[a, b], Physics:-LeviCivita[a, b, c]}$

(3)

Now, further define these tensors as quantum operators and gives the usual commutation rule between position and momentum operators (Quantum Mechanics).

>

(4)

As expected:

>

(5)

Now, reset all the Hermitian operators, so that all quantum operators are destroyed. This is useful if, for instance, one needs to compare some the result with the commutative case.

>

(6)

As expected, there are no quantum operators anymore...

>

(7)

...so that the following expressions should commute (result should be true)

>

(8)

Result should be 0

>

(9)

>

(10)

>

Below is just a copy & paste of the above section. The only difference, is that "" has been commented, so that and are not a tensor. In that case, everything behaves as expected (but of course, the interesting feature of tensors is not available).

>

First, set a 3D Euclidian space

>

(11)

#Define two rank 1 tensors

>

Now, further define these tensors as quantum operators and gives the usual commutation rule between position and momentum operators (Quantum Mechanics)

>

(12)

As expected:

>

(13)

Now, reset all the Hermitian operators, so that all quantum operators are destroyed.

>

(14)

As expected, there are no quantum operators anymore...

>

(15)

...so that the following expressions should commute (result should be true)

>

(16)

Result should be 0

>

(17)

>

(18)

>

Download Quantum_operator_as_Tensors_August_23_2016.mw

why did that russian guy refuse a million dollars...

by: Adam Ledger 360

August 19 2016

4 13

just reading this story... a large quantity of information does not add up for me, like he denies it is his work and was done by hamilton? also its blasted across the net that he his proof is valid, so he cant say he doesnt want fame because its been all over the internet, and the sheer lack of logic of refusing money based on a moral code of conduct? then give it to charity, pay for a dozen scholarships but what the money is dirty?

pretty sure this whole thing is a pile of crap made up by someone.

odd Zeta value series approximation to the value of Ei...

by: Adam Ledger 360 Product: Maple

August 18 2016

0 0

Download EXPONENTIAL_INTEGRAL_ODD_ZETA_SERIES_APPROXIMATION.mw

CONGRUENT FUNCTIONS OF THE FRACTIONAL PART OVER...

by: Adam Ledger 360 Product: Maple

August 17 2016

0 1

A more honest and specific version of lemma 3.

CONGRUENT_FUNCTIONS_OF_THE_FRACTIONAL_PART_OVER_Q_LEMMA_4.mw

Maple Worksheet - Error

Failed to load the worksheet /maplenet/convert/CONGRUENT_FUNCTIONS_OF_THE_FRACTIONAL_PART_OVER_Q_LEMMA_4.mw .

Download CONGRUENT_FUNCTIONS_OF_THE_FRACTIONAL_PART_OVER_Q_LEMMA_4.mw

Application of first order equations

by: Lenin Araujo Castillo 1790 Product: Maple 2016

August 07 2016

2 0

It is very important that you learn to pose and solve equations in practical problems. Ernest Mach, a famous scientist of the nineteenth century, said that algebra is characterized by a lightening of mind, because the solution of a problem, after building the equation, you can "forget" all the practical situation to focus on the mathematical expression; everything that is not necessary to solve the problem no longer interfere with your mind. Another famous scientist, Isaac Newton, wrote that the language of algebra is the equation. To see a problem concerning abstract relations of numbers or amounts, simply translate the problem of colloquial language to the algebraic language. Here I leave the application for first order equations developed in 2016 Maple.

Aplicativo_Ecuaciones.mw

(In Spanish)

Lenin Araujo Castillo

Ambassador of Maple - Perú

Prime number subset code using set and list conversion...

by: Adam Ledger 360 Product: Maple

August 02 2016

1 26

hello i was just looking back on some stuff i did a few months back and although im aware there is a function for generating the prime subset up to a given number already featured in a package in mape im just curious to know how this one measures up in terms of computational efficiency etc.

anyway, this is code, if anyone has the time to give it a try and let me know what they think ie faster more logical way about it any feed back is appreciated cheers.

restart;
interface(showassumed = 0, rtablesize = infinity);
with(plots); with(numtheory); with(Statistics); with(LinearAlgebra); with(RandomTools); with(codegen, makeproc); with(combinat); with(Maplets[Elements]);
unprotect(real, rational, integer, complex);
alias(P[In] = CurveFitting[PolynomialInterpolation]); alias(L[In] = CurveFitting[LeastSquares]); alias(R[In] = CurveFitting[RationalInterpolation]); alias(S[In] = CurveFitting[Spline]); alias(B[In] = CurveFitting[BSplineCurve]); alias(L[In] = CurveFitting[ThieleInterpolation], rho = frac); alias(`&Nscr;` = Count); alias(`&Dopf;` = numtheory:-divisors); alias(sigma = numtheory:-sigma); alias(`&Fscr;` = ListTools['Flatten']); alias(`&Sopf;` = seq);
delta := proc (x, y) options operator, arrow; piecewise(x = y, 1, x <> y, 0) end proc;
`&Mopf;` := proc (X, Y) options operator, arrow; map(X, Y) end proc;
`&Cscr;`[S, L] := proc (X) options operator, arrow; convert(X, 'list') end proc;
`&Cscr;`[L, S] := proc (X) options operator, arrow; convert(X, 'set') end proc;
`&Popf;` := proc (N) options operator, arrow; `minus`({`&Sopf;`(k*delta(`&Nscr;`(`&Fscr;`(`&Cscr;`[S, L](`&Mopf;`(`&Cscr;`[S, L], `&Mopf;`(`&Dopf;`, `&Dopf;`(k)))))), 3), k = 1 .. N)}, {0}) end proc;
N -> `minus`({(k delta(&Nscr;(&Fscr;(&Cscr;[S, L]((&Cscr;[S, L])

&Mopf; (&Dopf; &Mopf; (&Dopf;(k)))))), 3)) &Sopf; (k = 1 .. N)},

{0})
n[P] := proc (N) options operator, arrow; `&Nscr;`(`&Cscr;`[S, L](`&Popf;`(N)))-1 end proc;

Maple Worksheet - Error

Failed to load the worksheet /maplenet/convert/prime_subset_up_to_N.mw .

Download prime_subset_up_to_N.mw

Diminishing Returns from Parallel Processing:...

by: Carl Love 28115 Product: Maple 2016

July 30 2016

1 8

This post is about the relationship between the number of processors used in parallel processing with the Threads package and the resultant real times and cpu times for a computation.

In the worksheet below, I perform the same computation using each possible number of processors on my machine, one thru eight. The computation is adding a list of 32 million pre-selected random integers. The real times and cpu times are collected from each run, and these are analyzed with a variety of metrics that I devised. Note that garbage-collection (gc) time is not an issue in the timings; as you can see below, the gc times are zero throughout.

My conclusion is that there are severely diminishing returns as the number of processors increases. There is a major benefit in going from one processor to two; there is a not-as-great-but-still-substantial benefit in going from two processors to four. But the real-time reduction in going from four processors to eight is very small compared to the substantial increase in resource consumption.

Please discuss the relevance of my six metrics, the soundness of my test technique, and how the presentation could be better. If you have a computer capable of running more than eight threads, please modify and run my worksheet on it.

Diminishing Returns from Parallel Processing: Is it worth using more than four processors with Threads?

Author: Carl J Love, 2016-July-30

Set up tests

restart:

currentdir(kernelopts(homedir)):
if kernelopts(numcpus) <> 8 then
     error "This worksheet needs to be adjusted for your number of CPUs."
end if:
try fremove("ThreadsData.m") catch: end try:
try fremove("ThreadsTestData.m") catch: end try:
try fremove("ThreadsTest.mpl") catch: end try:

#Create and save random test data
L:= RandomTools:-Generate(list(integer, 2^25)):
save L, "ThreadsTestData.m":

#Create code file to be read for the tests.
fd:= FileTools:-Text:-Open("ThreadsTest.mpl", create):
fprintf(
     fd,
     "gc();\n"
     "read \"ThreadsTestData.m\":\n"
     "CodeTools:-Usage(Threads:-Add(x, x= L)):\n"
     "fd:= FileTools:-Text:-Open(\"ThreadsData.m\", create, append):\n"
     "fprintf(\n"
     "     fd, \"%%m%%m%%m\\n\",\n"
     "     kernelopts(numcpus),\n"
     "     CodeTools:-Usage(\n"
     "          Threads:-Add(x, x= L),\n"
     "          iterations= 8,\n"
     "          output= [realtime, cputime]\n"
     "     )\n"
     "):\n"
     "fclose(fd):"
):
fclose(fd):

#Code review
fd:= FileTools:-Text:-Open("ThreadsTest.mpl"):
while not feof(fd) do
     printf("%s\n", FileTools:-Text:-ReadLine(fd))
end do:

fclose(fd):

gc();
read "ThreadsTestData.m":
CodeTools:-Usage(Threads:-Add(x, x= L)):
fd:= FileTools:-Text:-Open("ThreadsData.m", create, append):
fprintf(
     fd, "%m%m%m\n",
     kernelopts(numcpus),
     CodeTools:-Usage(
          Threads:-Add(x, x= L),
          iterations= 8,
          output= [realtime, cputime]
     )
):
fclose(fd):

Run the tests

restart:

kernelopts(numcpus= 1):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=0 bytes, cpu time=2.66s, real time=2.66s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.26s, real time=2.26s, gc time=0ns

Repeat above test using numcpus= 2..8.

restart:

kernelopts(numcpus= 2):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=2.19MiB, cpu time=2.73s, real time=1.65s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.37s, real time=1.28s, gc time=0ns

restart:

kernelopts(numcpus= 3):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.79MiB, alloc change=4.38MiB, cpu time=2.98s, real time=1.38s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=2.75s, real time=1.05s, gc time=0ns

restart:

kernelopts(numcpus= 4):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.80MiB, alloc change=6.56MiB, cpu time=3.76s, real time=1.38s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=3.26s, real time=959.75ms, gc time=0ns

restart:

kernelopts(numcpus= 5):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.80MiB, alloc change=8.75MiB, cpu time=4.12s, real time=1.30s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=3.74s, real time=910.88ms, gc time=0ns

restart:

kernelopts(numcpus= 6):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.81MiB, alloc change=10.94MiB, cpu time=4.59s, real time=1.26s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.29s, real time=894.00ms, gc time=0ns

restart:

kernelopts(numcpus= 7):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.81MiB, alloc change=13.12MiB, cpu time=5.08s, real time=1.26s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.63s, real time=879.00ms, gc time=0ns

restart:

kernelopts(numcpus= 8):
currentdir(kernelopts(homedir)):
read "ThreadsTest.mpl":

memory used=0.82MiB, alloc change=15.31MiB, cpu time=5.08s, real time=1.25s, gc time=0ns

memory used=0.78MiB, alloc change=0 bytes, cpu time=4.69s, real time=845.75ms, gc time=0ns

Analyze the data

restart:

currentdir(kernelopts(homedir)):

(R,C):= 'Vector(kernelopts(numcpus))' $ 2:
N:= Vector(kernelopts(numcpus), i-> i):

fd:= FileTools:-Text:-Open("ThreadsData.m"):
while not feof(fd) do
(n,Tr,Tc):= fscanf(fd, "%m%m%m\n")[];
(R[n],C[n]):= (Tr,Tc)
end do:

fclose(fd):

plot(
     (V-> <N | 100*~V>)~([R /~ max(R), C /~ max(C)]),
     title= "Raw timing data (normalized)",
     legend= ["real", "CPU"],
     labels= [`number of processors\n`, `% of max`],
     labeldirections= [HORIZONTAL,VERTICAL],
     view= [DEFAULT, 0..100]
);

The metrics:

R[1] /~ R /~ N: Gain: The gain from parallelism expressed as a percentage of the theoretical maximum gain given the number of processors

C /~ R /~ N: Evenness: How evenly the task is distributed among the processors

1 -~ C[1] /~ C: Overhead: The percentage of extra resource consumption due to parallelism

R /~ R[1]: Reduction: The percentage reduction in real time

1 -~ R[2..] /~ R[..-2]: Marginal Reduction: Percentage reduction in real time by using one more processor

C[2..] /~ C[..-2] -~ 1: Marginal Consumption: Percentage increase in resource consumption by using one more processor

plot(
     [
          (V-> <N | 100*~V>)~([
               R[1]/~R/~N,             #gain from parallelism
               C/~R/~N,                #how evenly distributed
               1 -~ C[1]/~C,           #overhead
               R/~R[1]                 #reduction
          ])[],
          (V-> <N[2..] -~ .5 | 100*~V>)~([
               1 -~ R[2..]/~R[..-2],   #marginal reduction rate
               C[2..]/~C[..-2] -~ 1    #marginal consumption rate
          ])[]
     ],
     legend= typeset~([
          'r[1]/r/n',
          'c/r/n',
          '1 - c[1]/c',
          'r/r[1]',
          '1 - `Delta__%`(r)',
          '`Delta__%`(c) - 1'
     ]),
     linestyle= ["solid"$4, "dash"$2], thickness= 2,
     title= "Efficiency metrics\n", titlefont= [HELVETICA,BOLD,16],
     labels= [`number of processors\n`, `% change`], labelfont= [TIMES,ITALIC,14],
     labeldirections= [HORIZONTAL,VERTICAL],
     caption= "\nr = real time, c = CPU time, n = # of processors",
     size= combinat:-fibonacci~([16,15]),
     gridlines
);

Download Threads_dim_ret.mw

Please bring back dsolve numeric method = mgear

by: Dr. Venkat Subramanian 431 Product: Maple

July 20 2016

2 5

In a recent conversation I explained whyLSODE was giving wrong results (http://www.mapleprimes.com/questions/210948-Can-We-Trust-Maple#comment230167). After a lot of confusions and weird infinite loops for answers, it turned out that Newton Raphson was not properly done.

Both LSODE and MEBDFI are currently incompletely implemented (only one iteration is done instead of Newton Raphson till convergence). Maplesoft should update the help files accordingly.

The post below explains how better results are obtained with method = mgear. To run the command mgear you will need Maple 6 or earlier versions. For lsode, any current version is fine. Unfortunately Maple deprecated an algorithm that worked fine. From Maple 8, the algorithm moved to Rosenbrock methods for stiff equations. This is still not ideal.

If Maple had a working algorithm, I am hoping that Maplesoft folks would consider bringing it back in future versions. (At least with the same functionality as in Maple 6).

PLEASE NOTE, the issue is not with solving this example (Very simple). This example is chosen to show how a popular algorithm in the literature is wrongly implemented.

Here Maple's lsode is forced to take only one step and use first order back ward difference formula to integrate from 0 to 1. LSODE mimics Eulerbackward using the options given below. The post shows that LSODE does not do Newton Raphson and just performs only iteration for nonlinear equations.

>

restart;

>	Digits:=15;

(1)

>	eq:=diff(y(t),t)=-y(t);

(2)

>	C:=array([0$22]);

(3)

>

C[9]:=1;

(4)

>	sol:=dsolve({eq,y(0)=1},type=numeric,method=lsode[backfull],ctrl=C,initstep=0.1,minstep=0.1,abserr=1,relerr=1):

>

sol(0.1);

(5)

>	subs(diff(y(t),t)=(y1-1)/0.1,y(t)=y1,eq);

(6)

>	fsolve(%,y1=0.5);

(7)

While for linear it gave the expected result, it gives wrong results for nonlinear problems.

>	sol1:=dsolve({eq,y(0)=1},type=numeric):

>	sol1(0.1);

(8)

>	eq:=diff(y(t),t)=-y(t)^2exp(-y(t))-10y(t)(1+0.01exp(y(t)));

(9)

>	sol:=dsolve({eq,y(0)=1},type=numeric,method=lsode[backfull],ctrl=C,initstep=0.1,minstep=0.1,abserr=1,relerr=1):

>

sol(0.1);

(10)

>	subs(diff(y(t),t)=(y1-1)/0.1,y(t)=y1,eq);

(11)

>	fsolve(%,y1=1);

(12)

>	sol1:=dsolve({eq,y(0)=1},type=numeric):

the expected answer is correctly obtained with default tolerance as

>	sol1(0.1);

(13)

The results obtained are worse than single iteration using jacobian.

>	eq2:=(lhs-rhs)(subs(diff(y(t),t)=(y1-1)/0.1,y(t)=y1,eq));

(14)

>	jac:=unapply(diff(eq2,y1),y1);

(15)

>	f:=unapply(eq2,y1);

(16)

>

y0:=1;

(17)

>	dy:=-evalf(f(y0)/jac(y0));

(18)

>	ynew:=y0+dy;

(19)

Following procedures confirm that it is indeed calling the procedure only at 0 and 0.1, with backdiag giving slightly better results.

>	myfun:= proc(x,y) if not type(x,'numeric') or not type(evalf(y),numeric)then 'procname'(x,y); else lprint(`Request at x=`,x); -y^2exp(-y(x))-10y(1+0.01exp(y)); end if; end proc;

myfun := proc (x, y) if not (type(x, 'numeric') and type(evalf(y), numeric)) then ('procname')(x, y) else lprint(`Request at x=`, x); -y^2*exp(-y(x))-10*y*(1+0.1e-1*exp(y)) end if end proc

(20)

>	sol1:=dsolve({diff(y(x),x)=myfun(x,y(x)),y(0)=1},numeric,method=lsode[backfull],ctrl=C,initstep=0.1,minstep=0.1,abserr=1,relerr=1,known={myfun}):

>	sol1(0.1);

`Request at x=`, 0.

`Request at x=`, .1

(21)

>	sol2:=dsolve({diff(y(x),x)=myfun(x,y(x)),y(0)=1},numeric,method=lsode[backdiag],ctrl=C,initstep=0.1,minstep=0.1,abserr=1,relerr=1,known={myfun}):

>	sol2(0.1);

`Request at x=`, 0.

`Request at x=`, .1

(22)

Download Lsodeanalysistrunc.mws

Next see how dsolve method = mgear works just fine in Maple 6 (gives the expected answer upto 3 Digits accuracy). To run this code you will need Maple 6 or earlier versions. Maple 7 has this algorithm, but I don't know to use it as it is hidden. I would like to get support from other members to get Maplesoft's attention to bring this algorithm back.

If Mdy/dt = f(y) is solved using mgear algorithm (instead of dy/dt =f ), then one can have a good DAE solver based on this (M being singular).

Download Mgearworks.mws

Linkage mechanisms

by: one man 1370 Product: Maple 15

July 10 2016

1 5

        General description of the method of solving underdetermined systems of equations. As a particular application of the idea proposed a universal method kinematic analysis for all kinds of spatial and planar link mechanisms with any number degrees of freedom.  The method can be used for powerful CAD linkages.
        http://www.maplesoft.com/applications/view.aspx?SID=154228

Points on the coordinate plane

by: Alsu 445 Product: Maple

July 08 2016

2 0

Points on the coordinate plane

(Guidance manual for the 6th class)

Changing the initial coordinates and going through the entire program first, we get a new picture-task

Point_on_co-plane.mws

And Another Coordinate_plane.mws

Points on the coordinate plane

by: Alsu 445 Product: Maple

July 08 2016

2 0

Points on the coordinate plane

(Guidance manual for the 6th class)

Changing the initial coordinates and going through the entire program first, we get a new picture-task

Point_on_co-plane.mws

And Another Coordinate_plane.mws

The definition of the derivative of the function

by: Alsu 445 Product: Maple

July 06 2016

5 11

diff_first.mws

The definition of the derivative of the function

by: Alsu 445 Product: Maple

July 06 2016

5 11

diff_first.mws

New version of the Multivariate Calculus Study...

by: eithne 2072 Products: Maple , Maple Toolboxes

June 29 2016

2 0

We have just released a new version of the Multivariate Calculus Study Guide. It provides a new section on Vector Calculus, with over 100 additional worked problems, and makes extensive use of Maple’s Clickable Math tools as well as commands.

Existing study guide customers can get the new content via a free update, available through the Check for Updates system or from our website. See Multivariate Calculus Study Guide 2016 Update for details.

For more information about this guide, including a full table of contents, visit Multivariate Calculus Study Guide.

eithne

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

E-Mail Address:
Password:
Remember Me:	Automatically sign in on future visits

Ask a Question

Create a Post

Teaching and learning about math, Maple and MapleSim

Maple T.A. course materials – Engineering Mechanics...

Defining a quantum operator as a tensor – And...

why did that russian guy refuse a million dollars...

odd Zeta value series approximation to the value of Ei...

CONGRUENT FUNCTIONS OF THE FRACTIONAL PART OVER...

Application of first order equations

Prime number subset code using set and list conversion...

Diminishing Returns from Parallel Processing:...

Please bring back dsolve numeric method = mgear

Linkage mechanisms

Points on the coordinate plane

Points on the coordinate plane

The definition of the derivative of the function

The definition of the derivative of the function

New version of the Multivariate Calculus Study...

Save this setting as your default sorting preference?

Ask a Question

Create a Post

Generating PDF…

Save this setting as your default sorting preference?
Note: You can change your preference any time in your account settings
Don't show this again