|\^/|     Maple V Release 3 (University of Florida)
._|\|   |/|_. Copyright (c) 1981-1994 by Waterloo Maple Software and the
 \  MAPLE  /  University of Waterloo. All rights reserved. Maple and Maple V
 <____ ____>  are registered trademarks of Waterloo Maple Software.
      |       Type ? for help.


PROBLEM CI(b) and C2.  I do this with Maple, so as to demonstrate some
commands.  However, almost all of the calculations I can do faster by hand.
For *large* matrices, however, using these Maple cmds is much better.

                                                          [ -1  -1 ]
                                                     B := [        ]
                                                          [  2  -4 ]

I'll use Id for the 2x2 identity matrix, and use BmxId to denote
	B minus x times Id
which is the matrix we use to compute the char.poly of B.
> Id := eye(2) : BmxId := B - x*Id : evalm(BmxId);
                                                  [ - 1 - x     -1   ]
                                                  [                  ]
                                                  [    2     - 4 - x ]

>  cpB := det(BmxId); factor(cpB);
                                                                     2
                                                   cpB := 6 + 5 x + x
                                                     (x + 3) (x + 2)

So the eigenvalues are -3 and -2.  Letting alpha be the more-positive, lets
compute vectors in the nullspaces of the corresponding matrices.  I'll let
Maple do this, since we did a nullspace calculation in part(a).

> alpha := -2: beta := -3: basisalpha := nullspace(B - alpha*Id);
  basisbeta := nullspace(B - beta*Id);

      basisalpha := {[ 1, 1 ]}   ,     basisbeta := {[ 1, 2 ]}

As we knew had to happen, each nullspace is 1-dimensional.  Lets call the eigenvectors
valpha and vbeta.  So
> valpha := convertvec(op(basisalpha)); vbeta := convertvec(op(basisbeta));

	            [ 1 ]	          [ 1 ]
          valpha := [   ]        vbeta := [   ]
                    [ 1 ]   , 	          [ 2 ]

Let EIG denote the eigenbasis {valpha, vbeta},  We now make the ChangeOfBasis
matrix, which converts vectors to the STD basis, from the EIGen basis.
>  COBtoSTDfromEIG := augment(valpha,vbeta);  # Maple's `concat' is faster.

                                                                  [ 1  1 ]
                                               COBtoSTDfromEIG := [      ]
                                                                  [ 1  2 ]

This is our M^(-1), though of course it depends on the particular eigenvectors
that I chose.  Lets compute M:
>  COBtoEIGfromSTD := inverse(COBtoSTDfromEIG) ;
                                                                 [  2  -1 ]
                                              COBtoEIGfromSTD := [        ]
                                                                 [ -1   1 ]

Finally, we compute the diagonal matrix, which is the linear trn. B, but written
relative to the eigenbasis EIG.
> diag := matrix(2,2,[alpha, 0 , 0 , beta]) ;
                                                           [ -2   0 ]
                                                   diag := [        ]
                                                           [  0  -3 ]

Let's check that conjugating the diagonal matrix *really yields* the original B.

> evalm(COBtoSTDfromEIG &* diag &* COBtoEIGfromSTD) , evalm(B);

                                                 [ -1  -1 ]  [ -1  -1 ]
                                                 [        ], [        ]
                                                 [  2  -4 ]  [  2  -4 ]

Ain't Science Wonnerful?

Now lets compute all the entries in B^(100).  Because I don't want Maple to expand out
alpha^(100), let me use symbolic names ALPHA and BETA for alpha^(100) and beta^(100).
Letting DIAG denote diag^(100), then,

> DIAG := matrix(2,2,[ALPHA, 0 , 0 , BETA]) ;
                                                         [ ALPHA    0  ]
                                                 DIAG := [             ]
                                                         [   0    BETA ]
Thus...
> BtoTheOneHundred := evalm(COBtoSTDfromEIG &* DIAG &* COBtoEIGfromSTD);

			       [  2 ALPHA - BETA    - ALPHA + BETA  ]
	   BtoTheOneHundred := [                                    ]
			       [ 2 ALPHA - 2 BETA  - ALPHA + 2 BETA ]

We can now plug in the correct values for ALPHA and BETA but -just for fun- let
us substitute *strings* in for ALPHA and BETA; this way, Maple will not try to
evaluate (-2)^100.

> ALPHA := `(-2)^100` : BETA := `(-3)^100` : map(eval,BtoTheOneHundred) ;

	      [  2 (-2)^100 - (-3)^100    - (-2)^100 + (-3)^100  ]
	      [                                                  ]
	      [ 2 (-2)^100 - 2 (-3)^100  - (-2)^100 + 2 (-3)^100 ]

The entry in position (2,1) is
> z := "[2,1];

                                              z := 2 (-2)^100 - 2 (-3)^100

Question for you:  Is z positive or negative?

#### End of File ####