MGM.03 Using Aligners, Stretchers and Hangers to Make 2D Matrices Do What You Want
 LITERACY

Needs["LinearAlgebra`MatrixManipulation`"];
Needs["Graphics`Colors`"];
Off[General::"spell"];
Off[General::"spell1"];
Off[ParametricPlot3D::"ppcom"];
Off[ParametricPlot::"ppcom"];
Off[Plot::"plnr"];
SetOptions[Limit, Analytic -> True];
$Pre = Chop;

CMView = {2.7, 1.6, 1.2};

Vector Drawer

\(\(\( (*\ \(\(:\)\(Date : \ \ Copyright\ 2001\)\), \ 
      Math\ Everywhere, \ \(\(Inc\)\(.\)\)\ 
*) \)\(
\)\( (*
Original\ Conception\ to\ create\ a\ vector\ drawer\ is\ due\ to\ Bill\ Davis . 
Current\ code\ is\ by\ Bruce\ \(\(Carpenter\)\(.\)\)
*) \)\(
\)\( (*\ \ \(\(\(:\)\(Drawbacks : \ \ Since\ the\ vectors\ are\ drawn\ out\ of\)\)\ 

      \ \ \ \ \ context\), \ 
      the\ shapes\ of\ the\ arrowheads\ are\ only\ 
\ \ \ \ \ correct\ with\ AspectRatio\ set\ to\ \(\(Automatic\)\(.\)\)
*) \)\)\)

BeginPackage["Vector3D`","Graphics`Colors`"];

Axes3D::usage = "Axes3D[a, b] creates a Graphics3D object of cartesian axes with x, y, and z running from -a/3 to a, and with axes labels b units beyond the tips of the axes.  Axes3D[a] is Axes3D[a, a/8].";

Perpend::usage = "Perpend[a] returns a unit vector which is perpendicular to the vector a.";

Arrow::usage = "Arrow[a] produces a 2 or 3 dimensional vector from the origin to a. Arrow[a, Tail -> tail] gives a vector from tail to a.";
	
Vector::usage = "Vector[a, b] gives a 2D or 3D vector from a to b.";

ArrowHead::usage = "ArrowHead[a, vec] produces an arrowhead with its tip placed at the point a, pointing in the direction of the vector vec.";

Tail::usage = "Tail -> point puts the tail of the vector at point.";

Norm::usage = "Norm[vec] returns the Euclidean length of vec.";

Normalize::usage = "Normalize[vec] returns a unit vector in the direction of vec, provided vec is nonzero.";

Aperture::usage = "Aperture is the ratio of the radius of the base to the length of the head of a vector.";

TipSize::usage = "TipSize specifies an absolute size for the inner tip length of the head of a vector.";

TipRatio::usage = "TipRatio is the ratio of the inner length of the arrowhead to the length of the shaft of a vector.";

HeadRatio::usage = "HeadRatio is the ratio of the outer length of the arrowhead to the length of the shaft of a vector.";

HeadSize::usage = "HeadSize specifies an absolute size for the head of a vector.";

ScaleFactor::usage = "ScaleFactor specifies the amount to scale a vector in length and may be either a number or a pure function.";

ZeroVectorPointSize::usage = "ZeroVectorPointSize is the size of the point used to represent a zero vector.";

Options[Vector] = Options[Arrow] = Options[ArrowHead] =
{HeadRatio -> 0.18, TipRatio -> 0.14, Aperture -> 0.3, ScaleFactor -> 1, HeadType -> Polygon, ShaftQ -> True, EdgesQ -> True, VectorColor -> RGBColor[0,0,1], ShaftWidth -> 0.005, ZeroVectorPointSize -> 0.01};
		
Begin["`Private`"];

SetOptions[ParametricPlot,AspectRatio -> Automatic];
SetOptions[Plot,AspectRatio -> Automatic];
SetOptions[Graphics,AspectRatio -> Automatic];

Axes3D[u_,v_] := 
      Graphics3D[{
            {Blue,Line[{{-u/3,0,0},{u,0,0}}]},
                    Text["x",{u + v,0,0}],
            {Blue,Line[{{0,-u/3,0},{0,u,0}}]},
                    Text["y",{0, u + v,0}],
            {Blue,Line[{{0,0,-u/3},{0,0,u}}]},
                    Text["z",{0,0,u + v}]}]; 
Axes3D[u_] := Axes3D[u,u/8];
				
Norm[a_?VectorQ] := N[Sqrt[a.a]];

Normalize[a_?VectorQ] := If[a.a == 0, a, a/Norm[a]];

Perpend[a_?VectorQ] := Normalize[{a[[2]],-a[[1]]}]/;Length[a]==2;

Perpend[a_?VectorQ]:=
    Normalize[If[a[[1]]==0,{1,0,0},{a[[2]],-a[[1]],0}]]/;
      Length[a]==3;
      
Base3D = Table[{Cos[2 k Pi/8.], Sin[2 k Pi/8.]},{k,0,8}]; 

Vector[from_?VectorQ, to_?VectorQ, opts___] := Module[
   {sq, sw, ht, hs, hr, tr, ap, sf, vc, zvps, diff = to - from, tip},
   {sq, sw, ht, hs, hr, ts, tr, ap, sf, vc, zvps} = {ShaftQ, ShaftWidth, HeadType, HeadSize, HeadRatio, TipSize, TipRatio, Aperture, ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts} /. Options[Vector];
   If[from==to, Return[Graphics[{PointSize[zvps],vc,Point[from]}]]];
   diff = If[NumberQ[N[sf]], sf diff, sf[diff]];
   tip = from + diff;
   If[NumberQ[hs], hr = hs/Norm[diff]; tr = 0.75 hr];
   If[NumberQ[ts], tr = ts/Norm[diff]];
   Graphics[{If[sq,{vc,Thickness[sw],Line[{from,tip - tr diff}]},{}],
      With[{trans = ap hr Norm[diff] Perpend[diff]},
      {vc, Thickness[sw], ht[{tip,
                   (tip - hr diff + trans),
                   (tip - tr diff),
                   (tip - hr diff - trans),tip}]}]}]
] /; Length[from]==Length[to]==2

Vector[from_?VectorQ, to_?VectorQ, opts___] := Module[
   {sq, eq, sw, hs, hr, tr,ap, sf, vc, zvps, diff = to - from, tip},
   {sq, eq, sw, hs, hr, ap, sf, vc, zvps} = {ShaftQ, EdgesQ, ShaftWidth, HeadSize, HeadRatio, Aperture, ScaleFactor, VectorColor, ZeroVectorPointSize} /. {opts} /. Options[Vector];
   If[from==to, Return[Graphics3D[{PointSize[zvps],vc,Point[from]}]]];
   diff = If[NumberQ[N[sf]], sf diff, sf[diff]];
   tip = from + diff;
   If[NumberQ[hs], hr = hs/Norm[diff]];
   tr = hr/2;
   Graphics3D[{If[sq,{vc,Thickness[sw],Line[{from,tip-tr diff}]},{}], If[eq, {}, EdgeForm[]], {SurfaceColor[vc],
      With[{temp = Perpend[diff]},
      Polygon[Append[#,tip]]& /@ Partition[(tip - hr diff + #)&/@((ap hr Norm[diff] Base3D) . {temp,Normalize[Cross[temp,diff]]}),2,1]]}}]
] /; Length[from]==Length[to]==3


Arrow[a_, Tail->b_, opts___] := Vector[b,a+b,opts]

Arrow[a_, opts___] := Vector[Table[0,{Length[a]}],a,opts]

ArrowHead[a_, b_, opts___] := Vector[a-b,a,ShaftQ->False,opts];

End[];

EndPackage[];
Null

Graphics`Colors`GosiaGreen = 
        RGBColor[0,  0.392187,  0];

ThreeAxes[u,v]

ThreeAxes[u_, v_] := 
        Graphics3D[{{Blue, Line[{{-u, 0, 0}, {u, 0, 0}}]}, 
            Text["x", {u + v, 0, 0}], {Blue, 
              Line[{{0, -u, 0}, {0, u, 0}}]}, 
            Text["y", {0, u + v, 0}], {Blue, 
              Line[{{0, 0, 0}, {0, 0, u}}]}, 
            Text["z", {0, 0, u + v}]}];
ThreeAxes[u_] := ThreeAxes[u, (u/8)];
ThreeAxes::"usage" = "ThreeAxes[a,b] makes a standard cartesian \
axis graphics object with x, y, and z running from -a to a, and with axis \
labels b units beyond the tips of the axes.  ThreeAxes[a] is \
ThreeAxes[a,a/8].";

What you should be able to handle when you are away from the machine.

L.1)

Here are the x and y axis unit vectors:

\(\(xyunits\  = \ 
        Show[
\ \ \ \ \ Arrow[{1, 0}, Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[{0, 1}, Tail -> {0, 0}, 
            VectorColor -> 
              Blue], \ 
\ \ \ PlotRange -> {{\(-1\), 1}, {\(-1\), 1}}, 
          Axes -> True, AxesLabel -> {"x", "y"}];\)\)

Here's a perpendicular frame:

s = Random[Real, {(π/16), 0.3 π}];
Clear[perpframe];
{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
            Sin[s + (π/2)]}};
frameplot = 
        Show[Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[perpframe[2], Tail -> {0, 0}, VectorColor -> Blue], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          PlotRange -> {{-1, 1}, {-1, 1}}, Axes -> True, 
          AxesLabel -> {"x", "y"}];

When you hit the x-y axis unit vectors with the hanger corresponding to the this perpendicular frame, you get one of the following outcomes:

\(\(original\  = \ 
        Show[
\ \ \ \ \ Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[perpframe[2], 
            Tail -> {0, 0}, 
            VectorColor -> 
              Blue], \ 
\ \ \ \ \ PlotRange -> {{\(-1\), 1}, {\(-1\), 1}}, 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Plot A", 
          DisplayFunction -> Identity];\)\)
\(\(xyunits\  = \ 
        Show[
\ \ \ \ \ Arrow[{1, 0}, Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[{0, 1}, Tail -> {0, 0}, 
            VectorColor -> 
              Blue], \ 
\ \ \ PlotRange -> {{\(-1\), 1}, {\(-1\), 1}}, 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Plot B", 
          DisplayFunction -> Identity];\)\)
Show[GraphicsArray[{original, xyunits}]];

The correct plot is Plot A.

L.2)

Here's a perpendicular frame:

s = Random[Real, {(π/16), 0.3 π}];
Clear[perpframe];
{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
            Sin[s + (π/2)]}};
frameplot = 
        Show[Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[perpframe[2], Tail -> {0, 0}, VectorColor -> Blue], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          PlotRange -> {{-1, 1}, {-1, 1}}, Axes -> True, 
          AxesLabel -> {"x", "y"}];

When you hit this perpendicular frame with the aligner corresponding to the same perpendicular frame, you get one of the following outcomes:

\(\(original\  = \ 
        Show[
\ \ \ \ \ Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[perpframe[2], 
            Tail -> {0, 0}, 
            VectorColor -> 
              Blue], \ 
\ \ \ \ \ PlotRange -> {{\(-1\), 1}, {\(-1\), 1}}, 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Plot A", 
          DisplayFunction -> Identity];\)\)
\(\(xyunits\  = \ 
        Show[
\ \ \ \ \ Arrow[{1, 0}, Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[{0, 1}, Tail -> {0, 0}, 
            VectorColor -> 
              Blue], \ 
\ \ \ PlotRange -> {{\(-1\), 1}, {\(-1\), 1}}, 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotLabel -> "Plot B", 
          DisplayFunction -> Identity];\)\)
Show[GraphicsArray[{original, xyunits}]];

The correct plot is Plot B.

L.3)

Agree or disagree:
When you hit a 2D perpendicular frame with a 2D matrix, you get another perpendicular frame.
Disagree.

L.4)

Here's a perpendicular frame

s = Random[Real, {-(π/3), 0.4 π}];
Clear[perpframe];
{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
            Sin[s + (π/2)]}};
frameplot = 
        Show[Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[perpframe[2], Tail -> {0, 0}, VectorColor -> Blue], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          PlotRange -> {{-1, 1}, {-1, 1}}, Axes -> True, 
          AxesLabel -> {"x", "y"}];

Here is an ellipse:

ParametricPlot[{1.5 Cos[t], 0.8 Sin[t]}, {t, 0, 2 Pi}, 
      PlotStyle -> Thickness[0.01], AxesLabel -> {"x", "y"}, 
      PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}];

When you hit this ellipse with the hanger corresponding to the perpendicular frame plotted above, you get one of the following outcomes:

\(\(frameplot\  = \ 
        Show[
\ \ \ \ \ Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[perpframe[2], 
            Tail -> {0, 0}, VectorColor -> Blue], 
          DisplayFunction -> Identity];\)\ 
\ \)
Cplot =  
        ParametricPlot[
          1.5 Cos[t] perpframe[1]  + 0.8 Sin[t] perpframe[2], {t, 0, 
            2 Pi}, PlotStyle -> Thickness[0.02], 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, 
          PlotLabel -> "Plot C", 
          DisplayFunction -> Identity];
Cplotframe  =  
        Show[Cplot, frameplot, DisplayFunction -> Identity];
\(\(Bplot\  = \ 
	
        ParametricPlot[
          1.5\ Cos[t]\ perpframe[2]\  + 0.8\ Sin[t]\ perpframe[1], {t, 0, 
            2\ Pi}, PlotStyle -> Thickness[0.02], 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{\(-1.5\), 1.5}, {\(-1.5\), 1.5}}, 
          PlotLabel -> "Plot B", 
          DisplayFunction -> Identity];\)\)
Bplotframe  =  
        Show[Bplot, frameplot, DisplayFunction -> Identity];
Aplot  =  
        ParametricPlot[{0.8 Cos[t] , 1.5 Sin[t]} , {t, 0, 2 Pi}, 
          PlotStyle -> Thickness[0.02], AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, 
          PlotLabel -> "Plot A", 
          DisplayFunction -> Identity];
Aplotframe  =  
        Show[Aplot, frameplot, DisplayFunction -> Identity];
Show[
        GraphicsArray[{Aplotframe, Bplotframe, Cplotframe}]];

The correct plot is Plot c.

L.5)

Here's a perpendicular frame shown with a certain ellipse:

s = Random[Real, {-(π/3), 0.4 π}];
Clear[perpframe];
{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
            Sin[s + (π/2)]}};
frameplot = 
        Show[Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[perpframe[2], Tail -> {0, 0}, VectorColor -> Blue], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          DisplayFunction -> Identity];
ellipse = 
        ParametricPlot[
          1.5 Cos[t] perpframe[1] + 0.8 Sin[t] perpframe[2], {t, 0, 
            2 π}, PlotStyle -> Thickness[0.01], 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, 
          DisplayFunction -> Identity];
Show[ellipse, frameplot, 
        DisplayFunction -> $DisplayFunction];

When you hit this ellipse with the aligner corresponding to the perpendicular frame plotted above, you get one of the following outcomes:

\(\(frameplot\  = \ 
        Show[
\ \ \ \ \ Arrow[perpframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
\ \ \ \ \ \ Arrow[perpframe[2], 
            Tail -> {0, 0}, VectorColor -> Blue], 
          DisplayFunction -> Identity];\)\ 
\ \)
Cplot =  
        ParametricPlot[
          1.5 Cos[t] perpframe[2]  + 0.8 Sin[t] perpframe[1], {t, 0, 
            2 Pi}, PlotStyle -> Thickness[0.02], 
          AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, 
          PlotLabel -> "Plot C", 
          DisplayFunction -> Identity];
Cplotframe  =  
        Show[Cplot, frameplot, DisplayFunction -> Identity];
\(\(Bplot\  = \ 
	
        ParametricPlot[{0.8\ Cos[t]\ , 1.5\ Sin[t]}, {t, 0, 2\ Pi}, 
          PlotStyle -> Thickness[0.02], AxesLabel -> {"x", "y"}, 
          PlotRange -> {{\(-1.5\), 1.5}, {\(-1.5\), 1.5}}, 
          PlotLabel -> "Plot B", 
          DisplayFunction -> Identity];\)\)
Bplotframe  =  
        Show[Bplot, frameplot, DisplayFunction -> Identity];
Aplot  =  
        ParametricPlot[{1.5 Cos[t] , 0.8 Sin[t]} , {t, 0, 2 Pi}, 
          PlotStyle -> Thickness[0.02], AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-1.5, 1.5}, {-1.5, 1.5}}, 
          PlotLabel -> "Plot A", 
          DisplayFunction -> Identity];
Aplotframe  =  
        Show[Aplot, frameplot, DisplayFunction -> Identity];
Show[
        GraphicsArray[{Aplotframe, Bplotframe, Cplotframe}]];

The correct plot is Plot A.

L.6)

Here's a 2D perpendicular frame 
{perpframe[1], 
          perpframe[2]} = {{((Sqrt[3])/2), (1/2)}, {-(1/2), ((Sqrt[3])/2)}}
Given that the hanger corresponding to this perpendicular frame is
          hanger=(({{a, b}, {c, d}})),
fill in the appropriate values: 
a = ((Sqrt[3])/2) 	b = -(1/2)
c = (1/2) 	d = ((Sqrt[3])/2)
Remember that perpframe[1], perpframe[2] are the two columns of the hanger matrix.

L.7)

Here's a 2D perpendicular frame:
{perpframe[1], 
          perpframe[2]} = {{(1/2), ((Sqrt[3])/2)}, {-((Sqrt[3])/2), (1/2)}}
Given that the aligner corresponding to this perpendicular frame is
           aligner=(({{a, b}, {c, d}})),
fill in the appropriate values: 
a = (1/2)		b = ((Sqrt[3])/2)
c = -((Sqrt[3])/2)	d = (1/2)
Remember that perpframe[1], perpframe[2] are the two rows of the aligner matrix.

L.8)

Here's a cleared 2D perpendicular frame:

{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {-Sin[s], Cos[s]}}

Here is a point in usual xy coordinates:

{0.3  Random[Integer, {1, 9}], 
      0.2  Random[Integer, {1, 9}]}

The perpendicular frame coordinates (for the perpendicular frame specified above)  {u,v} of this point are given by
u =  point.perpframe[1] = 2.4 Cos[s] + 0.2 Sin[s]
v = point.perpframe[2] = -2.4 Sin[s] + 0.2 Cos[s]

L.9)

Here's a cleared 2D perpendicular frame:

{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {-Sin[s], Cos[s]}}

Here is a point with usual xy coordinates:

\(\(
	{x, y}\  = {0.3\ \ Random[Integer, {1, 9}], 
        0.2\ \ Random[Integer, {1, 9}]}\)\)

Fill the blank below with either the word "aligner" or "hanger."
I can calculate the perpframe coordinates of this point by hitting {x,y} with the 
hanger  for this perpendicular frame.

Explanation:  Recall that a given perpframe and a point {x, y}

s = (π/8); {perpframe[1], 
        perpframe[
          2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], Sin[s + (π/2)]}} // 
        N;

{x, y} = {0.3, 1.2};

the coordinates in x-y are

{x, 
        y} = ({x , y} . {1, 0}) {1, 0} + ({x, y} . {0, 1}) {0, 
            1}

OR equivalently by

{x, y} = x {1, 0} + y {0, 1}

The coordinates in perpframe[1]-perpframe[2] are obtained by replacing {1,0} and {0,1} by perpframe[1] and perpframe[2] respectively

{u, v} = x perpframe[1] + y perpframe[2]

which is  is also obtained by hitting {x,y} with the hanger

hanger = 
        Transpose[{perpframe[1], 
            perpframe[2]}];

hanger . {x, y}

L.10)

Here's a cleared 2D perpendicular frame:

{perpframe[1], 
          perpframe[2]} = {{Cos[s], Sin[s]}, {-Sin[s], Cos[s]}}

Here is a point with usual perpframe coordinates:

\(\(
	{u, v}\  = {0.3\ \ Random[Integer, {1, 9}], 
        0.2\ \ Random[Integer, {1, 9}]}\)\)

Fill the blank below with either the word "aligner" or "hanger."
I can calculate the usual xy coordinates of this point by hitting {u,v} with the 
 aligner  for this perpendicular frame.
 
Explanation:  Recall that for a given perpframe and a point {u,v}

s = (π/8); 
    m = {perpframe[1], 
          perpframe[
            2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], Sin[s + (π/2)]}} // 
          N;

{u, v} = {2.4, 1.4};

the coordinates in perpframe are

{u, 
        v} = ({u, v} . perpframe[1]) 
          perpframe[1] + ({u, v} . perpframe[2]) perpframe[2]

The coordinates in x-y are obtained by replacing perpframe[1] and perpframe[2] by {1,0} and {0,1} respectively

{x, 
        y} = ({u, v} . perpframe[1]) {1, 
            0} + ({u, v} . perpframe[2]) {0, 1}

which is also obtained by hitting {u,v} with the aligner

aligner = {perpframe[1], 
          perpframe[2]};

aligner . {u, v}

L.11)

Here is a perpendicular frame and a curve:

s = Random[Real, {0.2, 1.5}];
Clear[perpframe];
{perpframe[1], perpframe[2]} = 
        N[{{Cos[s], Sin[s]}, {-Sin[s], Cos[s]}}];
frameplot = 
        Show[Table[
            Arrow[perpframe[k], Tail -> {0, 0}, 
              VectorColor -> Red], {k, 1, 2}], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
Clear[x, y, t];
{tlow, thigh} = {-(π/2), π};
{x[t_], y[t_]} = 
        t perpframe[1] + 
          (E^(-0.2 t)) Cos[4 t] perpframe[2];
curveplot = 
        ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, 
          AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
Show[curveplot, frameplot, 
        PlotRange -> {{-3, 3}, {-3, 3}}, 
        DisplayFunction -> $DisplayFunction];

Here is what you get when you hit this curve with a certain matrix A:

A  =  {perpframe[1], perpframe[2]};
\(\(hitcurveplot\  = \ 
        ParametricPlot[
          A . {x[t], y[t]}, {t, tlow, 
            thigh}, 
\ \ \ \ \ \ \ PlotStyle -> {{Thickness[0.01], Blue}}, 
          AxesLabel -> {"x", "y"}, 
\ \ \ \ \ \ \ \ DisplayFunction -> 
            Identity];\)\)
Show[hitcurveplot, frameplot, 
        PlotRange -> {{-3, 3}, {-3, 3}},  
        DisplayFunction -> $DisplayFunction];

Given that this matrix A is either the aligner or the hanger based on the plotted perpendicular frame, which is it:
The aligner?
The hanger?
It is the aligner.

L.12)

Here is a perpendicular frame and a curve:

s = Random[Real, {0.2, 0.6}];
Clear[perpframe];
{perpframe[1], perpframe[2]} = 
        N[{{Cos[s], Sin[s]}, {-Sin[s], Cos[s]}}];
frameplot = 
        Show[Table[
            Arrow[perpframe[k], Tail -> {0, 0}, 
              VectorColor -> Red], {k, 1, 2}], 
          Graphics[Text["perpframe[1]", 0.4 perpframe[1]]], 
          Graphics[Text["perpframe[2]", 0.7 perpframe[2]]], 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
Clear[x, y, t];
{tlow, thigh} = {-(π/2), π};
{x[t_], y[t_]} = {t, (E^(-0.2 t)) Cos[4 t]};
curveplot = 
        ParametricPlot[{x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, 
          AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
Show[curveplot, frameplot, 
        PlotRange -> {{-3, 3}, {-3, 3}}, 
        DisplayFunction -> $DisplayFunction];

Here is what you get when you hit this curve with a certain matrix A:

A  =  Transpose[{perpframe[1], perpframe[2]}];
\(\(hitcurveplot\  = \ 
        ParametricPlot[
          A . {x[t], y[t]}, {t, tlow, 
            thigh}, 
\ \ \ \ \ \ \ PlotStyle -> {{Thickness[0.015], Blue}}, 
          AxesLabel -> {"x", "y"}, 
\ \ \ \ \ \ \ \ DisplayFunction -> 
            Identity];\)\)
Show[hitcurveplot, frameplot, 
        PlotRange -> {{-3, 3}, {-3, 3}},  
        DisplayFunction -> $DisplayFunction];

Given that this matrix A is either the aligner or the hanger based on the plotted perpendicular frame, which is it:
The aligner?
The hanger?
It is the hanger.

L.13)

Here's a random 2D matrix 
              A = hanger.stretcher.aligner 
made through matrix maker ingredients:

Clear[alignerframe];
s = Random[Real, {-1.5, 1.5}];
{alignerframe[1], alignerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
aligner = {alignerframe[1], alignerframe[2]};
{xstretch, ystretch} = {0.5 Random[Integer, {5, 10}], 
          0.2 Random[Integer, {5, 10}]};
stretcher = {{xstretch, 0}, {0, ystretch}};
Clear[hangerframe];
s = Random[Real, {-1.5, 1.5}];
{hangerframe[1], hangerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
hanger = Transpose[{hangerframe[1], hangerframe[2]}];
A = hanger . (stretcher . aligner);
MatrixForm[A]

When you hit the unit circle centered at {0,0} with A you get this ellipse:

Clear[x, y, t];
{x[t_], y[t_]} = {Cos[t], Sin[t]};
{tlow, thigh} = {0, 2 π};
ranger = 1.2 Max[{xstretch, ystretch, 1}];
ellipseplot = 
        ParametricPlot[A . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, 
          PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
          AxesLabel -> {"x", "y"}];

Agree or disagree with each of the following statements:

1) When you change the stretcher by going with new stretch factors and replot, you are guaranteed to get the same physical ellipse as plotted above.
Agree...............   Disagree ∴

2) When you change the aligner by going with a different aligner frame and replot, you are guaranteed to get the same physical ellipse as plotted above.
Agree ∴	     Disagree............... 

3) When you change the hanger by going with a different hanger frame and replot, you are guaranteed to get the same physical ellipse as plotted above.
Agree...............   Disagree ∴

L.14.i)

Here's a random 2D matrix 
              A = hanger.stretcher.aligner 
made through matrix maker ingredients.
The aligner is:

Clear[alignerframe];
s = Random[Real, {-1.5, 1.5}];
{alignerframe[1], alignerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
aligner = {alignerframe[1], alignerframe[2]};
MatrixForm[aligner]

The stretcher is:

{xstretch, ystretch} = {0.5 Random[Integer, {5, 10}], 
          0.2 Random[Integer, {5, 10}]};
stretcher = {{xstretch, 0}, {0, ystretch}};
MatrixForm[stretcher]

The hanger is:

Clear[hangerframe];
s = Random[Real, {-1.5, 1.5}];
{hangerframe[1], hangerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
hanger = Transpose[{hangerframe[1], hangerframe[2]}];
MatrixForm[hanger]

The resulting matrix 
             A = hanger.stretcher.aligner 
is:

A = hanger . (stretcher . aligner); MatrixForm[A]

When you hit the unit circle centered at {0,0} with A you get this ellipse:

Clear[x, y, t];
{x[t_], y[t_]} = {Cos[t], Sin[t]};
{tlow, thigh} = {0, 2 π};
ranger = 1.2 Max[{xstretch, ystretch, 1}];
ellipseplot = 
        ParametricPlot[A . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, 
          PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
          AxesLabel -> {"x", "y"}];

Look at this plot of the hanger frame and its negatives:

Show[ellipseplot, 
        Arrow[hangerframe[1], Tail -> {0, 0}, VectorColor -> Red], 
        Arrow[-hangerframe[1], Tail -> {0, 0}, 
          VectorColor -> Red], 
        Arrow[hangerframe[2], Tail -> {0, 0}, VectorColor -> Red], 
        Arrow[-hangerframe[2], Tail -> {0, 0}, 
          VectorColor -> Red], 
        Graphics[Text["hangerframe[1]", 0.6 hangerframe[1]]], 
        Graphics[Text["hangerframe[2]", 0.6 hangerframe[2]]], 
        Axes -> True, AxesLabel -> {"x", "y"}, 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "hanger frame"];

Do you think the outcome is an accident? 
Yes.......
No ∴  The unit cirlce was first hit by the aligner which aligned it to the x and y axis. Then it was hit by the stretcher which expanded the unit circle to it currently length. At this point, it was hit by the hanger which rotated the ellipse to it's new location.

L.14.ii)

Stay with the same set up as in part i) and look at this plot in which the unit hanger frame vectors have been multiplied by their associated stretch factors:

lastplot = 
        Show[ellipseplot, 
          Arrow[xstretch hangerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-xstretch hangerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[ystretch hangerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-ystretch hangerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Graphics[
            Text["hangerframe[1]", 0.6 xstretch hangerframe[1]]], 
          Graphics[
            Text["hangerframe[2]", 0.6 ystretch hangerframe[2]]], 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-ranger, ranger}, {-ranger, 
                ranger}}];

Do you think the outcome is an accident? 
Yes.........
No ∴
If not, why not?
The unit circle had radius of one before being hit by the stretcher, so did the hanger frame.  Therefore, they had to come out to the same length.  They both had the same radius/length to begin with, and they were hit by the same stretcher, the outcome had to be the same.

L.14.iii)

Here's another look at the plot in part ii) above:

Show[lastplot];

And look at the stretch factors used to make A:

{xstretch, ystretch}

Fill the blanks.
The length of the long axis of this ellipse measures out to 2 * 4.5 = 9
The length of the short axis of this ellipse measures out to 2 * 1.4 = 2.8
The area enclosed by this ellipse measures out to 4.5 * 1.4 * π = 6.3 π

L.15)

For what kind of perpendicular frames is the corresponding hanger guaranteed to be a rotation matrix?
Right hand perpendicular frames
For what kind of perpendicular frames is the corresponding aligner guaranteed to be a rotation matrix?
Right hand perpendicular frames

L.16)

Go with the hanger and the aligner corresponding to a given 2D perpendicular frame.
When you multiply out 
            hanger . aligner, 
you get
             hanger . aligner =(({{1, 0}, {0, 1}})).
(Fill the boxes.)

L.17)

If (({{a, b}, {c, d}})) is the aligner corresponding to a given perpendicular frame, then the hanger corresponding to the same perpendicular frame is  hanger = (({{a, c}, {b, d}})).

L.18)

You are given a perpendicular frame {perpframe[1], perpframe[2]}. Explain how you go about making a matrix A so that
          A . perpframe[1] = 3.2 perpframe[1]
and
          A . perpframe[2] = 0.5 perpframe[2].

Remember that when we make a matrix with matrix maker ingredients:
aligner,stretcher,hanger, then we are guaranteed that
A. alignerframe[1]= xstretch hangerframe[1]
and
A. alignerframe[2]= ystretch hangerframe[2]
We can arrange for this by going with:
alignerframe = the given perpendicular frame
hangerframe = the same given perpendicular frame
xstretch = 3.2,
and
ystretch = 0.5.
The Matrix A we are after is computed below. We pick any value for s:

s = (π/8); {perpframe[1], 
        perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
          Sin[s + (π/2)]}};

Clear[alignerframe];
{alignerframe[1], alignerframe[2]} = {perpframe[1], 
          perpframe[2]};
aligner = {alignerframe[1], 
          alignerframe[2]};

    
{xstretch, ystretch} = {3.2, 0.5};
stretcher = {{xstretch, 0}, {0, 
            ystretch}};

    
Clear[hangerframe];
{hangerframe[1], hangerframe[2]} = {perpframe[1], 
          perpframe[2]};
hanger = 
        Transpose[{hangerframe[1], hangerframe[2]}];

    
A = 
        hanger . stretcher . aligner // 
          FullSimplify;
MatrixForm[A]

A . perpframe[1] == 3.2 perpframe[1]
A . perpframe[2] == 0.5 perpframe[2]

L.19)

You are given a perpendicular frame {perpframe[1], perpframe[2]}. Explain how you  go about making a matrix A so that
          A . perpframe[1] = 0.7 perpframe[2]
and
          A . perpframe[2] = 1.3 perpframe[1].
Remember that when we make a matrix with matrix maker ingredients:
aligner,stretcher,hanger, then we are guaranteed that
A. alignerframe[1]= xstretch hangerframe[1]
and
A. alignerframe[2]= ystretch hangerframe[2]
We can arrange for this by going with:
alignerframe = the given perpendicular frame
hangerframe = the same given perpendicular frame
xstretch = 0.7,
and
ystretch = 1.3.
The Matrix A we are after is computed below.  We pick any value for s:

s = (π/8); {perpframe[1], 
        perpframe[2]} = {{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
          Sin[s + (π/2)]}};

Clear[alignerframe];
{alignerframe[1], alignerframe[2]} = {perpframe[1], 
          perpframe[2]};
\(\(aligner = {alignerframe[1], 
          alignerframe[2]};\)
\)
{xstretch, ystretch} = {0.7, 1.3};
stretcher = {{xstretch, 0}, {0, 
            ystretch}};

Clear[hangerframe];
{hangerframe[1], hangerframe[2]} = {perpframe[2], 
          perpframe[1]};
\(\(hanger = 
        Transpose[{hangerframe[1], 
            hangerframe[2]}];\)
\)
A = hanger . stretcher . aligner;
MatrixForm[A]

A . perpframe[1] == 0.7  perpframe[2]
A . perpframe[2] == 1.3 perpframe[1]

L.20)

When you are making a matrix 
           A = hanger.stretcher.aligner,
what do you do so to be sure that A is invertible?
We can go with any aligner frame and any hanger frame we like, but we have to make
xstretch AND ystretch different from 0.

L.21)

You are given a line through {0, 0} in the direction of a unit vector{a, b}.
Define ( by filling the boxes) 
            aligner =(({{a, b}, {-b, a}})), 
            stretcher = (({{1.0, 0}, {0, 0.0}}))  and 
            hanger =(({{a, -b}, {b, a}}))
so that when you hit any {x, y} with 
            A = hanger . stretcher . aligner, 
you get the point on the line closest to {x, y}.

Tip: The vector {-b, a} is a unit vector perpendicular to the line.

L.22)

You make a 2D matrix A by choosing a perpendicular frame to define your aligner, choosing another perpendicular frame for your hanger and two stretch factors xstretch and ystretch and then putting

             A =  hanger.(({{xstretch, 0}, {0, ystretch}})). aligner.
             
Using this, you can compute (A^(t ))via the formula:

a)  (A^t) =  aligner.(({{xstretch, 0}, {0, ystretch}})). hanger    
        
b)  (A^t) =  (hanger^t).(({{ystretch, 0}, {0, xstretch}})). (aligner^t)

c)  (A^t) =  (aligner^t).(({{ystretch, 0}, {0, xstretch}})). (hanger^t)      

d)  (A^t) =  (aligner^t).(({{xstretch, 0}, {0, ystretch}})). (hanger^t)

My choice is d

L.23)

You make a 2D matrix A by choosing a perpendicular frame to define your aligner, choosing another perpendicular frame for your hanger and two stretch factors xstretch and ystretch and then putting

             A =  hanger.(({{xstretch, 0}, {0, ystretch}})). aligner.
             
Using this, you can compute (A^(-1 ))via the formula:

a)  (A^(-1)) =  aligner.(({{(1/xstretch), 0}, {0, (1/ystretch)}})). hanger       
b)  (A^(-1)) =  (hanger^t).(({{(1/xstretch), 0}, {0, (1/ystretch)}})). (aligner^t)
 
c)  (A^(-1)) =  (aligner^t).(({{(1/ystretch), 0}, {0, (1/xstretch)}})). (hanger^t)    
d)  (A^(-1)) =  (aligner^t).(({{(1/xstretch), 0}, {0, (1/ystretch)}})). (hanger^t)

My choice is d

L.24)

You make a 2D matrix A by choosing a perpendicular frame to define your aligner, choosing another perpendicular frame for your hanger and two stretch factors xstretch and ystretch and the putting

             A =  aligner.(({{xstretch, 0}, {0, ystretch}})). hanger.
             
If  xstretch ≠ 0  and  ystretch ≠ 0 , then you are guaranteed that given any 2D vector Y, there is exactly one 2D vector X with A . X = Y.
Agree ∴

L.25.i)

Here's a random matrix made with matrix maker ingredients

Clear[alignerframe];
s  =  Random[Real, {-Pi/2, Pi/2}];
\(\({alignerframe[1], 
          alignerframe[
            2]}\  = \ 
\ \ \ \ \ \ \ \ \ \ \ N[{{Cos[s], 
              Sin[s]}, {Cos[s\  + \ Pi/2], Sin[s\  + \ Pi/2]}}];\)\)
\(\(aligner\  = \ {alignerframe[1], alignerframe[2]};\)
\)
{xstretch, ystretch}  =  {0.5 Random[Integer, {4, 8}], 
          0.2 Random[Integer, {3, 7}]};
\(\(stretcher\  = \ {{xstretch, 0}, {0, ystretch}};\)
\)
Clear[hangerframe];
s  =  Random[Real, {-Pi/2, Pi/2}];;
\(\({hangerframe[1], 
          hangerframe[
            2]}\  = \ 
\ \ \ \ \ \ \ \ \ \ \ N[{{Cos[s], 
              Sin[s]}, {Cos[s\  + \ Pi/2], Sin[s\  + \ Pi/2]}}];\)\)
hanger  =  Transpose[{hangerframe[1], hangerframe[2]}];
A  =  hanger . stretcher . aligner;
MatrixForm[A]

Here are the ellipses you get what you get when you hit the unit circle centered at {0, 0} with this matrix and its inverse:

Clear[x, y, t, s];
{tlow, thigh} = {0, 2 π};
{x[t_], y[t_]} = {Cos[t], Sin[t]};
Clear[hitplotter, hitpointplotter, pointcolor, actionarrows, 
        matrix2D];
Ahit = 
        ParametricPlot[A . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.012], Blue}}, 
          AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
invAhit = 
        ParametricPlot[Inverse[A] . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
          AxesLabel -> {"x", "y"}, 
          DisplayFunction -> Identity];
Show[Ahit, invAhit, PlotRange -> All, 
        DisplayFunction -> $DisplayFunction];

Put
      a = measurement of area enclosed by one of these ellipses
      b =   measurement of area enclosed by the other ellipse .
Without getting your hands dirty, calculate the product 

 Remember :          A =  hanger.(({{xstretch, 0}, {0, ystretch}})). aligner     and      (A^(-1)) =  (aligner^t).(({{(1/xstretch), 0}, {0, (1/ystretch)}})). (hanger^t).  The area of the first ellipse is 
 a=xstretch * ystretch*π   and of the second ellipse is b= (1/xstretch)*(1/ystretch)*π.  Their product a*b= (π^2).

L.25.ii)

The stretch factors used to make the matrix in part i) are:

{xstretch, ystretch}

Use what you see to measure the area enclosed by each ellipse.
The length of the long axis of the blue ellipse measures out to 2 * 3.5 = 7
The length of the short axis of the blue ellipse measures out to 2 * 1.0 = 2.0
The area enclosed by the blue ellipse measures out to 3.5 * 1 * π = 3.5 π

The length of the long axis of the red ellipse measures out to 2 * 1/3.5 = 0.571
The length of the short axis of the red ellipse measures out to 2 * 1/1.0 = 2.0
The area enclosed by  the red ellipse measures out to (1/3.5) * (1/1) * π = 0.286 π

L.26.i)

Here's a random matrix made with matrix maker ingredients

Clear[alignerframe];
s  =  Random[Real, {-Pi/2, Pi/2}];
\(\({alignerframe[1], 
          alignerframe[
            2]}\  = \ 
\ \ \ \ \ \ \ \ \ \ \ N[{{Cos[s], 
              Sin[s]}, {Cos[s\  + \ Pi/2], Sin[s\  + \ Pi/2]}}];\)\)
\(\(aligner\  = \ {alignerframe[1], alignerframe[2]};\)
\)
{xstretch, ystretch}  =  {0.4 Random[Integer, {3, 5}], 
          0.3 Random[Integer, {1, 3}]};
\(\(stretcher\  = \ {{xstretch, 0}, {0, ystretch}};\)
\)
Clear[hangerframe];
s  =  Random[Real, {-Pi/2, Pi/2}];;
\(\({hangerframe[1], 
          hangerframe[
            2]}\  = \ 
\ \ \ \ \ \ \ \ \ \ \ N[{{Cos[s], 
              Sin[s]}, {Cos[s\  + \ Pi/2], Sin[s\  + \ Pi/2]}}];\)\)
hanger  =  Transpose[{hangerframe[1], hangerframe[2]}];
A  =  hanger . stretcher . aligner;
MatrixForm[A]

Here is the square with corners at {-1,-1}, {1,-1},{1,1}, and {-1,1}:

Show[
      Graphics[{Thickness[0.01], Blue, 
          Line[{{-1, -1}, {1, -1}, {1, 1}, {-1, 1}, {-1, 
                -1}}]}], PlotRange -> All, Axes -> True, 
      AxesLabel -> {"x", "y"}, PlotLabel -> "Before"];

Here are the parallelograms you get what you get when you hit this square with this matrix and its transpose:

Ahit  =  
        Graphics[{Thickness[0.01], Red, 
            Line[{A . {-1, -1}, A . {1, -1}, A . {1, 1}, 
                A . {-1, 1}, A . {-1, -1}}]}];
B  =  Transpose[A];
\(\(transAhit\  = \ \ Graphics[{Thickness[0.01], Blue, 
            Line[{B . {\(-1\), \(-1\)}, B . {1, \(-1\)}, B . {1, 1}, 
                B . {\(-1\), 1}, B . {\(-1\), \(-1\)}}]}];\)
\)
\(\(Show[Ahit, transAhit, PlotRange -> All, 
\ 
\ \ \ \ \ Axes -> True, 
        AxesLabel -> {"x", "y"}];\)\)

Express the measurement of area enclosed by one of these parallelograms in terms of the measurement of the area enclosed by the other.

EQUAL.   Remember :          A =  hanger.(({{xstretch, 0}, {0, ystretch}})). aligner     and   (A^t) =  (aligner^t).(({{xstretch, 0}, {0, ystretch}})). (hanger^t).  Area = determinant of each matrix = 
 xstretch * ystretch for both cases.

L.26.ii)

The stretch factors used to make the matrix in part i) are:

{xstretch, ystretch}

Use what you see to measure the area enclosed by each parallelogram.
It is easy to calculate  1.6 *  0.3 =  0.48. Needless to say that exact the same calculation applies to the other parallelogram. They have
the same area.

L.27.i)

Here's a random 2D matrix 
              A = hanger.stretcher.aligner 
made through matrix maker ingredients.
The aligner is:

Clear[alignerframe];
s = Random[Real, {-1.5, 1.5}];
{alignerframe[1], alignerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
aligner = {alignerframe[1], alignerframe[2]};
MatrixForm[aligner]

The stretcher is:

{xstretch, ystretch} = {0.5 Random[Integer, {5, 10}], 
          0.2 Random[Integer, {5, 10}]};
stretcher = {{xstretch, 0}, {0, ystretch}};
MatrixForm[stretcher]

The hanger is:

Clear[hangerframe];
s = Random[Real, {-1.5, 1.5}];
{hangerframe[1], hangerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
hanger = Transpose[{hangerframe[1], hangerframe[2]}];
MatrixForm[hanger]

The resulting matrix 
             A = hanger.stretcher.aligner 
is:

A = hanger . (stretcher . aligner); MatrixForm[A]

When you hit the unit circle centered at {0,0} with (A^t) you get this ellipse:

Clear[x, y, t];
{x[t_], y[t_]} = {Cos[t], Sin[t]};
{tlow, thigh} = {0, 2 π};
ranger = 1.2 Max[{xstretch, ystretch, 1}];
ellipseplot = 
        ParametricPlot[Transpose[A] . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, 
          PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
          AxesLabel -> {"x", "y"}];

Look at this plot of the aligner frame and its negatives:

Show[ellipseplot, 
        Arrow[alignerframe[1], Tail -> {0, 0}, VectorColor -> Red], 
        Arrow[-alignerframe[1], Tail -> {0, 0}, 
          VectorColor -> Red], 
        Arrow[alignerframe[2], Tail -> {0, 0}, VectorColor -> Red], 
        Arrow[-alignerframe[2], Tail -> {0, 0}, 
          VectorColor -> Red], 
        Graphics[Text["alignerframe[1]", 0.6 alignerframe[1]]], 
        Graphics[Text["alignerframe[2]", 0.6 alignerframe[2]]], 
        Axes -> True, AxesLabel -> {"x", "y"}, 
        PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
        PlotLabel -> "aligner frame"];

Do you think the outcome is an accident? 
Yes.......
No ∴
If not, explain your response.
We multiplied the unit circle times the TRANSPOSE of the original matrix.  In this case the aligner becomes the hanger frame.

L.27.ii)

Stay with the same set up as in part i) and look at this plot in which the unit hanger frame vectors have been multiplied by their associated stretch factors:

lastplot = 
        Show[ellipseplot, 
          Arrow[xstretch alignerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-xstretch alignerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[ystretch alignerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-ystretch alignerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Graphics[
            Text["alignerframe[1]", 0.6 xstretch alignerframe[1]]], 
          Graphics[
            Text["alignerframe[2]", 0.6 ystretch alignerframe[2]]], 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotRange -> {{-ranger, ranger}, {-ranger, 
                ranger}}];

Do you think the outcome is an accident? 
Yes.........
No ∴
If not, explain your response.

L.27.iii)

Here's another look at the plot in part ii) above:

Show[lastplot];

And look at the stretch factors used to make A:

{xstretch, ystretch}

Fill the blanks.
The length of the long axis of this ellipse measures out to 2 * 5.0 = 10
The length of the short axis of this ellipse measures out to 2 * 1.6 = 3.2
The area enclosed by this ellipse measures out to 5.0 * 1.6 * π = 8 π

L.28.i)

Here's a random 2D matrix 
              A = hanger.stretcher.aligner 
made through matrix maker ingredients.
The aligner is:

Clear[alignerframe];
s = Random[Real, {-1.5, 1.5}];
{alignerframe[1], alignerframe[2]} = 
        N[{{Cos[s], Sin[s]}, {Cos[s + (π/2)], 
              Sin[s + (π/2)]}}];
aligner = {alignerframe[1], alignerframe[2]};
MatrixForm[aligner]

The stretcher is:

{xstretch, ystretch} = {0.5 Random[Integer, {1, 3}], 
        0.4 Random[Integer, {1, 2}]}; stretcher = {{xstretch, 0}, {0, ystretch}}; MatrixForm[stretcher]

The hanger is:

\(Clear[hangerframe]; 
s = Random[Real, {\(-1.5\), 1.5}]; 

    \({hangerframe[1], hangerframe[2]} = 
      N[{{Cos[s], Sin[s]}, {Cos[s + π\/2], Sin[s + π\/2]}}]; \)\)hanger = Transpose[{hangerframe[1], hangerframe[2]}]; MatrixForm[hanger]

The resulting matrix 
             A = hanger.stretcher.aligner 
is:

A = hanger . (stretcher . aligner); MatrixForm[A]

When you hit the unit circle centered at {0,0} with (A^(-1)) you get this ellipse:

Clear[x, y, t];
{x[t_], y[t_]} = {Cos[t], Sin[t]};
{tlow, thigh} = {0, 2 π};
ranger = 1.2 Max[{xstretch, ystretch, 1}];
ellipseplot = 
        ParametricPlot[Inverse[A] . {x[t], y[t]}, {t, tlow, thigh}, 
          PlotStyle -> {{Thickness[0.01], Blue}}, PlotRange -> All, 
          AxesLabel -> {"x", "y"}];

Look at this plot of the aligner frame and its negatives:

lastplot = 
        Show[ellipseplot, 
          Arrow[alignerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-alignerframe[1], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[alignerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Arrow[-alignerframe[2], Tail -> {0, 0}, 
            VectorColor -> Red], 
          Graphics[Text["alignerframe[1]", 0.6 alignerframe[1]]], 
          Graphics[Text["alignerframe[2]", 0.6 alignerframe[2]]], 
          Axes -> True, AxesLabel -> {"x", "y"}, 
          PlotRange -> All, 
          PlotLabel -> "aligner frame"];

Do you think the outcome is an accident? 
Yes.......
No ∴
If not, explain your response.  See 27i for analogous reasons.

L.28.ii)

Here's another look at the plot in part i) above:

Show[lastplot, PlotLabel -> None];

And look at the stretch factors used to make A:

{xstretch, ystretch}

Fill the blanks.
The length of the long axis of this ellipse measures out to 2 * 1.5 = 3.0
The length of the short axis of this ellipse measures out to 2* 0.8 = 1.6
The area enclosed by this ellipse measures out to 1.5 * 0.8 * π = 1.2 π