This is a post that I wrote for the Altair Innovation Intelligence blog.

I have a grudging respect for Victorian engineers. Isambard Kingdom Brunel, for example, designed bridges, steam ships and railway stations with nothing but intellectual flair, hand-calculations and painstakingly crafted schematics. His notebooks are digitally preserved, and make for fascinating reading for anyone with an interest in the history of engineering.

His notebooks have several characteristics.

• Equations are written in natural math notation
• Text and diagrams are freely mixed with calculations
• Calculation flow is clear and well-structured

Hand calculations mix equations, text and diagrams.

Engineers still use paper for quick calculations and analyses, but how would Brunel have calculated the shape of the Clifton Suspension Bridge or the dimensions of its chain links if he worked today?

If computational support is needed, engineers often choose spreadsheets. They’re ubiquitous, and the barrier to entry is low. It’s just too easy to fire-up a spreadsheet and do a few simple design calculations.

 Spreadsheets are difficult to debug, validate and extend.

Spreadsheets are great at manipulating tabular data. I use them for tracking expenses and budgeting.

However, the very design of spreadsheets encourages the propagation of errors in equation-oriented engineering calculations

• Results are difficult to validate because equations are hidden and written in programming notation
• You’re often jumping about from one cell to another in a different part of the worksheet, with no clear visual roadmap to signpost the flow of a calculation

For these limitations alone, I doubt if Brunel would have used a spreadsheet.

Technology has now evolved to the point where an engineer can reproduce the design metaphor of Brunel’s paper notebooks in software – a freeform mix of calculations, text, drawings and equations in an electronic notebook. A number of these tools are available (including Maple, available via the APA website).

 Modern calculation tools reproduce the design metaphor of hand calculations.

Additionally, these modern software tools can do math that is improbably difficult to do by hand (for example, FFTs, matrix computation and optimization) and connect to CAD packages.

For example, Brunel could have designed the chain links on the Clifton Suspension Bridge, and updated the dimensions of a CAD diagram, while still maintaining the readability of hand calculations, all from the same electronic notebook.

That seems like a smarter choice.

Would I go back to the physical notebooks that Brunel diligently filled with hand calculations? Given the scrawl that I call my handwriting, probably not.

I am learning to use maple for my notes preparation for the subject Finite Element Analysis. It is interesting to know that how often we blame maple or computer for the silly mistakes we made in our commands and expect the exact answers. I have used a small file and find it easy to analyse my mistakes fatser. If we make a small mistake in a big file, it not only gives us problem finding our mistakes, it leads to more mistakes in other parts as well. A command working in one document need not necessarily work the same way in other document.

I have made my first document and people will come with suggestions to make appropriate modifications in the various sections to improve my knowledge on maple as well as the subject.

Download FINITE_ELEMENT_ANALYSIS.mw

Ramakrishnan V

rukmini_ramki@hotmail.com

Um den Studierenden zu helfen, deren Mathematikkenntnisse nicht auf dem von Studienanfängern erwarteten Niveau waren, hat die TU Wien einen Auffrischungskurs mit Maple T.A. entwickelt.  Die vom Team der TU Wien ausgearbeiteten Fragen zu mathematischen Themen wie der Integralrechnung, linearen Funktionen, der Vektoranalysis, der Differentialrechnung und der Trigonometrie, sind in die Maple T.A. Cloud übernommen worden.  Außerdem haben wir diesen Inhalt als Kursmodul zur Verfügung gestellt.

Laden Sie das Kursmodul der TU Wien herunter.

Bei Interesse können Sie mehr über das Projekt der TU Wien in diesem Anwenderbericht lesen: Erfolgreiches Auffrischen von Mathematikkenntnissen an der Technischen Universität Wien mit Maple T.A.

Jonny
Maplesoft Product Manager, Maple T.A.

Here's a simple package for drawing knot diagrams and computing the Alexander polynomial. A typical usage case for the AlexanderPolynomial function is when a knot needs to be identified and only a visual representation of the knot is available. Then it's trivial to write down the Dowker sequence by hand and then the sequence can be used as an input for this package. The KnotDiagram function also takes the Dowker sequence as an input.

TorusKnot(p, q) and PretzelKnot(p, q, r) are accepted as an input as well and can also be passed to the DowkerNotation function.

The algorithm is fairly simple, it works as follows: represent each double point as a quadrilateral (two 'in' vertices and two 'out' vertices); connect the quads according to the Dowker specification; draw the result as a planar graph; erase the sides of each quad and draw its diagonals instead. This draws the intersections corresponding to the double points and guarantees that there are no other intersections. The knot polynomial is then computed from the diagram.

The diagrams work fairly well for pretzel knots, but for certain knots they can be difficult to read because some of the quads around the double points can become too small or too skewed. Also, the code doesn't check that the generated quadrilaterals are convex (which is an implicit assumption in the algorithm).

knot.txt

knot.mw

Download knot.mw

knot.txt

ABSTRACT. In this paper we demonstrate how the simulation of dynamic systems engineering has been implemented with graphics software algorithms using maple and MapleSim. Today, many of our researchers the computational modeling performed by inserting a piece of code from static work; with these packages we have implemented through the automation components of kinematics and dynamics of solids simple to complex.

It is very important to note that once developed equations study; recently we can move to the simulation; to thereby start the physical construction of the system. We will use mathematical and computational methods using the embedded buttons which lie in the dynamics leaves and viewing platform cloud of Maplesoft and power MapleNet for online evaluation of specialists in the area. Finally they will see some work done; which integrate various mechanical and computational concepts implemented for companies in real time and pattern of credibility.

Selasi_2015.pdf

(in spanish)

Lenin Araujo Castillo

I have two linear algebra texts [1, 2]  with examples of the process of constructing the transition matrix  that brings a matrix  to its Jordan form . In each, the authors make what seems to be arbitrary selections of basis vectors via processes that do not seem algorithmic. So recently, while looking at some other calculations in linear algebra, I decided to revisit these calculations in as orderly a way as possible.

First, I needed a matrix  with a prescribed Jordan form. Actually, I started with a Jordan form, and then constructed  via a similarity transform on . To avoid introducing fractions, I sought transition matrices  with determinant 1.

Let's begin with , obtained with Maple's JordanBlockMatrix command.

The eigenvalue  has algebraic multiplicity 6. There are sub-blocks of size 3×3, 2×2, and 1×1. Consequently, there will be three eigenvectors, supporting chains of generalized eigenvectors having total lengths 3, 2, and 1. Before delving further into structural theory, we next find a transition matrix  with which to fabricate .

The following code generates random 6×6 matrices of determinant 1, and with integer entries in the interval . For each, the matrix  is computed. From these candidates, one  is then chosen.

After several such trials, the matrix  was chosen as

for which the characteristic and minimal polynomials are

So, if we had started with just , we'd now know that the algebraic multiplicity of its one eigenvalue  is 6, and there is at least one 3×3 sub-block in the Jordan form. We would not know if the other sub-blocks were all 1×1, or a 1×1 and a 2×2, or another 3×3. Here is where some additional theory must be invoked.

The null spaces  of the matrices  are nested: , as depicted in Figure 1, where the vectors , are basis vectors.

The vectors  are eigenvectors, and form a basis for the eigenspace . The vectors , form a basis for the subspace , and the vectors , for a basis for the space , but the vectors  are not yet the generalized eigenvectors. The vector  must be replaced with a vector  that lies in  but is not in . Once such a vector is found, then  can be replaced with the generalized eigenvector , and  can be replaced with . The vectors  are then said to form a chain, with  being the eigenvector, and  and  being the generalized eigenvectors.

If we could carry out these steps, we'd be in the state depicted in Figure 2.

Next, basis vector  is to be replaced with , a vector in  but not in , and linearly independent of . If such a  is found, then  is replaced with the generalized eigenvector . The vectors  and  would form a second chain, with  as the eigenvector, and  as the generalized eigenvector.

Define the matrix  by the Maple calculation

and note

The dimension of  is 3, and of , 5. However, the basis vectors Maple has chosen for  do not include the exact basis vectors chosen for .

We now come to the crucial step, finding , a vector in  that is not in  (and consequently, not in  either). The examples in  are simple enough that the authors can "guess" at the vector to be taken as . What we will do is take an arbitrary vector in  and project it onto the 5-dimensional subspace , and take the orthogonal complement as .

A general vector in  is

A matrix that projects onto  is

The orthogonal complement of the projection of Z onto  is then . This vector can be simplified by choosing the parameters in Z appropriately. The result is taken as .

The other two members of this chain are then

A general vector in  is a linear combination of the five vectors that span the null space of , namely, the vectors in the list . We obtain this vector as

A vector in  that is not in  is the orthogonal complement of the projection of ZZ onto the space spanned by the eigenvectors spanning  and the vector . This projection matrix is

The orthogonal complement of ZZ, taken as , is then

Replace the vector  with , obtained as

The columns of the transition matrix  can be taken as the vectors , and the eigenvector . Hence,  is the matrix

Proof that this matrix  indeed sends  to its Jordan form consists in the calculation

The bases for , are not unique. The columns of the matrix  provide one set of basis vectors, but the columns of the transition matrix generated by Maple, shown below, provide another.

I've therefore added to my to-do list the investigation into Maple's algorithm for determining an appropriate set of basis vectors that will support the Jordan form of a matrix.

Download JordanForm_blog.mw

Some time ago, @marc005 asked how he could send an email from the Maple command line.

Why would you want to do this? Using Maple's functionality, you could programatically construct an email - perhaps with the results of a computation - and email it yourself or someone else.

I originally posted a solution that involved communicating with a locally-installed SMTP server using the Sockets package. But of course, you need to set up an SMTP server and ensure the appropriate ports are open.

I recently found a better solution. Mailgun (http://mailgun.com) is a free email delivery service with an web-based API. You can communicate with this API via the URL package; simply send Mailgun a URL:-Post() message that contains account-specific information, and the text of your email.

The general steps and Maple commands are given below, and you can download the worksheet here.

Note: Maplesoft have no affiliation with Mailgun.

Step 1:
Sign up for a free Mailgun account.

Step 2:
In your Mailgun account, go to the Domains section - it should look like the screengrab below (account-specific information has been blanked).

Note down the API Base URL and the API key.

• the API Base URL looks like https://api.mailgun.net/v3/sandboxXXXXXXXXXXXXXXXXXXXXXXXXXXX.mailgun.org.  
• •the API Key looks like key-XXXXXXXXXXXXXXXXXXXXXXXXXX

Step 3:

In Maple, define strings containing your own API Base URL and API Key. Also, define the recipient's email address, the email you want the recipient to reply to, the email subject and email body.

>restart:

>APIBaseURL := "https://api.mailgun.net/v3/sandboxXXXXXXXXXXXXXXXXXXXXXXXX.mailgun.org":

>APIKey:="key-XXXXXXXXXXXXXXXXXXXXXXXX":

>toEmail := "xxxxx@xxxxxx.com":

>fromEmail:="First Last <FirstLast@Domain.com>":

>subject:= "Email Subject Goes Here":

>emailBody := "I'd rather have a bottle in front of me than a frontal lobotomy":

Step 4:
Run the following code

> URL:-Post(cat(APIBaseURL,"/messages"),[

"from"=fromEmail,"to"=toEmail,

"subject"=subject,

"text"= emailBody],

user="api",password=APIKey);

If you've successfully sent the email, you should see something like this (account-specific information is blanked out)

You can also send HTML emails by replacing the "text" line with "html" = str, where str is a string with your HTML code.

The engineering design process involves numerous steps that allow the engineer to reach his/her final design objectives to the best of his/her ability. This process is akin to creating a fine sculpture or a great painting where different approaches are explored and tested, then either adopted or abandoned in favor of better or more developed and fine-tuned ones. Consider the x-ray of an oil painting. X-rays of the works of master artists reveal the thought and creative processes of their minds as they complete the work. I am sure that some colleagues may disagree with the comparison of our modern engineering designs to art masterpieces, but let me ask you to explore the innovations and their brilliant forms, and maybe you will agree with me even a little bit.

Design Process

Successful design engineers must have the very best craft, knowledge and experience to generate work that is truly worthy of being incorporated in products that sell in the tens, or even hundreds, of millions. This is presently achieved by having cross-functional teams of engineers work on a design, allowing cross checking and several rounds of reviews, followed by multiple prototypes and exhaustive preproduction testing until the team reaches a collective conclusion that “we have a design.” This is then followed by the final design review and release of the product. This necessary and vital approach is clearly a time consuming and costly process. Over the years I have asked myself several times, “Did I explore every single detail of the design fully”? “Am I sure that this is the very best I can do?” And more importantly, “Does every component have the most fine-tuned value to render the best performance possible?” And invariably I am left with a bit of doubt. That brings me to a tool that has helped me in this regard.

A Great New Tool

I have used Maple for over 25 years to dig deeply into my designs and understand the interplay between a given set of parameters and the performance of the particular circuit I am working on. This has always given me a complete view of the problem at hand and solidly pointed me in the direction of the best possible solutions.

In recent years, a new feature called “Explore” has been added to Maple. This amazing feature allows the engineer/researcher to peer very deeply into any formula and explore the interaction of EVERY variable in the formula. 

Take for example the losses in the control MOSFET in a synchronous buck converter. In order to minimize these losses and maximize the power conversion efficiency, the most suitable MOSFET must be selected. With thousands of these devices being available in the market, a dozen of them are considered very close to the best at any given time. The real question then is, which one is really the very best amongst all of them? 

There are two possible approaches - one, build an application prototype, test a random sample of each and choose the one that gives you the best efficiency.  Or, use an accurate mathematical model to calculate the losses of each and chose the best. The first approach lacks the variability of each parameter due to the six sigma statistical distribution where it is next to impossible to get a device laying on the outer limits of the distribution. That leaves the mathematical model approach. If you take this route, you can have built-in tolerances in the equations to accommodate all the variabilities and use a simplified equation for the control MOSFET losses (clearly you can use a very detailed model should you chose to) to explore these losses. Luckily you can explore the losses using the Explore function in Maple.

The figure below shows a three dimensional plot, plus five other variables in the formula that the user can change using sliders that cover the range of values of interest including Minima and Maxima, while observing in real time the effects of the change on the power loss.

This means that by changing the values of any set of variables, you can observe their effect on the function. To put it simply, this single feature helps you replace dozens of plots with just one, saving you precious time and cost in fine-tuning your design. In my opinion, this is equivalent to an eight-dimensional/axes plot.

I used this amazing feature in the last few weeks and I was delighted at how simple it is to use and how much it simplifies the study of my approach and my components selection, in record times!

 Obtain the tri-stimulus XYZ values from the CIE Color matching functions.

 Show the gamut of maximum chroma for the standard observer model with a D65 Illuminant.

 Approximate the white point of a Planckian source and compare to D65.

 Translate the maximum chroma gamut in xy to Lab (CIE L*a*b*) for perceived gamut (Violet and Magenta come together)

 Map the RGB color cube of fully saturated color into Lab and compare to perceivable colors.

10/6/15  Initial Document

•12/28/15 Improve RGB gamut with more data points: Procedures added for RGB to Lab: Wavlength Colors now based on CIEDE2000 model for Lab.                   

 Here is the latest version of this document, the MSL_data must be in a directory set in the mw file;

MSL_data.xlsx    Vision_RGB_Gamut.mw

In this paper we will demonstrate the many differences of implementation in the modeling of mechanical systems using embedded components through Maplesoft. The mechanical systems are used for different tasks and therefore have different structure in its design; as to the nature of the used functional elements placed on them, they vary greatly. This diversity is reflected in approaches and practices in modeling.

The following cases focus on mechanical components of the units manufacturing and processing machines. We can generate graphs for analysis using different dynamic pair ametros; all in real-time considerations in its manufacturing costs from the equations of conservation of energy.
Therefore modeling with Maplesoft ensures the smooth optimum performance in mechanical systems, highlighting the sustainability criteria for other areas of engineering.

XXXIII_Coloquio_SMP_2015.pdf

XXXIII_Coloquio_UNASAM_2015.mw

(in spanish)

L.AraujoC.

Apparently inconsistent behaviour of the BesselJ() function.

Examples: BesselJ(-3, 0)  ... gives 0 (correct)

but BesselJ(-3.0, 0), BesselJ(-3, 0.0)  and BesselJ(-3, 0.0) all give Float(infinity) (wrong! - should be 0.0)

The problem seems to occur for all negative integer values of the first argument (the order) when the second argument is 0 or 0.0.

Download Physics[Factor].mw

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

Maple's dsolve numeric can solve delay ODEs and DAEs as of Maple 18. However, if I am not wrong, it cannot solve delay equations with a time dependent history. In this post I show two examples.

Example 1:

y1(t) and y2(t) with time dependent history. Use of piecewise helps this problem to be solved efficiently. Hopefully Maple will add history soon in its capability.

Example 2: 

This is a very a complicated stiff problem from immunology. As of now, I believe only Maple can solve this (other than RADAR5 from Prof. Hairer). Details and plots are posted in the attached code.

Let me know if any one has a delay problem that needs to be solved. I have tested many delay problems in Maple (they work fine). The attached examples required addtional tweaking, hence the post.

I want to take this opportunity to congratulate and thank Maple's dsolve numeric/delay solvers for their fantastic job. Maple is world leader not because of example1, but because of its ability to solve example 2.

Download delayimmunetopost.mws

LL_104)_NASDAQ.mw
Portfolio_Optimization.txt

Portfolio Optimization with Google Spreadsheet and Maple
 

I will in this post show how to manage data and do portfolio optimization in Maple by using google spreadsheet.

You can either use a direct link to the data:

https://docs.google.com/spreadsheets/d/1L5-yUB0EWeBdJNMdELKBRmBQ1JJ0QymrtDLkVhHCVn8/pub?gid=649021574&single=true&output=csv

or you can set up your own google spreadsheet. If you choice to set up your own spreedsheet follow the below road map:

1) select which market you want to follow:

NASDAQ

http://www.nasdaq.com/screening/companies-by-industry.aspx?exchange=NASDAQ&render=download

NYSE

http://www.nasdaq.com/screening/companies-by-industry.aspx?exchange=NYSE&render=download

AMEX

http://www.nasdaq.com/screening/companies-by-industry.aspx?exchange=AMEX&render=download

2) Create a new google spreadsheet and name two sheets Blad1 and Panel. In the first cell of Blad1 you put the formula:

=IMPORTDATA("http://www.nasdaq.com/screening/companies-by-industry.aspx?exchange=NASDAQ&render=download")

you need to change the url to match your selection in 1).

3) In the first cell of Panel you put the name "Ticker" and then you copy all the ticker names from Blad1.

4) In the script editor you put in the below java script code:

function PanelCreation_Stock() 

{
var ss = SpreadsheetApp.getActiveSpreadsheet();
var sourceSheet = ss.getSheetByName("Blad1");
var dstSheet = ss.getSheetByName("Panel");
var curDat = new Date();
var day1 = curDat.getDay();
if(day1 == 0 || day1 == 1)
{
return;
}
var lCol = dstSheet.getLastColumn();
var srcdate = dstSheet.getRange(1, 1, 1, lCol).getValues();

for(var k=1;k<=srcdate[0].length-1;k++)
{
if(Utilities.formatDate(srcdate[0][k],"GMT", "dd-MMM-yy") == Utilities.formatDate(curDat,"GMT", "dd-MMM-yy"))
{
return;
}
}
var snRows = sourceSheet.getLastRow();
var dnRows = dstSheet.getLastRow();

var srcStock = sourceSheet.getRange("A2:A" + snRows).getValues();
var srcLastSale = sourceSheet.getRange("C2:C" + snRows).getValues();

var dstStock = dstSheet.getRange("A2:A" + dnRows).getValues();
var dstLastSale = dstSheet.getRange("Z2:Z" + dnRows).getValues();

for(var j=0;j<dnRows-1;j++)
{
dstLastSale[j][0]="n/a";
}
var flag = "true";
var foundStock;
for(var i=0;i<snRows-1;i++) //snRows
{
var sStockVal = srcStock[i][0];

//var foundStock = ArrayLib.indexOf(dstStock,0, sStockVal);

flag="false";
for(var j=0;j<dnRows-1;j++)
{
if(dstStock[j][0].toString().toUpperCase() == srcStock[i][0].toString().toUpperCase())
{
flag = "true";
foundStock = j;
break;
}
}
if(flag=="true")
{
dstLastSale[foundStock][0] = srcLastSale[i][0];
}
else
{
var dnRows1 = dstSheet.getLastRow()+1;
dstSheet.getRange("A" + dnRows1).setValue(srcStock[i][0]);
dstSheet.getRange(dnRows1,lCol+1,1,1).setValue(srcLastSale[i][0]);
for(var k=2;k<=lCol;k++)
{
if(dstSheet.getRange(dnRows1, k).getValue()=="")
{
dstSheet.getRange(dnRows1, k).setValue("n/a");
}
}
}
}
dstSheet.getRange(1,lCol+1).setValue(curDat);
dstSheet.getRange(2, lCol+1, dstLastSale.length, 1).setValues(dstLastSale);
}

 
5) Set it to run each day at 12:00. The code will save the new last sale price for monday to friday with one days lag.

Now we can move on to Maple.

In Maple run the following code to load the data:

X := proc (Url) local theDLL, URLDownloadToFile, myDirectory, myFile, Destination, DL;

theDLL := "C:\\WINDOWS\\SYSTEM32\\urlmon.dll";

URLDownloadToFile := define_external('URLDownloadToFileA', pCaller::(integer[4]), szURL::string, szFileName::string, dwReserved::(integer[4]), lpfnCB::(integer[4]), 'RETURN'::(integer[4]), LIB = theDLL);

if FileTools[Exists]("C:\\mydir") = true then FileTools:-RemoveDirectory("C:\\mydir", recurse = true, forceremove = true) else end if;

FileTools:-MakeDirectory("C:\\mydir");
myDirectory := "C:\\mydir";
myFile := "data1.csv";
Destination := cat(myDirectory, "\\", myFile);

DL := proc () local M;

URLDownloadToFile(0, Url, Destination, 0, 0);
M := ImportMatrix("C:\\mydir\\data1.csv", delimiter = ",", datatype = string);
M := Matrix(M, datatype = anything)

end proc;

return DL()

end proc:

data := X("https://docs.google.com/spreadsheets/d/1L5-yUB0EWeBdJNMdELKBRmBQ1JJ0QymrtDLkVhHCVn8/pub?gid=649021574&single=true&output=csv");
L := LinearAlgebra:-Transpose(data);

If you use your own spreadsheet you need to change the url to match that spreadsheet.
Select File -> Publish to the web in google spreadsheet

We can now run the portfolio optimization in Maple:

with(Statistics):
with(ListTools):
with(LinearAlgebra):
with(Optimization):
with(plots):

Nr, Nc := ArrayTools:-Size(L):
symb := L[1 .. 1, 2 .. Nc]:
LL := L[2 .. Nr, 2 .. Nc]:
Nr, Nc := ArrayTools:-Size(LL):

# Removing stocks with missing observations
for i to Nc do if Occurrences("n/a", convert(Column(LL, i), list)) >= 1 then AA[i] := i else AA[i] := 0 end if
end do;

DD := RemoveInRange([seq(AA[i], i = 1 .. Nc)], 0 .. 1):
symbb := DeleteColumn(symb, DD):
LLL := map(parse, DeleteColumn(LL, DD)):
Nr, Nc := ArrayTools:-Size(LLL):

# Calculate Return
for j to Nc do
for i from 2 to Nr do

r[i, j] := (LLL[i, j]-LLL[i-1, j])/LLL[i-1, j]

end do
end do;

RR := Matrix([seq([seq(r[i, j], j = 1 .. Nc)], i = 2 .. Nr)], datatype = float[8]);
n, nstock := ArrayTools:-Size(RR):

# Portfolio Optimization
W := Vector(nstock, symbol = w):
y := Vector(n, fill = 2, datatype = float[8]):
s1 := Optimization[LSSolve]([y, RR])[2];
Nr, Nc := ArrayTools:-Size(s1):

j := 0:
for i to Nr do if s1[i] <> 0 then j := j+1; ss1[j] := symbb[1, i] = s1[i] end if end do;

Vector(j, proc (i) options operator, arrow; ss1[i] end proc);
LineChart(s1);