## Timely DataFrames Example: 2020 US Presidential...

by: Maple 2020

DataFrames: An example from the 2020 U.S. Presidential election

In this example of working with DataFrames, the goal is to use a spreadsheet from a website, which contains polling data, to estimate the probability each of the two candidates from the major parties will win the US Presidential election in November.  I first tried doing the calculations with a spreadsheet, but I discovered DataFrames was far more powerful. Warning: This worksheet uses live data. Hence the outcome at the end of the worksheet is likely to change daily. A more extensive example with even more common DataFrame operations should be available soon.

How the US Presidential election works - highly simplified version: In the US there are only two parties for which their candidate could win the election:  the Democratic party and Republican party. The Republican party is often referred to as the "Grand Old Party", or GOP. Each state executes its own election. The candidate who receives the most votes wins the states "electoral votes" (EV). The number of the electoral votes for each state is essentially proportional to the population of the state. A candidate who receives a total of 270 or more EVs out of 538, is declared the president of the US for the next term, which starts January 20 of 2021.

Creating DataFrame from web based data:

 >

Each row contains information about a poll conducted in one of the states.  The first poll starts on row 2, hence the number of polls are:

 >

Now I want to create a new DataFrame containing only the most useful information. In web_data, many are the columns are not important. However I do want to keep the column label names from those columns I wish to retain.

 >

Because  the first poll in web_data is labeled 2, I would like to relabel all the polls starting from 1

 >

Creating a DataFrame from a Matrix or another DataFrame:  (with row labels and column labels)

Now I can build the DataFrame that I will be working with:

 >

What each column means

* "Day" - day of the year in 2020 when the poll within the state was halfway completed. The larger the value, the more recent the poll.

* "State" - the state in the US where the poll was conducted. The candidate that receives the most votes "wins the state".

* "EV" - the number of electoral votes given to the candidate who receives the most votes within the state.

* "Dem" - the percentage of people who said they are going to vote for the candidate from the Democratic party.

* "GOP" - the percentage of people who said they are going to vote for the candidate from the Republican party.

Sorting:

By using the sort function, using the `>` operator, I can see which polls are the more recent. (If you run the worksheet yourself, the outcome will change as more polls are added to the website spreadsheet.)

 >

Selecting Unique entries - by column values:

For the my simple analysis, I will use only the most recent poll, one from each state. Hence, using AreUnique, I can pull the first row that matches a state name. This new DataFrame called states.

 >

(Note, one of the "states" is the District of Columbia, D.C., which is why there are 51 rows.)

Removing a column: (and relabeling rows)

This next example isn't necessary, but shows some of the cool features of DataFrames.

Since there is only 1 entry per state, I'm going to remove the "State" column and relabel all the rows with the state names

 >

Indexing by row labels:

This allow me to to display information by individual states. What is the data for California, Maine and Alaska?

 >

Mathematics with multiple-columns:

My preference is to work with fractions, rather than percentages. Hence I want all the values in the "Dem" and "GOP" to be divided by 100 (or multiplied by 1/100).  Treating each column like a vector, the multiplication is performed individually on each cell. This is what the tilda, "~", symbol performs.

 >

Mathematics: using a function to calculate a column

For the next action, I want to use the power of the Statistics package to create a "probability of winning the state" function.

For simplicity, I will assume the outcome of the voting in a state is purely random, but is conditional to popularity of each candidate as measured by the polls. I'll assume the likelihood of an outcome follows a normal (Gaussian) distribution with the peak being at point where the difference of the polling of the two candidates is zero. (Note, other than 2016, where there was an unusually larger percentage of undecided voters on election day, this simple model is reasonable accurate. For example, in 2012, of the states which appeared to be the "closest", the winner over-performed his polling in half of them, and under-performed in the other half with a mean difference of nearly zero.)  From previous elections, the standard deviation of differences between polling values and the actual outcome is at most 0.05, however, it does increase with the fraction of undecided voters.

To mathematically model this situation, I have chosen to use the "Cumulative Density Function" CDF in the Statistics package. It will calculate the probability that a candidate polling with fraction f1 wins the election if the other candidate is polling with fraction f2.  The variable u is the fraction of undecided voters. It is included in the calculation to increase the spread of the possible outcomes.

 >

Converting this expression into a function using the worst named function in Maple, unapply:

 >

Now I can calculate a DataFrames column of the "win probability", in this case, for the candidate from the Democratic platy. By apply the function, individually, using the columns "Dem" and "GOP", I produce:

 >

Appending a column:

I can add this column to the end of the states with the label "DemWinProb":

 >

Mathematics of adding the entries of a column:

 >

While the number of EV a candidate wins is discrete, I can use the "win probability" from each state to estimate the total number of EV each of the candidates might win. This means adding up number of EV in each state times, individually, the probability of winning that state:

 >

Currently, the candidate from the Democratic party is likely to win more then 300 electoral vtes.

What about for the candidate from the Republican / "GOP" party?

 >

Summing the two EV values, we obtain the total number of electoral votes.

 >

## Workaround for the problem of installing MapleCloud...

by: Maple 2020

Hi,
Some people using the Windows platform have had problems installing MapleCloud packages, including the Maplesoft Physics Updates. This problem does not happen in Macintosh or Linux/Unix, also does not happen with all Windows computers but with some of them, and is not a problem of the MapleCloud packages themselves, but a problem of the installer of packages.

I understand that a solution to this problem will be presented within an upcoming Maple dot release.

Meantime, there is a solution by installing a helper library; after that, MapleCloud packages install without problems in all Windows machines. So whoever is having trouble installing MapleCloud packages in Windows and prefers not to wait until that dot release, instead wants to install this helper library, please email me at physics@maplesoft.com

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

## 2D Input operator assignment syntax

by: Maple

Caution, certain kinds of earlier input can affect the results from using the 2D Input syntax for operator assignment.

 >

 >
 >

The following now produces a remember-table assignment,
instead of assigning a procedure to name f, even though by default
Typesetting:-Settings(functionassign)
is set to true.

 >

 >

 >

 >
 >

With the previous line of code commented-out the following
line assigns a procedure to name f, as expected.

If you uncomment the previous line, and re-execute the whole
worksheet using !!! from the menubar, then the following will

 >

 >

 >

 >

## Visualize the behaviour of a mechanical system

by: Maple

HI,

This post concerns the simulation of a physical system whose behavior is governed by ODEs.
It is likely that some people will think that all which follows is nothing but embellishments  or a waste of time.
And in some sense they will be right.
I was thinking the same until I received some sharp remarks at the occasion of a few presentations of my works.
So experience has proven me that doing a presentation in front of project managers with only 2D curves often leads to smiles, not to speak about those who raise their eyes to heaven in front of the poverty of the slides.
Tired of this attitude, I decided to replace these 2D curves with a short film, which of course does not reveal more than what these 2D curves were already revealing, but which is pretty enough for the financing keeps going on.

For those of you who might regret this situation, just consider this work as a demonstration of the capabilities of Maple in 3D rendering.

PS: all the display outputs have been removed to avoid loading an unnecessary huge file.
The two last commands must be uncommented to play the animation.

Maple

## Three level Newton-Raphson optimization code

by: Maple

Newton raphson method is used for optimization of functions and is based on taylor series expansion. Here is the code for a three level newton raphson method.

 >
 .8180854533 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808 .8164965808
 >
 (1)
 >
 (2)
 >

## what are the main things you like to see improved...

by: Maple

What are the things you most like to see improved/add to next version of Maple?

This is my list for a starter:

1.  Improve the debugger. Debugger is very useful but needs more work. At least be able to see code listing in larger view as one steps in for example. See Matlab debugger for inspiration.

3. Eliminate hangs when using timelimit(). On long runs, random hangs happen when timelimit() do not expire as requested. Posted about this before.

## Use of MapleSim to teach Vector Analysis

In the present work we are going to demonstrate the importance of the study of vector analysis, with modeling and simulation criteria, using the MapleSim scientific software from MapleSoft. Nowadays, the majority of higher education centers direct their teaching of vector analysis in an abstract way and there are few or no teachers who carry out applications using modeling and simulation. (In spanish)

IPN_CICATA_2020.pdf

## Maple 2020.1.1 update

by: Maple 2020

We have just released an update to Maple, Maple 2020.1.1. This update includes the following:

• Correction to a problem that occurred when printing or exporting documents to PDF. If the document included a 3-D plot, nearby text was sometimes missing from the printed/exported document.
• Correction to an issue that prevented users from installing between-release updates to the Physics package

In particular, please note that this update fixes the problems reported on MaplePrimes in Maple 2020.1 issue with print to PDF  and installing the Maplesoft Physics updates. As always, we appreciate the feedback.

## The strandbeest

Maple 2020

The strandbeest is a walking machine developed by Theo Jansen. Its cleverly designed legs consist of single-degree-of-freedom linkage mechanisms, actuated by the turning of a wind-powered crankshaft.

His working models are generally large - something of the order of the size of a bus. Look for videos on YouTube.  Commercially made small toy models are also available.  This one sells for under \$10 and it's fun to assemble and works quite well. Beware that the kit consists of over 100 tiny pieces - so assembling it is not for the impatient type.

Here is a Maple worksheet that produces an animated strandbeest. Link lengths are taken from Theo Jansen's video (go to his site above and click on Explains) where he explains that he calculated the optimal link lengths by applying a genetic algorithm.

Here is a Maple animation of a single leg.  The yellow disk represents the crankshaft.

And here are two legs working in tandem:

Here is the complete beest, running on six legs. The crankshaft turns at a constant angular velocity.

The toy model noted above runs on twelve legs for greater stability.

## The Friis Transmission Equation

by: Maple 2020

This may be of interest to anyone curious about why the effective area of an isotropic antenna is λ^2/4π.

Friis Transmission Equation

 Initialise

 The Hertzian Dipole antenna The Hertzian Dipole is a conceptual antenna that carries a constant current along its length.     By laying a number of these small current elements end to end, it is possible to model a physical antenna (such as a half-wave dipole for example).  But since we are only interested in obtaining an expression for the effective area of an Isotropic Antenna (in order to derive The Friis Transmission Equation) the Hertzian Dipole will be sufficient for our needs.

Maxwell's Equations

Since the purpose of a radio antenna is to either launch or to receive radio waves, we know that both the antenna, and the space surrounding the antenna, must satisfy Maxwell's Equations. We define Maxwell's Equations in terms of vector functions using spherical coordinates:

 (3.1)

Ampère's circuital law (with Maxwell's addition):

 (3.2)

Gauss' Law:

 (3.3)

Gauss' Law for Magnetism:

 (3.4)

Where:

E is the electric field strength [Volts/m]

H is the magnetic field strength [Amperes/m]

J is the current density (current per unit area) [Amperes/m2]

ρ is the charge density (charge per unit volume) [Coulombs/m3]

ε is Electric Permittivity

μ is Magnetic Permeability

Helmholtz decomposition

The Helmholtz Decomposition Theorem states that providing a vector field, (F) satisfies appropriate smoothness and decay conditions, it can be decomposed as the sum of components derived from a scalar field, (Φ) called the "scalar potential", and a vector field (A) called the "vector potential".

F = -VΦ + V×A

And that the scalar (Φ) and vector (A) potentials can be calculated from the field (F) as follows (image from https://en.wikipedia.org/wiki/Helmholtz_decomposition):

Where:

r is the vector from the origin to the observation point (P) at which we wish to know the scalar or vector potential.

r' is the vector from the origin to the source of the scalar or vector potential (i.e. a point on the Hertzian Dipole antenna).

V'·F(r')  is the Divergence of the vector field (F) at source position r'.

V'×F(r')  is the Curl of the vector field (F) at source position r'.

Calculating the Scalar Potential for the magnetic Field, H

We know that the Divergence of the magnetic field (H) is zero:

 (4.1.1)

And so the magnetic field (H) must have a scalar vector potential of zero:

 (4.1.2)

Calculating the Vector Potential for the magnetic Field, H

We know that the Curl of the magnetic field (H) is equal to the sum of current density (J) and the rate of change of the electric filled (E):

 (4.2.1)

Since the Hertzian Dipole is a conductor, we need only concern ourselves with the current density (J) when calculating the vector potential (A). Integrating current density (J) over the volume of the antenna, is equivalent to integrating current along the length of the antenna (L).

We know that Maxwell's Equations can be solved for single frequency (monochromatic) fields, so we will excite our antenna with a single frequency current:

 (4.2.2)

We can simplify the integral for the vector potential (A) by recognising that:

 1 Our observation point (P) will be a long way from the antenna and so (r) will be very large.
 2 The length of the antenna (L) will be very small and so (r') will be very small.

Since |r|>>|r'|, we can substitute |r-r'| with r.

Because we have decided that the observation point at r will be a long way from the antenna, we must allow for the fact that the observed antenna current will be delayed.  The delay will be equal to the distance from the antenna to the observation point |r-r'| (which we have simplified to r), divided by the speed of light (c).  The time delay will therefore be approximately equal to r/c and so the observed antenna current becomes:

 (4.2.3)

Since the length, L of the antenna will be very small, we can assume that the current is in phase at all points along its length.  Working in the Cartesian coordinate system, the final integral for the vector potential for the magnetic field is therefore:

 (4.2.4)

We will now convert to the spherical coordinate system, which is more convenient when working with radio antenna radiation patterns:

The radial component of the observed current (and therefore vector potential), will be at a maximum when the observer is on the z-axis (that is when θ=0 or θ=π) and will be zero when the observer is in the x-y-plane:

 (4.2.5)

The angular component of the observed current (and therefore vector potential), in the θ direction will be zero when the observer is on the z-axis (that is when θ=0 or θ=π) and will be at a maximum when the observer is in the x-y-plane:

 (4.2.6)

Since the observed current (and therefore vector potential) flows along the z-axis, there will be no variation in the Ï• direction.  That is to say, that varying Ï• will have no impact on the observed vector potential.

 (4.2.7)

And so the vector potential for the magnetic field (H) expressed using spherical coordinate system is:

 (4.2.8)

Calculating the Magnetic Field components

The Helmholtz Decomposition Theorem states that providing a vector field (F) satisfies appropriate smoothness and decay conditions, it can be decomposed as the sum of components derived from a scalar field (Φ) called "scalar potential", and a vector field (A) called the vector potential.

F = -VΦ + V×A

And so the magnetic field, H will be:

 (4.3.1)

We see that the magnetic field comprises two components, one is inversely proportional to the distance from the antenna (r) and the other falls off with r2.  Since we are interested in the far-field radiation pattern for the antenna, we can ignore the r2 component and so the expression for the magnetic field reduces to:

 (4.3.2)

We can further simplify by substituting ω/c for 2π/λ:

 (4.3.3)

Calculating the Poynting Vector

We know that the magnitude of the Poynting Vector (S) can be calculated as the cross product of the electric field vector (E) and the magnetic field vector (H) :

S = -E x H which is analogous to a resistive circuit where power is the product of voltage and current: P=V*I.

We also know that the impedance of free space (Z) can be calculated as the ratio of the electric field (E) and magnetic field (H) vectors: Z = E /H =

This is analogous to a resistive circuit where resistance is the ratio of voltage and current: R=V/I.

This provides two more methods for calculating the Poynting Vector (S):

S = -E·E/Z which is analogous to a resistive circuit where power, P=V2/R, and:

S = -H·H*Z which is analogous to a resistive circuit where power, P=I2R.

Since we have obtained an expression for the magnetic field vector (H), we can derive an expression for the Poynting Vector (S):

 (5.1)

We can separate out the time variable part to yield:

 (5.2)

Where:

 (5.3)

And we can visualise this radiation pattern using Maple's plotting tools:

So the Hertzian Dipole produces a electromagnetic radiation pattern with a pleasing doughnut shape :-)

Calculating Antenna Gain

We can calculate the total power radiated by the Hertzian Dipole by integrating the power flux density over all solid angles dΩ=sin(θ) dθ dφ.  Since we have expressed power flux density in terms of watts per square meter, we multiply the solid angle by r2 to convert the solid angle expressed in steradians into an area expressed in m2.

 (6.1)

We can now use this power to calculate the power flux density that would be produced by an isotropic antenna by dividing the total transmitted power by the area of a sphere with radius r:

 (6.2)

The Gain of the Hertzian Dipole is defined as the ratio between the maximum power flux density produced by the Hertzian Dipole and the maximum power flux density produced by the isotropic antenna:

 (6.3)

The input impedance of the Hertzian Dipole will have both a real and a reactive part.  The reactive part will be associated with energy storage in the near field and will not contribute to the Poynting Vector in the far-field.  For an ideal antenna (with no resistive power loss) the real part will be responsible for the radiated power:

 (7.1)

 (7.2)

Calculating the power received by a Hertzian Dipole

If an electromagnetic field (E) is incident on the Hertzian Dipole antenna, it will generate an Electro-Motive Force (EMF) at the antenna terminals.  The EMF will be at a maximum when the transmitter is on the x-y-plane (that is when θ=π/2) and will be zero when the transmitter is on the z-axis.

For and incident E-field:

 (8.1)

The z-axis component will be:

 (8.2)

The z-axis component of the E-field will create an EMF at the antenna terminals that will draw charge out of the receiver to each tip of the antenna. We can calculate the work done per unit charge by integrating the z-axis component of (E) over the length of the antenna (L):

 (8.3)

In order to extract the maximum possible power from the antenna, we will form a conjugate match between the impedance of the antenna and the load.  This means that the load resistance must be the same as the radiation resistance of the antenna.  The voltage developed across the load resistance will therefore be half of the open circuit EMF:

 (8.4)

And so the power delivered to the load will be:

 (8.5)

Calculating the Effective area of an Isotropic Antenna

We can also calculate the power received by the Hertzian Dipole by multiplying the power flux density arriving at the antenna with the effective area of an isotropic antenna and the gain of the Hertzian Dipole relative to an isotropic antenna:

 (9.1)

We can express the incident power flux density in terms of electric field strength and wave impedance:

 (9.2)

Rearranging, we obtain an expression for the effective area of the isotropic antenna:

 (9.3)

The Friis Transmission Equation

We can calculate the power flux density that would be produced by an isotropic antenna at a distance r from the antenna by dividing the total transmitted power Ptx by the area of a sphere with radius r:

 (10.1)

And so the power flux density that would be produced by an antenna with gain Gtx is:

 (10.2)

We can calculate the power received by an isotropic antenna by multiplying the power flux density incident onto the antenna with the effective area of an isotropic antenna:

 (10.3)

And so the power that would be received by an antenna with gain Grx is:

 (10.4)

The free space path loss is defined as the ratio between the received power and the transmitted power:

 (10.5)

And so:

 (10.6)

## Eigenfunctions of a multi-span Euler-Bernoulli...

Maple 2020

Question about deflection and vibration of beams occur with some regularity in this forum.  Search for "beam" to see several pages of hits.

In this post I present a general approach to calculating the vibrational modes of a beam that applies to both single-span and multi-span beams.  The code is not perfectly polished, but it is sufficiently documented to enable the interested user to modify/extend it as needed.

Vibrational modes of multi-span Euler-Bernoulli beams

through Krylov-Dunction functions

Rouben Rostamian
2020-07-19

 > restart;

Note:  Maple defines the imaginary unit . We want to use the
symbol  as the beam's cross-sectional moment of inertia.
Therefore we redefine the imaginary unit (for which we have no

use) as  and free up the symbol  for our use.

 > interface(imaginaryunit=II):
 > with(LinearAlgebra):
 >

The Euler-Bernoulli beam equation
.

We wish to determine the natural modes of vibration of

a possibly multi-span Euler-Bernoulli beam.

Separate the variables by setting .   We get
-

whence
.

Let .  Then

and

The idea behind the Krylov-Duncan technique is to express

in terms an alternative (and equivalent) set of basis
functions  through ,, as
,

where the functions  through  are defined in the next section.

In some literature the symbols , are used for these

functions but I find it more sensible to use the indexed function

notation.

The Krylov-Duncan approach is particularly effective in formulating
and finding a multi-span beam's natural modes of vibration.

 >
 >

The Krylov-Duncan functions

The K[i](x) defined by this proc evaluates to the th

Krylov-Duncan function.

Normally the index  will be in the set, however the proc is

set up to accept any integer index (positive or negative).  The proc evaluates

the index modulo 4 to bring the index into the set .   For

instance, K[5](x) and K[-3](x)i are equivalent to K[1](x) .

 > K := proc(x)         local n := op(procname);         if not type(n, integer) then                 return 'procname'(args);         else                 n := 1 + modp(n-1,4);  # reduce n modulo 4         end if;         if n=1 then                 (cosh(x) + cos(x))/2;         elif n=2 then                 (sinh(x) + sin(x))/2;         elif n=3 then                  (cosh(x) - cos(x))/2;         elif n=4 then                 (sinh(x) - sin(x))/2;         else                 error "shouldn't be here!";         end if; end proc:

Here are the Krylov-Duncan basis functions:

 > seq(print(cat(`K__`,i)(x) = K[i](x)), i=1..4);

and here is what they look like.  All grow exponentially for large
but are significantly different near the origin.

 > plot([K[i](x) \$i=1..4], x=-Pi..Pi,         color=["red","Green","blue","cyan"],         thickness=2,         legend=['K[1](x)', 'K[2](x)', 'K[3](x)', 'K[4](x)']);

The cyclic property of the derivatives:
We have .  Let's verify that:

 > diff(K[i](x),x) - K[i-1](x) \$i=1..4;

The fourth derivative of each   function equals itself. This is a consequence of the cyclic property:

 > diff(K[i](x), x\$4) - K[i](x) \$ i=1..4;

The essential property of the Krylov-Duncan basis function is that their

zeroth through third derivatives at  form a basis for :

 > seq((D@@n)(K[1])(0), n=0..3); seq((D@@n)(K[2])(0), n=0..3); seq((D@@n)(K[3])(0), n=0..3); seq((D@@n)(K[4])(0), n=0..3);

As noted earlier, in the case of a single-span beam, the modal  shapes

are expressed as
.

Then, due to the cyclic property of the derivatives of the Krylov-Duncan

functions, we see that:
.
.
.
Let us note, in particular, that
,
,
,
.

 >

A general approach for solving multi-span beams

In a multi-span beam, we write  for the deflection of the th span, where

and where  is the span's length.  The  coordinate indicates the

location within the span, with  corresponding to the span's left endpoint.

Thus, each span has its own  coordinate system.

We assume that the interface of the two adjoining spans is supported on springs

which (a) resist transverse displacement proportional to the displacement (constant of

proportionality of   (d for displacement), and (b) resist rotation proportional to the
slope (constant of proportionality of   (t for torsion or twist). The spans are numbered

from left to right. The interface conditions between spans  and +1 are

 1 The displacements at the interface match: .
 2 The slopes at the interface match (0).
 3 The difference of the moments just to the left and just to the right of the support is due to the torque exerted by the torsional spring:
 4 The difference of the shear forces just to the left and just to the right of the support is due to the force exerted by the linear spring:

The special case of a pinned support corresponds to  and .
In that case, condition 3 above implies that ,
and condition 4 implies that

Let us write the displacements  and  in terms of the Krylov-Duncan

functions as:

Then applying the cyclic properties of the Krylov-Duncan functions described

earlier, the four interface conditions translate to the following system of four
equations involving the eight coefficients .

,

which we write as a matrix equation
.

That  coefficient matrix plays a central role in solving

for modal shapes of multi-span beams.  Let's call it .

Note that the value of  enters that matrix only in combinations with
and .  Therefore we introduce the new symbols

,    .

The following proc generates the matrix .  The parameters  and

are optional and are assigned the default values of infinity and zero, which

corresponds to a pinned support.

The % sign in front of each Krylov function makes the function inert, that is, it
prevents it from expanding into trig functions.  This is so that we can

see, visually, what our expressions look like in terms of the  functions.  To

force the evaluation of those inert function, we will apply Maple's value function,

as seen in the subsequent demos.

 > M_interface := proc(mu, L, {Kd:=infinity, Kt:=0})         local row1, row2, row3, row4;         row1 := %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), -1,  0, 0, 0;         row2 := %K[4](mu*L), %K[1](mu*L), %K[2](mu*L), %K[3](mu*L),  0, -1, 0, 0;         row3 := %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L),  0, Kt/mu, -1, 0;         if Kd = infinity then                 row4 := 0, 0, 0, 0, 1, 0, 0, 0 ;         else                 row4 := %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), Kd/mu^3, 0, 0, -1;         end if:                 return < | | | >^+; end proc:

Here is the interface matrix for a pinned support:

 > M_interface(mu, L);

And here is the interface matrix for a general springy support:

 > M_interface(mu, L, 'Kd'=a, 'Kt'=b);

Note:  In Maple's Java interface, inert quantities are shown in gray.

Note:  The  in this matrix is the length of the span to the left of the interface.
Recall that it is  , not , in the derivation that leads to that matrix.

In a beam consisting of  spans, we write the th span's deflection  as

Solving the beam amounts to determining the  unknowns

which we order as

At each of the  interface supports we have a set of four equations as derived
above, for a total of  equations.  Additionally, we have four user-supplied

boundary conditions -- two at the extreme left and two at the extreme right of the

overall beam.  Thus, altogether we have  equations which then we solve for the

unknown coefficients .

The user-supplied boundary conditions at the left end are two equations, each in the
form of a linear combination of the coefficients .  We write  for the
coefficient matrix of that set of equations.  Similarly, the user-supplied boundary
conditions at the right end are two equations, each in the form of a linear combination
of the coefficients .  We write  for the  coefficient matrix of
that set of equations.   Putting these equations together with those obtained at the interfaces,

we get a linear set of equations represented by a  matrix which can be assembled

easily from the matrices , and .  In the case of a 4-span beam the

assembled matrix looks like this:

The pattern generalizes to any number of spans in the obvious way.

For future use, here we record a few frequently occurring  and  matrices.

 > M_left_pinned := <         1, 0, 0, 0;         0, 0, 1, 0 >;

 > M_right_pinned := (mu,L) -> <         %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L);         %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L) >;

 > M_left_clamped := <         1, 0, 0, 0;                 0, 1, 0, 0 >;

 > M_right_clamped := (mu,L) -> <         %K[1](mu*L), %K[2](mu*L), %K[3](mu*L), %K[4](mu*L);         %K[4](mu*L), %K[1](mu*L), %K[2](mu*L), %K[3](mu*L) >;

 > M_left_free := <         0, 0, 1, 0;                 0, 0, 0, 1 >;

 > M_right_free := (mu,L) -> <         %K[3](mu*L), %K[4](mu*L), %K[1](mu*L), %K[2](mu*L);         %K[2](mu*L), %K[3](mu*L), %K[4](mu*L), %K[1](mu*L) >;

The following proc builds the overall matrix in the general case.  It takes
two or three arguments.  The first two arguments are the  matrices
which are called  and  in the discussion above.  If the beam
consists of a single span, that's all the information that need be supplied.
There is no need for the third argument.

In the case of a multi-span beam, in the third argument we supply the
list of the interface matrices  , as in , listed in order
of the supports,  from left to right.   An empty list is also
acceptable and is interpreted as having no internal supports,
i.e., a single-span beam.

 > build_matrix := proc(left_bc::Matrix(2,4), right_bc::Matrix(2,4), interface_matrices::list)         local N, n, i, M;         # n is the number of internal supports         n := 0;         # adjust n if a third argument is supplied         if _npassed = 3 then                 n := nops(interface_matrices);                 if n > 0 then                         for i from 1 to n do                                 if not type(interface_matrices[i], 'Matrix(4,8)') then                                         error "expected a 4x8 matrix for element %1 in the list of interface matrices", i;                                 end if;                         end do;                 end if;         end if;         N := n + 1;                     # number of spans         M := Matrix(4*N);         M[1..2, 1..4] := left_bc;         for i from 1 to n do                 M[4*i-1..4*i+2, 4*i-3..4*i+4] := interface_matrices[i];         end do;         M[4*N-1..4*N, 4*N-3..4*N] := right_bc;                          return M; end proc:

For instance, for a single-span cantilever beam of length  we get the following  matrix:

 > build_matrix(M_left_clamped, M_right_free(mu,L));

For a two-span beam with with span lengths of  and , and all three
supports pinned,  we get the following  matrix:

 > build_matrix(M_left_pinned, M_right_pinned(mu,L[2]), [M_interface(mu, L[1])]);

The matrix  represents a homogeneous linear system (i.e., the right-hand side vector

is zero.)  To obtain a nonzero solution, we set the determinant of  equal to zero.

That gives us a generally transcendental equation in the single unknown .  Normally

the equation has infinitely many solutions.  We call these

Remark: In the special case of pinned supports at the interfaces, that is, when
, the matrix  depends only on the span lengths .
It is independent of the parameters  that enter the Euler-Bernoulli
equations.  The frequencies , however, depend on those parameters.

This proc plots the calculated modal shape corresponding to the eigenvalue .
The params argument is a set of equations which define the  numerical values

of all the parameters that enter the problem's description, such as the span

lengths.

It is assumed that in a multi-span beam, the span lengths are named  etc.,
and in a single-span beam, the length is named .

 > plot_beam := proc(M::Matrix,mu::realcons, params::set)         local null_space, N, a_vals, i, j, A, B, P;         eval(M, params);         eval(%, :-mu=mu);         value(%);  #print(%);         null_space := NullSpace(%);  #print(%);         if nops(null_space) <> 1 then                 error "Calculation failed. Increasing Digits and try again";         end if;         N := Dimension(M)[1]/4;  # number of spans         a_vals := convert([seq(seq(a[i,j], j=1..4), i=1..N)] =~ null_space[1], list);         if N = 1 then                 eval(add(a[1,j]*K[j](mu*x), j=1..4), a_vals);                 P[1] := plot(%, x=0..eval(L,params));         else                 A := 0;                 B := 0;                 for i from 1 to N do                         B := A + eval(L[i], params);                         eval(add(a[i,j]*K[j](mu*x), j=1..4), a_vals);                         eval(%, x=x-A):                         P[i] := plot(%, x=A..B);                         A := B;                 end do;                 unassign('i');         end if;         plots:-display([P[i] \$i=1..N]); end proc:
 >
 A single-span pinned-pinned beam Here we calculate the natural modes of vibration of a single span