This post describes how Maple was used to investigate the Givens rotation matrix, and to answer a simple question about its behavior. The "Givens" part is the medium, but the message is that it really is better to teach, learn, and do mathematics with a tool like Maple.

The question: If Givens rotations are used to take the vector Y = <5, -2, 1> to Y₂ = , about what axis and through what angle will a single rotation accomplish the same thing?

The Givens matrix G₂₁ takes Y to the vector Y₁ =, and the Givens matrix G₃₁ takes Y₁ to Y₂. Graphing the vectors Y, Y₁, and Y₂ reveals that Y₁ lies in the xz-plane and that Y₂ is parallel to the x-axis. (These geometrical observations should have been obvious, but the typical usage of the Givens technique to "zero-out" elements in a vector or matrix obscured this, at least for me.)

The matrix G = G₃₁ G₂₁ rotates Y directly to Y₂; is the axis of rotation the vector W = Y x Y₂, and is the angle of rotation the angle  between Y and Y₂? To test these hypotheses, I used the RotationMatrix command in the Student LinearAlgebra package to build the corresponding rotation matrix R. But R did not agree with G. I had either the axis or the angle (actually both) incorrect.

The individual Givens rotation matrices are orthogonal, so G, their product is also orthogonal. It will have 1 as its single real eigenvalue, and the corresponding eigenvector V is actually the direction of the axis of the rotation. The vector W is a multiple of <0, 1, 2> but V = <a, b, 1>, where . Clearly, W  V.

The rotation matrix that rotates about the axis V through the angle  isn't the matrix G either. The correct angle of rotation about V turns out to be

the angle between the projections of Y and Y₂ onto the plane orthogonal to V. That came as a great surprise, one that required a significant adjustment of my intuition about spatial rotations. So again, the message is that teaching, learning, and doing mathematics is so much more effective and efficient when done with a tool like Maple.

A discussion of the Givens rotation, and a summary of the actual computations described above are available in the attached worksheet, What Gives with Givens.mw.

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

A wealth of knowledge is on display in MaplePrimes as our contributors share their expertise and step up to answer others’ queries. This post picks out one such response and further elucidates the answers to the posted question. I hope these explanations appeal to those of our readers who might not be familiar with the techniques embedded in the original responses.

Before I begin, a quick note that the content below was primarily created by one of our summer interns, Pia, with guidance and advice from me.

The Question: Rearranging the expression of equations

SY G wanted to be able to re-write an equation in terms of different variables.  SY G presented this example: 

I have the following two equations:

x1 = a-y1-d*y2;
x2 = a-y2-d*y1;

I wish to express the first equation in terms of y1 and x2, so that

x1 = c - b*y1+d*x2;

where c=a-a*d and b=1-d^2. How can I get Maple to rearrange the original equation x1 in term of y1, x2, c and b?

This question was answered by nm who provided code with a systematic approach:

restart;
eq1:=x1=a-y1-d*y2:
eq2:=x2=a-y2-d*y1:
z:=expand(subs(y2=solve(eq2,y2),eq1)):
z:=algsubs((a-a*d)=c,z):
algsubs((1-d^2)=b,z);

On the other hand, Carl Love answered this enquiry using a more direct and simple code:

simplify(x1=a-y1-d*y2, {a-y2-d*y1= x2, 1-d^2= b, a-a*d= c});

Let’s talk more about the expand, algsubs, subs, and simplify commands

First let’s take a look at the method nm used to solve the problem using the commands expand, subs, solve and algsubs.

The expand command, expand(expr, expr1, expr2, ..., exprn), distributes products over sums. This is done for all polynomials. For quotients of polynomials, only sums in the numerator are expanded; products and powers are left alone.

The solve command, solve(equations, variables), solves one or more equations or inequalities for their unknowns.

The subs command, subs(x=a,expr), substitutes a for x in the expression expr.

The function algsubs, algsubs(a = b, f),performs an algebraic substitution, replacing occurrences of a with b in the expression f.  It is a generalization of the subs command, which only handles syntactic substitution.

Let’s tackle the Maple code written by nm step by step:

1) restart;
The restart command is used to clear Maple’s internal memory

2)  eq1:=x1=a-y1-d*y2:
      eq2:=x2=a-y2-d*y1:
The names eq1 and eq2 were assigned to the equations SY G provided.

3) z:=expand(subs(y2=solve(eq2,y2),eq1)):
A new variable, z, was created, which will end up being x1 written in the terms SY G wanted.

• solve(eq2,y2)
  • the solve command was used to solve the expression eq2 for the variable y2.
    
    
• subs(y2=solve(eq2,y2),eq1)
  • The subs command was used to replace in expression eq1, y2 as determined by the solve step. 
    
    
• expand(subs(y2=solve(eq2,y2),eq1))
• The expand command was used to distribute products over sums. Note: this step served to ensure that the final output looked exactly how SY G wanted.

4) z:=algsubs((a-a*d)=c,z):
First, nm equated a-a*d to c, so later the algsubs command could be applied to substitute the new variable c into the expression z.

5) algsubs((1-d^2)=b,z);
Again, nm equated 1-d^2 to b, so later the algsubs command could be applied to substitute the new variable b into the expression z.

An alternate approach

Now let us check out Carl Love’s approach. Carl Love uses the simplify command in conjunction with side relations.

The simplify command has many calling sequences and one of them is the simplify(expr,eqns), that is known as simplify/siderels. A simplification of expr with respect to the side relations eqns is performed. The result is an expression which is mathematically equivalent toexpr but which is in normal form with respect to the specified side relations. Basically you are telling Maple to simplify the expression (expr) using the parameters (eqns) you gave to it.

I hope that you find this useful. If there is a particular question on MaplePrimes that you would like further explained, please let me know. 

A wealth of knowledge is on display in MaplePrimes as our contributors share their expertise and step up to answer others’ queries. This post picks out one such response and further elucidates the answers to the posted question. I hope these explanations appeal to those of our readers who might not be familiar with the techniques embedded in the original responses.

Before I begin, a quick note that the content below was primarily created by one of our summer interns, Pia, with guidance and advice from me.

The Question: Source Code of Math Apps

Eberch, a new Maple user, was interested in learning how to build his own Math Apps by looking at the source code of some of the already existing Math Apps that Maple offers.

Acer helpfully suggested that he look into the Startup Code of a Math App, in order to see definitions of procedures, modules, etc. He also recommended Eberch take a look at the “action code” that most of the Math Apps have which consist of function calls to procedures or modules defined in the Startup Code. The Startup Code can be accessed from the Edit menu. The function calls can be seen by right-clicking on the relevant component and selecting Edit Click Action.

Acer’s answer is correct and helpful. But for those just learning Maple, I wanted to provide some additional explanation.

Let’s talk more about building your own Math Apps

Building your own Math Apps can seem like something that involves complicated code and rare commands, but Daniel Skoog perfectly portrays an easy and straightforward method to do this in his latest webinar. He provides a clear definition of a Math App, a step-by-step approach to creating a Math App using the explore and quiz commands, and ways to share your applications with the Maple community. It is highly recommended that you watch the entire webinar if you would like to learn more about the core concepts of working with Maple, but you can find the Math App information starting at the 33:00 mark.

I hope that you find this useful. If there is a particular question on MaplePrimes that you would like further explained, please let me know. 

A wealth of knowledge is on display in MaplePrimes as our contributors share their expertise and step up to answer others’ queries. This post picks out one such response and further elucidates the answers to the posted question. I hope these explanations appeal to those of our readers who might not be familiar with the techniques embedded in the original responses.

Before I begin, a quick note that the content below was primarily created by one of our summer interns, Pia, with guidance and advice from me.

MaplePrimes member Thomas Dean wanted 1/2*x^(1/2) + 1/13*x^(1/3) + 1/26*x^(45/37)  to become  0.5*x^0.500000 + 0.07692307692*x^0.333333 + 0.03846153846*x^1.216216216  using the evalf command.

Here you can see the piece of code that Thomas Dean wrote in Maple:

eq:=1/2*x^(1/2) + 1/13*x^(1/3) + 1/26*x^(45/37);
evalf(eq);

Carl Love replied simply and effectively with a piece of code, using the evalindets command instead:

evalindets(eq, fraction, evalf);

As always, Love provided an accurate response, and it is absolutely correct. But for those just learning Maple, I wanted to provide some additional explanation.

The evalindets command, evalindets( expr, atype, transformer, rest ), is a particular combination of calls to eval and indets that allows you to efficiently transform all subexpressions of a given type by some algorithm. It encapsulates a common "pattern" used in expression manipulation and transformation.

Each subexpression of type atype is transformed by the supplied transformer procedure. Then, each subexpression is replaced in the original expression, using eval, with the corresponding transformed expression.

Note: the parameter restis an optional expression sequence of extra arguments to be passed to transformer. In this example it was not used.

I hope that you find this useful. If there is a particular question on MaplePrimes that you would like further explained, please let me know.