DE.07 Eigenvectors and Eigenvalues for Linear Systems
 BASICS

Needs["Graphics`Colors`"];
Needs["Graphics`FilledPlot`"];

If[MemberQ[{"Global`","Graphics`Common`GraphicsCommon`","Vector3D`"}, 
    Context[ScaleFactor]],Remove["*`ScaleFactor"]];
<<"Graphics`Legend`";
<<"Graphics`Common`GraphicsCommon`";
Remove["*`ScaleFactor"];
Graphics`Colors`GosiaGreen=RGBColor[0, 0.392187, 0];
Off[General::spell];
Off[General::spell1];
Off[ParametricPlot3D::ppcom];
Off[ParametricPlot::ppcom];
Off[Plot::plnr];
Needs["Calculus`Master`"];
Off[Unique::"usym"];
SetOptions[Limit,Analytic->True];

CMView = {2.7, 1.6, 1.2};

Off[Graphics::gpt]

New Vector Drawers

(* :Title:  NewVectorDraw  *)
(* :Author: Bruce Carpenter *)
(* :Summary:  Construct 2 and 3 dimensional vectors,
     arrows, and arrowheads as graphics 
     objects.
*)
(* :Date:  Copyright 1997, Math Everywhere, Inc. 
*)
(*  :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},{0,a[[3]],-a[[2]]}]]/;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

VectorField and Phase Lines

(*  :Title: VectorAndPhase.m  *)

(*  :Author:  Bill Davis  *)

(*  :Dates:  about March, 1996 *)

(*  :Drawbacks:  I wish someone serious would come and turn these into
                 Really carefully done packages.  *)

BeginPackage["PhaseStuff`","Vector3D`",
		"Utilities`FilterOptions`"];

PhaseLine::usage = "PhaseLine[fcn,{var,a,b},tint,pos]
	makes a vertical phase line for the function, fcn, of the variable, var,
	for the variable going from a to b, with 
	a color given by tint,  at the x-coordinate pos.";
	
PhaseLine3D::usage = "PhaseLIne3D[fcn,{var,a,b},tint,loc]
	makes a vertical phase line for the function, fcn, of the variable, var,
	for the variable going from a to b, with 
	a color given by tint, and base point at loc = {x,y}";
	
VectorField::usage = "VectorField[{function,{var1,a,b,space1},{var2,c,d,space2}]
	will make a vector field of normalized vectors, colored by
	magnitude, for the function of the variables on the
	range {r1,r2} with spacing between points given by 
	{space1, space2}.  If a single function of a single variable is given,
	the vector field {1,f} will be plotted.";
	
StikPikXZ::usage = "StikPikXZ[picture,a:_0] takes a 2 dimensional
	Mathematica picture and embeds it on the XZ plane at y = a.  
	Some optional characteristics of the graphs are lost in the 
	process.  StikPikYZ and StikPikXZ are similar.";
	
StikPikYZ::usage = "StikPikYZ[picture,a:_0] takes a 2 dimensional
	Mathematica picture and embeds it on the XZ plane at y = a.  
	Some optional characteristics of the graphs are lost in the 
	process.  StikPikYZ and StikPikXZ are similar.";
	
StikPikXY::usage = "StikPikXY[picture,a:_0] takes a 2 dimensional
	Mathematica picture and embeds it on the XZ plane at y = a.  
	Some optional characteristics of the graphs are lost in the 
	process.  StikPikYZ and StikPikXZ are similar.";
	
Begin["`Private`"];	

PhaseLine[fcn_,{var_,a_,b_},tint_,pos_:0] := 
	Module[{len,len1,k,zset,zero,zero1,signs,stick,dots,pointers},
	zset = Solve[fcn==0,var];
	zero = If[Length[zset]==0,{},var/.zset];
	zero = Sort[zero];
	zero = Select[zero,((# >= a)&&(# <= b))&];
	zero1 = Sort[Union[zero,{a,b}]];
	len = Length[zero];
	len1 = Length[zero1];
	signs = Table[Sign[fcn/.var->((zero1[[k+1]] + zero1[[k]])/2)],
		{k,1,len1-1}];
	stick = {Thickness[0.007],Line[{{pos,a},{pos,b}}]};
	dots = Point[{pos,#}]&/@zero;
	dots = Join[{PointSize[0.05],tint},dots];
	heads = Table[MakeHead[zero1[[k]],zero1[[k+1]],pos,
		signs[[k]],b-a,tint],{k,1,len1-1}];
	Return[{Graphics[Join[{tint},stick,dots]],heads}]
		]
		
MakeHead[a_,b_,c_,s_,slen_,tint_] := Module[{u,v,w},
	u = Min[2(b-a),3/4 slen];
	Return[ArrowHead[{c,a(.5-s/5)+b(.5+s/5)},
		{0,s u},VectorColor->tint]]]
		
PhaseLine3D[fcn_,{var_,a_,b_},tint_,pos_:{0,0}] := 
	Module[{len,len1,k,zset,zero,zero1,signs,stick,dots,pointers},
	zset = Solve[fcn==0,var];
	zero = If[Length[zset]==0,{},var/.zset];
	zero = Sort[zero];
	zero = Select[zero,((# >= a)&&(# <= b))&];
	zero1 = Sort[Union[zero,{a,b}]];
	len = Length[zero];
	len1 = Length[zero1];
	signs = Table[Sign[fcn/.var->((zero1[[k+1]] + zero1[[k]])/2)],
		{k,1,len1-1}];
	stick = {Thickness[0.007],Line[{{pos[[1]],pos[[2]],a},
		{pos[[1]],pos[[2]],b}}]};
	dots = Point[{pos[[1]],pos[[2]],#}]&/@zero;
	dots = Join[{PointSize[0.03],tint},dots];
	heads = Table[MakeHead3D[zero1[[k]],zero1[[k+1]],pos,
		signs[[k]],b-a,tint],{k,1,len1-1}];
	Return[{Graphics3D[Join[{tint},stick,dots]],heads}]
		]
		
MakeHead3D[a_,b_,c_,s_,slen_,tint_] := Module[{u,v,w},
	u = Min[2(b-a),1/2 slen];
	Return[ArrowHead[{c[[1]],c[[2]],a(.5-s/5)+b(.5+s/5)},
		{0,0,s u},VectorColor->tint]]]
		
		
VectorField[function_List,{var1_,a_,b_,sp1_:1},{var2_,c_,d_,sp2_:1}] := 
	Module[{i,j,U,V,UU,VV,ulow,uhigh,vlow,vhigh,maxval,minval,
		lengths,directions,locations,mlen},
	mlen = Min[sp1,sp2];
	normf[uu_,vv_] = Sqrt[function[[1]]^2+function[[2]]^2]/.
		{var1->uu,var2->vv};
	lengths = Table[N[normf[U,V]],{U,a,b,sp1},{V,c,d,sp2}];
	maxval = Max[lengths]; minval = Min[lengths];
	If[minval == maxval,maxval += 1];
	locations = Table[{uu,vv},{uu,a,b,sp1},
		{vv,c,d,sp2}];
	directions = Table[If[N[normf[U,V]]==0,{0,0},
		mlen (function/.{var1->U,var2->V})/(1.3 N[normf[U,V]])],
			{U,a,b,sp1},{V,c,d,sp2}];
	{UU,VV} = Dimensions[directions][[{1,2}]];
	Return[Table[Arrow[directions[[i,j]],
			Tail->locations[[i,j]],Aperture->1,
			HeadRatio->.4,ShaftWidth->0.008, VectorColor->
			RGBColor[(lengths[[i,j]] - minval)/(maxval-minval),0,
				(maxval -lengths[[i,j]])/(maxval-minval)]],{i,UU},{j,VV}]]
		]
		
VectorField[function_,{var1_,a_,b_,sp1_:1},{var2_,c_,d_,sp2_:1}] :=
	VectorField[{1,function},{var1,a,b,sp1},{var2,c,d,sp2}]
	
	
Needs["Utilities`FilterOptions`"]

FixOptions[a_] := Module[{picture = a, opt3},
If[Options[picture] != {}, 
	opt3 = FilterOptions[Graphics3D,#]&/@Options[picture];
	(* Fix things that might carry 2D characteristics. *)
	opt3 = opt3//. {(AxesLabel -> _) ->(AxesLabel -> None),
			(PlotRange->_) -> (PlotRange->Automatic),
			(PlotRegion -> _) -> (PlotRegion -> Automatic),
			(Ticks -> _) -> (Ticks -> Automatic)};
	picture = Apply[List,picture];
	picture[[-1]] = opt3;
	picture = Apply[Graphics3D,picture]];
	Return[picture]
	]

StikPikXZ[picture_,a_:0] := Module[{PIK3 = picture},
	PIK3 = PIK3//.{Graphics->Graphics3D,
		{u_?NumberQ,v_?NumberQ}:>{u,a,v}};
	PIK3 = FixOptions[PIK3];
	Return[PIK3]
		]


StikPikYZ[picture_,a_:0] := Module[{PIK3 = picture},
	PIK3 = PIK3//.{Graphics->Graphics3D,
		{u_?NumberQ,v_?NumberQ}:>{a,u,v}};
	PIK3 = FixOptions[PIK3];
	Return[PIK3]
		]


StikPikXY[picture_,a_:0] := Module[{PIK3 = picture},
	PIK3 = PIK3//.{Graphics->Graphics3D,
		{u_?NumberQ,v_?NumberQ}:>{u,v,a}};
	PIK3 = FixOptions[PIK3];
	Return[PIK3]
		]
		
End[];

EndPackage[];
Null

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].";

Crisscross

Clear[x];
crisscross = Plot[{Cos[x],Sin[x]},{x,Pi/8,3 Pi/8},
    PlotStyle->{{RGBColor[1,0,0],Thickness[0.02]}},
    Axes->None,AspectRatio->1/3,
    DisplayFunction->Identity];

B.1) Linear systems are diffeq systems you can make with a coefficient matrix of numbers

B.1.a.i)

Here's a diffeq system:

\(Clear[x, y, t]; 

    diffeqsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {2.9\ x[t]\  + \ 0.4\ y[t], \(-1.4\)\ x[t]\  + \ 0.6\ y[t]})\); 

    ColumnForm[Thread[diffeqsystem]]\)

How do you tell that this diffeq system is a linear system?

You can tell it's a linear system because you can make it with a matrix. 
Here's how:
Take another look:

ColumnForm[Thread[diffeqsystem]]

You can read off a matrix   A:

A = {{2.9, 0.4}, {-1.4, 0.6}}; MatrixForm[A]

Now you can use this matrix to write the given linear system in this compact way:

\(linearsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)

Compare:

ColumnForm[Thread[diffeqsystem]]

Any diffeq system you can make with a coefficient matrix of numbers is a linear system.

B.1.a.ii)

Here's another diffeq system:

\(Clear[x, y, t]; 

    diffeqsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {2.9\ x[t]^2\  + \ 0.4\ y[t], 
            \(-1.4\)\ x[t]\ y[t]\  + \ 0.6\ y[t]})\); 

    ColumnForm[Thread[diffeqsystem]]\)

How do you tell that this diffeq system is not a linear system?

Take another look:

ColumnForm[Thread[diffeqsystem]]

You can tell that this is not a linear system because there is no way to get that 
           x[t]^( 2)
or that
           x[t] y[t] 
term by multiplying {x[t], y[t]} by a coefficient matrix of numbers.

B.2) Eigenvectors of the coefficient matrix give the directions of propellers and suckers.
        Eigenvalues of the coefficient matrix measure the strengths of propellers and suckers

B.2.a.i) Eigenvectors: Suckers and propellers

Here's a linear system of differential equations:

\(Clear[x, y, t]; 

    linearsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {1.75\ x[t]\  + \ 2.17\ y[t], 2.17\ x[t]\  - \ 0.75\ y[t]})\)\)

Here it is in slightly better form:

ColumnForm[Thread[linearsystem]]

Read off the coefficient matrix  A:

A = {{1.75, 2.17}, {2.17, -0.75}}; MatrixForm[A]

Now you can use this matrix to write the given linear system in this compact way:

\(Clear[x, y, t]; 

    matrixlinearsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 

    ColumnForm[Thread[matrixlinearsystem]]\)

Introducing the cofficient matrix   A makes it really easy to write down the flow field for this linear system:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}\)

Look at the scaled flow:

\(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.3, HeadSize -> 0.6], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; 

    \(Show[flowplot, Axes -> True, 
      AxesLabel -> {"x", "y"}]; \)\)

Look at this flow carefully.
After you've got a good feel for this flow, let    Mathematica calculate two special vectors related to the coefficient matrix A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Plot scaled versions of these special vectors and their negatives together with the field:

scalefactor = 3.5;
headsize = 1;
revealer=Show[flowplot,
		Arrow[eigenvector[1],Tail -> {0, 0},VectorColor -> Red,ScaleFactor -> scalefactor,HeadSize -> headsize],
		Arrow[-eigenvector[1],Tail -> {0, 0},VectorColor -> Red,ScaleFactor -> scalefactor,HeadSize -> headsize],
		Arrow[eigenvector[2],Tail -> {0, 0},VectorColor -> Red,ScaleFactor -> scalefactor,HeadSize -> headsize],
		Arrow[-eigenvector[2],Tail -> {0, 0},VectorColor -> Red,ScaleFactor -> scalefactor,HeadSize -> headsize],Axes -> True,AxesLabel -> {"x", "y"}];

Hot plot.
Describe what you see.

Take another look:

Show[revealer, PlotLabel -> "Flow with eigenvectors"];

The eigenvectors tell all!
The flow is sucked toward {0, 0}  by the influence of the eigenvectors on the upper left and lower right.

Then the flow is propelled away from {0, 0} by the influence of the eigenvectors on the lower left and upper right.

B.2.a.ii) Eigenvectors: Suckers and propellers

Try it again with this new linear system: 
        x'[t]  =  -1.4 x[t]  -  1.3 y[t]
        y'[t]  =    0.5 y[t].
The coefficient matrix is:

A = {{-1.4, -1.3}, {0, 0.5}}; MatrixForm[A]

Compare with the given linear system
         x'[t]  =  -1.4 x[t]  -  1.3 y[t]
         y'[t]  =    0.5 y[t]:

\(Clear[x, y, t]; 

    matrixlinearsystem\  = \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 

    ColumnForm[Thread[matrixlinearsystem]]\)

That's the right matrix.
Look at the flow:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}\)\(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.3, HeadSize -> 0.25], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; 

    \(Show[flowplot, Axes -> True, 
      AxesLabel -> {"x", "y"}]; \)\)

Look at this flow carefully.
After you've got a good feel for this flow, let Mathematica calculate the eigenvectors of the matrix A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Plot scaled versions of these special vectors and their negatives together with the field:

scalefactor = 3.5; headsize = 1; eigenplot = 
      Show[flowplot, 
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[1], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[2], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], Axes -> True, 
        AxesLabel -> {"x", "y"}];

Another hot plot.
Describe what you see.

Take another look:

Show[eigenplot, PlotLabel -> "Flow with eigenvectors"];

The eigenvectors tell all!
The flow is sucked toward {0, 0}  by the influence of the eigenvectors that point down the horizontal axis.

Then the flow is propelled away from {0, 0} by the influence of the eigenvectors on the upper left and lower right.

B.2.a.iii) Eigenvectors: Suckers and no propellers

Try it again with this new linear system: 
        x'[t]  =  -0.57 x[t]  +  0.17 y[t]
        y'[t]  =    0.17 x[t]  -  0.93 y[t].
The coefficient matrix you want is:

A = {{-0.57, 0.17}, {0.17, -0.93}}; MatrixForm[A]

Compare 
	{x'[t], y'[t]}  =  A • {x[t], y[t]} 
with the given linear system:
        x'[t]  =  -0.57 x[t]  +  0.17 y[t]
        y'[t]  =    0.17 x[t]  -  0.93 y[t]:

\(Clear[x, y, t]; 

    linearsystem\  = \ \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

That's the right matrix.
Look at the flow:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}\)flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.35, HeadSize -> 0.25], {x, -3, 3, 
          (6/12)}, {y, -3, 3, (6/12)}]; Show[flowplot, Axes -> True, 
      AxesLabel -> {"x", "y"}];

Look at this flow carefully.
After you've got a good feel for this flow, let Mathematica calculate the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Plot these special vectors and their negatives together with the field:

scalefactor = 3.0; headsize = 1; eigenplot = 
      Show[flowplot, 
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[1], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[2], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], Axes -> True, 
        AxesLabel -> {"x", "y"}];

Describe what you see.

Take another look:

Show[eigenplot, PlotLabel -> "Flow with eigenvectors"];

Both eigenvectors work together to suck the flow toward {0, 0}.

The sucking influence of the sucker eigenvectors on the upper left and lower right is a bit stronger than the sucking influence of the sucker eigenvectors on the lower left and upper right.

B.2.a.iv) Eigenvectors: Propellers and no suckers

Try it again with this new linear system: 
        x'[t]  =    0.1 x[t]  +  0.5 y[t]
        y'[t]  =  -0.5 x[t]  +  1.5 y[t].
The coefficient matrix is:

A = {{0.1, 0.5}, {-0.5, 1.5}}; MatrixForm[A]

Compare with the given linear system
       x'[t]  =    0.1 x[t]  +  0.5 y[t]
       y'[t]  =  -0.5 x[t]  +  1.5 y[t]:

\(Clear[x, y, t]; 

    linearsystem\  = \ \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

That's the right matrix.
Look at the flow:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 

    \(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.35, HeadSize -> 0.3], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; \)\)Show[flowplot, Axes -> True, 
      AxesLabel -> {"x", "y"}];

Look at this flow carefully.

After you've got a good feel for this flow, let Mathematica calculate the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Plot scaled versions these eigenvectors and their negatives together with the field:

scalefactor = 3.5; headsize = 1; eigenplot = 
      Show[flowplot, 
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[1], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[-eigenvector[2], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], Axes -> True, 
        AxesLabel -> {"x", "y"}];

Describe what you see.

Take another look:

plot1 = 
      Show[eigenplot, PlotLabel -> "Flow with eigenvectors"];

Both eigenvectors work together to propell the flow away from {0, 0}.

The influence of the following two propelling eigenvectors is not very strong:

Show[flowplot, 
      Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> scalefactor, HeadSize -> headsize], 
      Arrow[-eigenvector[2], Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> scalefactor, 
        HeadSize -> headsize], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Weak propellers"];

The dominant propelling influence comes from the other eigenvectors:

Show[flowplot, 
      Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> scalefactor, HeadSize -> headsize], 
      Arrow[-eigenvector[1], Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> scalefactor, 
        HeadSize -> headsize], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Strong propellers"];

The flow is greatly influenced by these two dominant eigenvectors.

B.2.b.i) Eigenvalues tell you whether an eigenvector is a propeller or a sucker

How do you use Mathematica to tell in advance whether an eigenvector is a sucker or a propeller?

It's not very hard.
For instance when you come across a linear system like this:
        x'[t]  =  1.75 x[t]   +   1.8 y[t]
        y'[t]  =  2.17 x[t]  -  0.75 y[t].
The coefficient matrix is:

\(A\  = \ {{1.75, 1.8}, {2.17, \(-0.75\)}}; 
MatrixForm[A]
\)\(Clear[x, y, t]; 

    linearsystem\  = \ \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

You ask Mathematica for the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Now you ask for the eigenvalues of A:

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]

Eigenvalue[1] is positive. This tells you that eigenvector[1] is a propeller.  Check it out:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 

    \(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.2, HeadSize -> 0.3], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; \)\)Show[flowplot, 
      Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 3, HeadSize -> 1], 
      Arrow[-eigenvector[1], Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 3, HeadSize -> 1], 
      Axes -> True, AxesLabel -> {"x", "y"}];

Yes, eigenvector[1] is a propeller.
You knew this in advance because you knew that  eigenvalue[1] is positive:

eigenvalue[1]

Now look at  eigenvalue[2]:

eigenvalue[2]

Negative. This tells you that  eigenvector[2] is a sucker. 
Check it out:

Show[flowplot, 
      Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 3, HeadSize -> 1], 
      Arrow[-eigenvector[2], Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 3, HeadSize -> 1], 
      Axes -> True, AxesLabel -> {"x", "y"}];

Yes, eigenvector[2] is a sucker.
You knew this in advance because you knew that  eigenvalue[2] is negative:

eigenvalue[2]

B.2.b.ii) Eigenvalues measure the relative strengths of propellers

How do you use Mathematica to measure the relative strengths of two propellers?

When you come across a linear system like this:
        x'[t]=  0.36 x[t] +  0.81 y[t]
        y'[t]=-0.21 x[t] +  1.53 y[t].
The coefficient matrix is:

A = {{0.36, 0.81}, {-0.21, 1.53}}; MatrixForm[A]

Check:

\(Clear[x, y, t]; 

    linearsystem\  = \ \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

You ask Mathematica for the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Now you ask for the eigenvalues of A:

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]

Both eigenvalue[1] and eigenvalue[2] are positive. This signals that both eigenvector[1] and eigenvector[2] are propellers.

But eigenvalue[1]is more than twice the size of eigenvalue[2].  

This tells you that the dominant propeller is eigenvector[1]. 
Check it out:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 
\(scalefactor = 0.35; 
    \)\)flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.4, HeadSize -> 0.3], {x, -3, 3, 
          (6/12)}, {y, -3, 3, (6/12)}]; \(\(Show[flowplot, 
	
      Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 4.0, HeadSize -> 1], 
      Arrow[\(-eigenvector[1]\), Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 4.0, 
        HeadSize -> 1], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Dominant propeller"]; \)\)

Look at the field vectors.  Yes, eigenvector[1] is the dominant propeller. 
Check out eigenvector[2]:

\(\(Show[flowplot, 
	
      Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 4.0, HeadSize -> 1], 
      Arrow[\(-eigenvector[2]\), Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 4.0, 
        HeadSize -> 1], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Weaker propeller"]; \)\)

Look at the field vectors.  A much weaker propeller.
You knew this in advance because you knew that 
eigenvalue[1]  >  eigenvalue[2]  >  0.

{eigenvalue[1], eigenvalue[2]}

B.2.b.iii) Eigenvalues measure the relative strengths of suckers

How can you use Mathematica to measure the relative strengths of two suckers?

When you come across a linear system like this:
        x'[t]  =  -0.88 x[t]  +  0.16 y[t]
        y'[t]  =    0.54 x[t]  -  0.92 y[t].
The matrix you want is:

\(A\  = \ {{\(-0.88\), 0.16}, {0.54, \(-0.92\)}}; 
MatrixForm[A]
\)\(Clear[x, y, t]; 

    linearsystem\  = \ \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

You ask Mathematica for the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

Now you ask for the eigenvalues of A:

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]

Both eigenvalue[1] and eigenvalue[2] are negative. 
This tells you that both eigenvector[1] and eigenvector[2] are suckers.  

But  eigenvalue[1] is about twice as negative as eigenvalue[2].  
This tells you that the dominant sucker is eigenvector[1]. 
Check it out:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 

    \(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.35, HeadSize -> 0.3], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; \)\)\(\(Show[flowplot, 
	
      Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 3.0, HeadSize -> 1], 
	
      Arrow[\(-eigenvector[1]\), Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 3.0, 
        HeadSize -> 1], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Dominant sucker"]; \)\)

Look at the field vectors.  Yes, eigenvector[1] is the dominant sucker. 
Check out eigenvector[2]:

\(\(Show[flowplot, 
      Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
        ScaleFactor -> 3.0, HeadSize -> 1], 
	
      Arrow[\(-eigenvector[2]\), Tail -> {0, 0}, 
        VectorColor -> Red, ScaleFactor -> 3.0, 
        HeadSize -> 1], Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Weaker sucker"]; \)\)

Look at the field vectors.  A much weaker sucker.
You knew this in advance because you knew that 
       eigenvalue[1]  <  eigenvalue[2]  <  0.

B.3) How you can use eigenvectors and eigenvalues to understand 
        where exact formulas for solutions of linear systems come from

Here's a random coefficient matrix for a random linear system:

\(A\  = 
      \ {{Random[Real, {\(-2\), 2}], Random[Real, {\(-2\), 2}]}, 

        \ \ \ \ \ {Random[Real, {\(-2\), 2}], Random[Real, {\(-2\), 2}]}}; 

    Clear[x, y, t]; 

    linearsystem\  = \ 
\ \ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)

With random starter data on {x[0], y[0]}:

{xstarter, ystarter} = {Random[Real, {-2, 2}], 
        Random[Real, {-2, 2}]}

Formulas for the solution pair {x[t], y[t]} of this linear system with this starter data are:

Clear[eigenvector, eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Chop[Eigenvalues[A]]; \({eigenvector[1], eigenvector[2]} = Chop[Eigenvectors[A]]; 


    Clear[x, y, x1, y1, x2, y2, t, C1, C2]; 
    
{x1[t_], y1[t_]} = Chop[eigenvector[1]\ Exp[eigenvalue[1]\ t]]; 

    \({x2[t_], y2[t_]} = Chop[eigenvector[2]\ Exp[eigenvalue[2]\ t]]; \)\)\({x[t_], y[t_]} = C1\ {x1[t], y1[t]} + C2\ {x2[t], y2[t]}; 


    starter = {xstarter, ystarter}; 

    \(starterequation = {x[0], y[0]} == starter; \)\)\(Csols = Solve[starterequation]; 

    
{x[t_], y[t_]} = 
      Chop[ComplexExpand[{x[t], y[t]} /. 
            Csols[[1]]]]\)

Check:

Expand[{x'[t],y'[t]}]==Expand[A . {x[t], y[t]}]{x[0], y[0]} == {xstarter, ystarter}

See part of the corresponding trajectory:

endtime = 3; 
    ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
      PlotStyle -> {{Thickness[0.01], CadmiumOrange}}, 
      AxesLabel -> {"x", "y"}, AspectRatio -> 1, 
      Epilog -> {PointSize[0.03], Red, Point[{xstarter, ystarter}]}];

Note how the eigenvalues of the coefficient matrix show up in the formula for the solution:

{x[t], y[t]}Chop[Eigenvalues[A]]

Give it another whirl with a different random linear system with a different random starting point for {x[0],  y[0]}:

\(
A\  = 
      \ {{Random[Real, {\(-2\), 2}], Random[Real, {\(-2\), 2}]}, 

        \ \ \ \ \ {Random[Real, {\(-2\), 2}], Random[Real, {\(-2\), 2}]}}; 

    Clear[x, y, t]; 

    linearsystem\  = \ 
\ \ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)\({xstarter, ystarter}\  = 
      \ {Random[Real, {\(-2\), 2}], Random[Real, {\(-2\), 2}]}; 

    \(({x[0], y[0]}\  == \ starter)\)
\ \)\(Clear[eigenvector, eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]}\  = \ Chop[Eigenvalues[A]]; 
    
{eigenvector[1], eigenvector[2]}\  = \ Chop[Eigenvectors[A]]; 


    Clear[x, y, x1, y1, x2, y2, t, C1, C2]; 
    
{x1[t_], y1[t_]}\  = \ Chop[eigenvector[1]\ Exp[eigenvalue[1]\ t]]; 
    
{x2[t_], y2[t_]}\  = \ \ Chop[eigenvector[2]\ Exp[eigenvalue[2]\ t]]; 

    
{x[t_], y[t_]}\  = \ C1\ {x1[t], y1[t]}\  + \ C2\ {x2[t], y2[t]}; 


    starter\  = \ {xstarter, ystarter}; 

    starterequation\  = \ \(({x[0], y[0]}\  == \ starter)\); 

    Csols\  = \ Solve[starterequation]; 

    
{x[t_], y[t_]}\  = \ 
      Chop[ComplexExpand[{x[t], y[t]} /. Csols[\([1]\)]]]
\)

Note how the formulas are related to the eigenvalues of the coefficient matrix:

{x[t], y[t]}Eigenvalues[A]

If you want to see why these formulas came out the way they did, then jump into B.3) and follow it up with a healthy romp in B.4)

B.3.a.i) Straight line trajectories along eigenvectors.

Here's a linear system of differential equations:

\(Clear[x, y, t]; 

    linearsystem\  = \ 

      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {0.84\ x[t]\  + \ 0.90\ y[t], \ 0.40\ x[t]\  - \ 0.31\ y[t]})\); 
    

ColumnForm[Thread[linearsystem]]\)

You read off the coefficient matrix A:

A = {{0.84, 0.90}, {0.40, -0.31}}; MatrixForm[A]

Check:

ColumnForm[Thread[{x'[t], y'[t]}  ==  A . {x[t], y[t]}]]

Good.
You ask for the eigenvectors:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Eigenvectors[A]

The eigenvalues:

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]

The flow with eigenvectors:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 

    \(flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.4, HeadSize -> 0.3], {x, \(-3\), 3, 
          6\/12}, {y, \(-3\), 3, 6\/12}]; \)\)eigenplot = 
      Show[flowplot, 
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> 3.5, HeadSize -> 1], 
        Arrow[-eigenvector[1], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> 3.5, 
          HeadSize -> 1], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> 3.5, HeadSize -> 1], 
        Arrow[-eigenvector[2], Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> 3.5, 
          HeadSize -> 1], Axes -> True, 
        AxesLabel -> {"x", "y"}];

Note that the flow along each plotted eigenvector is a straight line determined by the eigenvector you are looking at.
Now look at these calculations:

\(Clear[s]; 

    A . \((s\ eigenvector[1])\) == eigenvalue[1]\ \((s\ eigenvector[1])\)\)

And:

A . (s eigenvector[2]) == 
      eigenvalue[2] (s eigenvector[2])

How do you use these calculations to explain why the trajectories along the eigenvectors are straight lines?

Look again:

Show[eigenplot];

And look at the calculations again.

Clear[s];
A.(s eigenvector[1])==eigenvalue[1] (s eigenvector[1])

And:

A.(s eigenvector[2])==eigenvalue[2] (s eigenvector[2])

Remembering that the linear system is
       {x'[t], y'[t]}  =  A . {x[t], y[t]}, 
this tells you that if {x[t], y[t]} is a multiple of one of the eigenvectors, then 
       {x'[t], y'[t]}  
is forced to point in the same (or opposite) direction as the eigenvector points.  

The upshot:
If a trajectory hits the line determined by one of the eigenvectors, it has no choice but to run along the line determined by that eigenvector.

Here's a plot of a solution that starts right on the middle of     eigenvector[1]:

multiplier = 0.5; {a, b} = multiplier eigenvector[1]; starterpoint = {a, b};

Clear[x, y, t, m, n];
{m[x_, y_], n[x_, y_]} = A . {x, y};
xequation=x'[t]==m[x[t], y[t]];yequation=y'[t]==n[x[t], y[t]];xstarter = x[0] == a; ystarter = y[0] == b; \(endtime = 2.5; 


    approxsolutions = 
      NDSolve[{xequation, yequation, xstarter, ystarter}, {x[t], y[t]}, {t, 
          0, endtime}]; 

Clear[trajectory]; 

    trajectory[t_] = {
        x[t] /. approxsolutions[[1]], 
        y[t] /. approxsolutions[[1]]}; 

    
trajectoryplot = 
      ParametricPlot[trajectory[t], {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 


    starterplot = Graphics[{Red, PointSize[0.04], Point[starterpoint]}]; 


    Show[eigenplot, starterplot, trajectoryplot, PlotRange -> All, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> "Trajectory along an eigenvector"]; \)

Propelled away from {0, 0} on the straight line trajectory determined by   eigenvector[1].
Check out what happens when you start a trajectory at 
           1.9 eigenvector[2]:

multiplier = 1.9; {a, b} = multiplier eigenvector[2]; starterpoint = {a, b}; Clear[x, y, t, m, n];
{m[x_, y_], n[x_, y_]} = A . {x, y};
xequation=x'[t]==m[x[t], y[t]];yequation=y'[t]==n[x[t], y[t]];xstarter = x[0] == a; ystarter = y[0] == b; endtime = 4; approxsolutions = 
      NDSolve[{xequation, yequation, xstarter, ystarter}, {x[t], y[t]}, {t, 
          0, endtime}]; \(Clear[trajectory]; 

    trajectory[t_] = {
        x[t] /. approxsolutions[[1]], 
        y[t] /. approxsolutions[[1]]}; 

    \(trajectoryplot = 
      ParametricPlot[trajectory[t], {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{Red, PointSize[0.04], Point[starterpoint]}]; 
    \)\)\)Show[eigenplot, starterplot, trajectoryplot, 
      PlotRange -> All, Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> "Trajectory along an eigenvector"];

Sucked towards {0, 0} on the straight line trajectory determined by   eigenvector[2].
Play with different starter points on the eigenvectors and different endtimes.

B.3.a.ii) Formulas for the straight line trajectories

Stay with the same linear system as above.  Formulas for the trajectories that start on the tips of the eigenvector[1] and eigenvector[2] are:

Clear[x1, y1, x2, y2, t];
{x1[t_], y1[t_]}=eigenvector[1] (E^(eigenvalue[1] t)){x2[t_], y2[t_]}=eigenvector[2] (E^(eigenvalue[2] t))

Explain where these formulas come from.

Answer:

The key idea comes from these calculations:

\(Clear[s]; 

    A . \((s\ eigenvector[1])\) == eigenvalue[1]\ \((s\ eigenvector[1])\)\)

And:

A . (s eigenvector[2]) == 
      eigenvalue[2] (s eigenvector[2])

The linear system is
           {x'[t], y'[t]}  =  A . {x[t], y[t]}.
          
If {x1[t], y1[t]} is on a multiple of eigenvector[1], then
           {x1'[t], y1'[t]}  =  
        A . {x1[t], y1[t]}  =  eigenvalue[1]  {x1[t], y1[t]}.
       
This gives
            x1'[t]  =  eigenvalue[1] x1[t]
            y1'[t]  =  eigenvalue[1] y1[t].
These are both exponential differential equations, and you know that these give you
           x1[t]  =  x1[0] Exp[eigenvalue[1] t]
           and 
           y1[t]  =  y1[0] Exp[eigenvalue[1] t].
        
This gives 
          {x1[t], y1[t]}  =  
         {x1[0], y1[0]} Exp[eigenvalue[1] t] .
where {x1[0], y1[0]} is the starter point at the tip of eigenvector[1].
Check this out:

\(Clear[x1, y1, t]; 
    
{x1[t_], y1[t_]} = eigenvector[1]\ Exp[eigenvalue[1]\ t]\)

{x1'[t],y1'[t]}==A . {x1[t], y1[t]}

{x1[0], y1[0]} == eigenvector[1]

This tells you that 
         {x1[t], y1[t]} 
solves the linear system
         {x1'[t], y1'[t]}  =  A . {x1[t], y1[t]}.
with 
         {x1[0], y1[0]}  =  eigenvector[1].
See these formulas for x1[t] and y1[t] plot out this straight line trajectory:

endtime = 1.5; \(eigentrajectoryplot = 
      ParametricPlot[{x1[t], y1[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{Red, PointSize[0.04], Point[{x1[0], y1[0]}]}]; 
    \)\)Show[eigenplot, starterplot, eigentrajectoryplot, 
      PlotRange -> All, Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> "Trajectory along an eigenvector"];

Similarly, the formulas for solutions coming from the straight line trajectory coming from       eigenvector[2] are:

\(Clear[x2, y2, t]; 
    
{x2[t_], y2[t_]} = eigenvector[2]\ Exp[eigenvalue[2]\ t]\)

Check it out:

{x2'[t],y2'[t]}==A . {x2[t], y2[t]}

{x2[0], y2[0]} == eigenvector[2]

See it now:

endtime = 5.5; \(eigentrajectoryplot = 
      ParametricPlot[{x2[t], y2[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{Red, PointSize[0.04], Point[{x2[0], y2[0]}]}]; 
    \)\)Show[eigenplot, starterplot, eigentrajectoryplot, 
      PlotRange -> All, Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> "Trajectory along an eigenvector"];

B.3.a.iii) Formulas for other trajectories

Stay with the same linear system and matrix A.
Here are straight line solution pairs starting at the tips of each of the eigenvectors:

Clear[x1, y1, x2, y2, t];
{x1[t_], y1[t_]}=eigenvector[1] (E^(eigenvalue[1] t)){x2[t_], y2[t_]}=eigenvector[2] (E^(eigenvalue[2] t))

Now see how this random combination
        C1 {x1[t], y1[t]}  +  C2 {x2[t], y2[t]
of the straight line solution pairs plots out:

\(C1 = Random[Real, {\(-2\), 2}]; 
C2 = Random[Real, {\(-2\), 2}]; 

    Clear[x, y, t]; 
    
{x[t_], y[t_]} = C1\ {x1[t], y1[t]} + C2\ {x2[t], y2[t]}; 

    \(endtime = 5; \)\)\(curveplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{Thickness[0.015], CadmiumOrange}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{PointSize[0.04], Red, Point[{x[0], y[0]}]}]; 
    \)\)Show[eigenplot, starterplot, curveplot, 
      PlotRange -> {{-4, 4}, {-4, 4}}, Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, PlotLabel -> None]; 
    {x[t], y[t]}Eigenvalues[A]

Damned if those curves don't look like trajectories!
Check out 
       {x[t], y[t]}  =  C1 {x1[t], y1[t]}  +  C2 {x2[t], y2[t]  
for cleared constants  C1 and C2.

Clear[x, y, t, C1, C2];
{x[t_], y[t_]} = C1 {x1[t], y1[t]} + C2 {x2[t], y2[t]};
{x'[t],y'[t]}==Expand[A . {x[t], y[t]}]

What's the message?

The message is: 
When you go with straight line trajectory solutions 
       {x1[t],  y1[t]} and {x2[t],  y2[t]}
coming from the tips of  eigenvector[1] and eigenvector[2],
and you go with and two  constants  C1 and C2 you like, then any combination {x[t], y[t]} like this:

Clear[x, y, t, C1, C2];
{x[t_], y[t_]}=C1 {x1[t], y1[t]}+C2 {x2[t], y2[t]}

gives you a formula for a solution pair {x[t], y[t]} (a trajectory) of the linear system
      {x'[t], y'[t]}  =  A . {x[t], y[t]}. 
Check:

{x'[t],y'[t]}==Expand[A . {x[t], y[t]}]

You can explain why this happens this way:        
          
      A . {x[t], y[t]}  =  
        A . (C1 {x1[t], y1[t]}  +  C2 {x2[t], y2[t]}) 
			      
         =  C1 A . {x1[t], y1[t]}  +  C2 A . {x2[t], y2[t]})
       	\(\(											\ \ \ \ \ \ 
      \( = \ C1\ {\(x1'\)[t], \(y1'\)[t]}\  + \ 
          C2 {\(x2'\)[t], \(y2'\)[t]}\)\)\)
        \(\(															\  = {\(x'\)[t], \(y'\)[t]}\)\).

B.3.a.iv) The formula for any trajectory

Stay with the same linear system and matrix A.

\(A\  = \ {{0.84, 0.90}, {0.40, \(-0.31\)}}; 
MatrixForm[A]
\)\(Clear[x, y, t]; 

    ColumnForm[Thread[{\(x'\)[t], \(y'\)[t]}\  == \ A . {x[t], y[t]}]]\)

Given starter data 
        {x[0], y[0]}  =  {-0.8, 1.5},
come up with formulas for the functions    x[t] and y[t] that solve this linear system.

Calculate the eigenvalues and the eigenvectors:

\(Clear[eigenvector, eigenvalue]; 
    
{eigenvector[1], eigenvector[2]} = Eigenvectors[A]\){eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]

One sucker and one propeller.
Set up formulas for the straight line trajectories starting at the tips of the two eigenvectors:

\(Clear[x1, y1, x2, y2, t]; 
    
{x1[t_], y1[t_]} = eigenvector[1]\ Exp[eigenvalue[1]\ t]\)

{x2[t_], y2[t_]} = eigenvector[2] Exp[eigenvalue[2] t]

Make a combination of the two straight line formulas but use undetermined cconstant  coefficients    C1 and C2 this way:

Clear[C1, C2];
{x[t_], y[t_]}=C1 {x1[t], y1[t]}+C2 {x2[t], y2[t]}

This trajectory starts at:

{x[0], y[0]}

The given starter data are
          {x[0], y[0]}  =  {-0.8, 1.5}.

starter = {-0.8, 1.5}

Determine the coefficients  C1 and C2 so that 
          {x[0], y[0]}  =  {-0.8, 1.5}:

starterequation = {x[0], y[0]} == starter

Solve for C1 and C2:

Csols = Solve[starterequation]

The formulas you are after are:

{x[t_], y[t_]} = {x[t], y[t]} /. 
        Csols[[1]]

Check it out:

Expand[{x'[t],y'[t]}]==Expand[A . {x[t], y[t]}]

{x[0], y[0]} == starter

See it:

endtime = 3; \(trajectoryplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{Red, PointSize[0.04], Point[{x[0], y[0]}]}]; 
    \)\)Show[eigenplot, starterplot, trajectoryplot, PlotRange -> All, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction];

Perfecto.
Play with other starting points.

B.4) Eigenvectors involving the imaginary number 
        I = (Sqrt[-1]) do not stand in your way; they are swirlers

Just when you thought you were getting good at this, someone flips you this linear system:

\(Clear[x, y, t]; 

    linearsystem\  = \ 
\ \ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {0.3\ x[t]\  + \ 1.5\ y[t], \(-1.7\)\ x[t]\  + \ 0.1\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)

And asks you to come up with formulas for the functions x[t] and y[t] that solve this linear system with starter data
          {x[0], y[0]}  =  {-0.2,  0.3}:

You read off the coefficient matrix A:

A = {{0.3, 1.5}, {-1.7, 0.1}}; MatrixForm[A]

Intent on looking for the straight line trajectory formulas, you calculate the eigenvalues of A,

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Chop[Eigenvalues[A]]

and the eigenvectors of A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Chop[Eigenvectors[A]]

You inspect this carefully and note that the dreaded number 
           I  =  (Sqrt[-1])
is sitting conspicuously in the output. 
But when you use the code at the beginning of B.3) above to go after formulas for the solution pair {x[t], y[t]}, you get:

{xstarter, ystarter} = {-0.2, 0.3}; Clear[eigenvector, eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Chop[Eigenvalues[A]]; \({eigenvector[1], eigenvector[2]} = Chop[Eigenvectors[A]]; 


    Clear[x, y, x1, y1, x2, y2, t, C1, C2]; 
    
{x1[t_], y1[t_]} = Chop[eigenvector[1]\ Exp[eigenvalue[1]\ t]]; 

    \({x2[t_], y2[t_]} = Chop[eigenvector[2]\ Exp[eigenvalue[2]\ t]]; \)\)\({x[t_], y[t_]} = C1\ {x1[t], y1[t]} + C2\ {x2[t], y2[t]}; 


    starter = {xstarter, ystarter}; 

    \(starterequation = {x[0], y[0]} == starter; \)\)\(Csols = Solve[starterequation]; 

    
{x[t_], y[t_]} = 
      Chop[ComplexExpand[{x[t], y[t]} /. 
            Csols[[1]]]]\)

Exponentials combined with sines and cosines.
Compare the formula with the eigenvalues of the coefficient matrix:

Eigenvalues[A]

If you want to see why these formulas came out the way they did, then jump into what follows.

B.4.a.i) Formulas for trajectories

Stay with the same linear system
        {x'[t], y'[t]}  =  A . {x[t] . y[t]}:

\(Clear[x, y, t]; 

    linearsystem\  = \ 
\ \ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {0.3\ x[t]\  + \ 1.5\ y[t], \(-1.7\)\ x[t]\  + \ 0.1\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)

Look again at the eigenvectors of  the coefficient matrix   A:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Chop[Eigenvectors[A]]

and eigenvalues of A:

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Chop[Eigenvalues[A]]

How do you interpret the presence of the complex numbers involving I  = (Sqrt[-1])?

The presence of the complex numbers involving I  =  (Sqrt[-1]) tells you that the straight line trajectories along the eigenvectors are strictly imaginary.  In the real world, there are no straight line trajectories.  Check this out:

\(Clear[Field]; 
Field[x_, y_] = A . {x, y}; 
\(scalefactor = 0.2; 
    \)\)\(flowplot = 
      Table[Arrow[scalefactor\ Field[x, y], Tail -> {x, y}, 
          VectorColor -> Blue, HeadSize -> 0.2], {x, \(-2\), 2, 0.25}, {
          y, \(-2\), 2, 0.25}]; 

    \(Show[flowplot, Axes -> True, 
      AxesLabel -> {"x", "y"}]; \)\)

All the trajectories swirling like all get-out. 
No straight line trajectories here. 
And this was predicted by the presence of I = (Sqrt[-1]) in the output from:

{eigenvalue[1], eigenvalue[2]}

The upshot:
The presence of I  = (Sqrt[-1]) in eigenvalues indicates that the eigenvectors are what DiffEq&Mathematica folks call "swirlers."

B.4.a.iii) Propelling swirlers

Stay with the same linear system.

ColumnForm[Thread[{x'[t], y'[t]}  ==  A . {x[t], y[t]}]]

In spite of the imaginary numbers in the eigenvectors and eigenvalues, come up with formulas for functions x[t] and y[t] that solve this linear system with the starter data
      {x[0], y[0]}  =  {-0.2,  0.3}
given above.

Don't worry about the imaginary numbers and go with them as if they were ordinary numbers:

Clear[eigenvector]; {eigenvector[1], eigenvector[2]} = Chop[Eigenvectors[A]]

Clear[eigenvalue]; {eigenvalue[1], eigenvalue[2]} = Chop[Eigenvalues[A]]

Set up formulas for the (imaginary) straight line trajectories starting at the tips of the two eigenvectors:

Clear[x1, y1, x2, y2, t];
{x1[t_], y1[t_]}=Chop[eigenvector[1] (E^(eigenvalue[1] t))]

{x2[t_], y2[t_]}=Chop[eigenvector[2] (E^(eigenvalue[2] t))]

Make a combination of the two (imaginary) straight line formulas but use undetermined coefficients C1 and C2 this way:

Clear[x, y, t, C1, C2];
{x[t_], y[t_]}=C1 {x1[t], y1[t]}+C2 {x2[t], y2[t]}

This (yet undetermined) trajectory starts at:

{x[0], y[0]}

The given starter data are
      {x[0], y[0]}  =  {-0.2,  0.3}.

starter = {-0.2, 0.3}

Determine the coefficients  C1 and C2 so that
      {x0], y[0]}  =  starter:

starterequation = ({x[0], y[0]} == starter)Csols = Solve[starterequation]

Use these values of C1 and C2 to nail down the solution pair {x[t], y[t]} with {x[0], y[0]}  =  starter:

{x[t_], y[t_]} = {x[t], y[t]} /. 
        Csols[[1]]

Clean this up by having Mathematica apply the fundamental identity 
          (E^((a  +  I b) t)) = 
        ((E )^(a t)) (Cos[b] + i Sin[b]):

\(Clear[cleanx, cleany]; 
    
{cleanx[t_], cleany[t_]} = Chop[ComplexExpand[{x[t], y[t]}]]\)

Check these formulas out:

Expand[{cleanx'[t],cleany'[t]}]==Expand[A . {cleanx[t], cleany[t]}]

{cleanx[0], cleany[0]} == starter

See the flow plot and the corresponding trajectory:

flowplot = 
      Table[Arrow[Field[x, y], Tail -> {x, y}, VectorColor -> Blue, 
          ScaleFactor -> 0.2, HeadSize -> 0.35], {x, -3, 3, 
          (6/12)}, {y, -3, 3, (6/12)}]; endtime = 11.5; \(trajectoryplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; 

    \(starterplot = Graphics[{Red, PointSize[0.04], Point[{x[0], y[0]}]}]; 
    \)\)Show[flowplot, starterplot, trajectoryplot, PlotRange -> All, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction];

Life in the fast lane.
Look at that spiral!
Take another look at the formula for {x[t], y[t]}:

{cleanx[t], cleany[t]}

Look at the eigenvalues of the coefficient matrix:

Eigenvalues[A]

The positive exponent on the exponential explains why the trajectory is propelled away from   {0, 0}. 
Do you see that number anywhere in the eigenvalues?  
The sine and cosine terms explain why the trajectory oscillates around {0, 0}.
Do you see the numbers inside the cosine and sine terms anywhere in the eigenvalues?
The spiral results from the combined effects of the exponential terms and the sine and cosine terms.

B.5) Eigenvalue-trajectory analysis summary:
       Propellers, suckers, pure swirlers, sucking swirlers, and propelling swirlers

B.5.a.i) Two Propellers:
            Two positive eigenvalues

If you find that both eigenvalues of the coefficient matrix   A are positive, then you already know that both eigenvectors are propellers and that all the trajectories are propelled away from {0, 0}.
How do the formulas back this up?

The formulas back this up.
For instance if  
        eigenvalue[1] of A is 0.9 
and 
        eigenvalue[2] of A is 3.0, 
then every trajectory is given by the formula
       {x[t],  y[t]}  =  C1 eigenvector[1](E^( 0.9 t)) + C2 eigenvector[2]((E )^(3.0 t))
The exponential terms  
        (E^( 0.9 t))  and  (E^( 3.0 t)) 
propel the trajectories away from {0, 0}. 

The result:  All solutions go to infinity as t becomes very large.

See two propellers in action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {1.3\ x[t]\  + \ 0.5\ y[t], \ \(-0.3\)\ x[t]\  + \ 1.2\ y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

A = {{1.3, 0.5}, {0.3, 1.2}}; MatrixForm[A]

Check the eigenvalues of the coefficient matrix  A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

Both eigenvalues are positive. This means that both eigenvectors are propellers.  See some random trajectories with scaled eigenvectors:

{xstarter, ystarter} = {Random[Real, {-40, 40}], 
        Random[Real, {-40, 40}]}; endtime = 7; starterpoint = {xstarter, ystarter}; \(Clear[x, y, t]; 
    
{x[t_], y[t_]} = 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]\)trajectoryplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; \(starterplot = Graphics[{Red, PointSize[0.05], Point[starterpoint]}]; 

    
Clear[eigenvector]; 
    
{eigenvector[1], eigenvector[2]} = Eigenvectors[A]; 

    \(scalefactor = 200; \)\)headsize = 50; \(eigenplot = {
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[\(-eigenvector[1]\), Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[\(-eigenvector[2]\), Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize]}; 


    Show[starterplot, trajectoryplot, eigenplot, 
      PlotRange 
        -> {{\(-2\)\ scalefactor, 2\ scalefactor}, {\(-2\)\ scalefactor, 
            2\ scalefactor}}, Axes -> True, 
      AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Two positive eigenvalues", 
      DisplayFunction -> $DisplayFunction]; \)

Off we go into the wild orange yonder.

B.5.a.ii) Two suckers:
             Two negative eigenvalues guarantee {x[t], y[t]}  is sucked to {0, 0}
             no matter what the starting data on {x[0], y[0]} are.

If you find that both eigenvalues of  A are negative, then you already know that both eigenvectors are suckers and all the trajectories are sucked toward {0, 0}. 
This means that if x[t] and y[t] solve the linear system, then you are guaranteed that as t gets large 
           {x[t], y[t]} -> {0, 0} 
no matter what the starting data on {x[0], y[0]} are.
How do the formulas back this up?

The formulas back this up.
For instance if  
        eigenvalue[1] of A is -0.9 
and 
        eigenvalue[2] of A is -3.0, 
then every trajectory is given by the formula
       {x[t],  y[t]}  =  C1 eigenvector[1] (E^(-0.9 t)) + C2 eigenvector[2] (E^(-3.0 t))
The exponential terms  
        (E^(-0.9 t))  and  (E^(-3.0 t))
 suck the trajectories toward the drain at {0, 0}. 
This forces
         {x[t], y[t]}  ->  {0, 0} as  t -> ∞
 no matter what the starting data on {x[0], y[0]} are.

The result:  All solutions end at {0, 0} when t is sufficiently large.

See two suckers in action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {\(-1.3\)\ x[t]\  + \ 0.5\ y[t], \ 0.3\ x[t]\  - \ 1.2\ y[t]})\); 
    
ColumnForm[Thread[linearsystem]]\)

Read off the coefficient matrix:

A = {{-1.3, 0.5}, {0.3, -1.2}}; MatrixForm[A]

Check the eigenvalues of the coefficient matrix A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

Both eigenvalues are negative. This means that both eigenvectors are suckers.  
See some random trajectories with scaled eigenvectors:

ranger = 10; {xstarter, ystarter} = {Random[Real, {-ranger, ranger}], 
        Random[Real, {-ranger, ranger}]}; \(Clear[x, y, t]; 
    
{x[t_], y[t_]} = 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]\)trajectoryplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; starterpoint = {xstarter, ystarter}; \(starterplot = Graphics[{Red, PointSize[0.05], Point[starterpoint]}]; 

    \(scaler = ranger\/3; \)\)\(Clear[eigenvector]; 
    
{eigenvector[1], eigenvector[2]} = Eigenvectors[A]; 

    \(scalefactor = 5; \)\)headsize = 1; \(eigenplot = {
        Arrow[eigenvector[1], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[\(-eigenvector[1]\), Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize], 
        Arrow[eigenvector[2], Tail -> {0, 0}, VectorColor -> Red, 
          ScaleFactor -> scalefactor, HeadSize -> headsize], 
        Arrow[\(-eigenvector[2]\), Tail -> {0, 0}, 
          VectorColor -> Red, ScaleFactor -> scalefactor, 
          HeadSize -> headsize]}; 

    \(Show[starterplot, trajectoryplot, eigenplot, PlotRange -> All, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
      PlotLabel -> "Two negative eigenvalues", 
      DisplayFunction -> $DisplayFunction]; \)\)

Down the drain at {0, 0}.
After you run this several times, you will be able to spot the eigenvector that corresponds to the most negative eigenvalue.

B.5.a.iii) A propeller and a sucker:
             One positive and one negative eigenvalue

If you find that one of the eigenvalues of A is positive and the other eigenvalue of A is negative, then you already know that one eigenvectors is a propeller, the other eigenvector is a sucker and that almost all trajectories end up being propelled away from {0, 0}, but some of the trajectories are sucked toward {0, 0} before they begin their journeys away from {0, 0}. 
How do the formulas back this up?

The formulas back this up.
For instance if  
        eigenvalue[1] of A is -4.8 
and 
        eigenvalue[2] of A is 2.7, 
then every trajectory is given by the formula
       {x[t],  y[t]}  =  C1 eigenvector[1](E^(-4.8 t)) + C2 eigenvector[2](E^(2.7 t))
As t continues to advance from 0, the exponential term 
        (E^(-4.8 t))
eventually decays to 0 but the the exponential term 
        (E^(2.7 t)) 
blasts the trajectories into outerspace in the direction of eigenvector[2] (unless C2  =  0).

The result:  You can expect the trajectories to go to infinity as t becomes very large, but some may move towards {0, 0} first, under the influence of the sucking eigenvector.

See a propeller and a sucker in combined action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {0.8\ x[t]\  + \ 0.2\ y[t], \ 0.4\ x[t]\  - \ 1.2\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]
\)\(A\  = \ {{0.8, 0.2}, {0.4, \(-1.2\)}}; 
MatrixForm[A]\)

Check the eigenvalues of the coefficient matrix A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

Mixed signs. This means one eigenvector is a propeller and the other is a sucker.  See some random trajectoies shown with the eigenvectors:

\(ranger\  = \ 200; 
    
{xstarter, ystarter}\  = 
      \ {Random[Real, {\(-ranger\)/2, ranger/2}], 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 
        Random[Real, {\(-ranger\)/2, ranger/2}]}; 
endtime\  = \ 9; 


    Clear[x, y, t]; 
    
{x[t_], y[t_]}\  = \ 
\ 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]

    \)\(trajectoryplot\  = \ 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
\ \ \ \ \ \ \ 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> Identity]; 

    \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 

    starterpoint\  = \ {xstarter, ystarter}; 
\ \ \ \ \ \ \ 
    starterplot\  = \ 
      Graphics[{Red, PointSize[0.06], 

          \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Point[starterpoint]}]; 
    
scaler\  = \ 0.9\ ranger; 
Clear[eigenvector]; 
    
{eigenvector[1], eigenvector[2]}\  = \ Eigenvectors[A]; 

    eigenplot\  = 
      \ {Arrow[scaler\ eigenvector[1], Tail -> {0, 0}, VectorColor -> Red], 

        \ \ \ \ \ \ \ 
        Arrow[\(-scaler\)\ eigenvector[1], Tail -> {0, 0}, 
          VectorColor -> Red], 
\ \ \ \ \ \ \ 
        Arrow[scaler\ eigenvector[2], Tail -> {0, 0}, VectorColor -> Red], 

        \ \ \ \ \ \ \ 
        Arrow[\(-scaler\)\ eigenvector[2], Tail -> {0, 0}, 
          VectorColor -> Red]}; 

    Show[starterplot, trajectoryplot, eigenplot, 
\ \ \ \ \ 
      PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
\ \ \ \ \ 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> "Eigenvalues of mixed signs"]; \)

After you run this several times, you will be able to spot the propelling eigenvectors that correspond to the the positive eigenvalue but occasionally you will see the initial influence of the sucker.

B.5.a.iv) Two pure swirlers:
             Eigenvalues p  +  I q and p  -  I q with p  =  0 and q not 0

If you find that the eigenvalues of A are of the form:
        p  +  I q and p  -  I q with p  =  0 and q not 0, 
then you know that both eigenvectors are pure swirlers and that all the trajectories will oscillate on ellipses centered on {0, 0}.
How do the formulas back this up?

The formulas back this up.
For instance if  
        eigenvalue[1] of A is 0  +  2.3 I 
and 
        eigenvalue[2] of A is 0  -  2.3 I, 
then every trajectory is given by the formula
       {x[t],  y[t]} =  C1 eigenvector[1](E^(2.3 I t)) +  C2 eigenvector[2]  (E^(-2.3 I t)) 
    
The exponents involving I  =  (Sqrt[-1]) tell you that the trajectories are purely oscillatory.  To see why look at:

Clear[t]; ComplexExpand[(E^(2.3 I t))]

ComplexExpand[(E^(-2.3 I t))]

This tells you that the ingredients in the formula are really combinations of Sin[2.3 t] and Cos[2.3 t]. 
This explains why the trajectories must oscillate along ellipses centered at {0, 0} and why individual solutions are genuine sine and cosine waves.
This is why the corresponding eigenvectors are called swirlers.

The result:  All trajectories oscillate around {0, 0} in the same track, and all solutions oscillate with constant amplitude.

See pure swirlers in action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {\(-1.2\)\ x[t]\  + \ 1.5\ y[t], \ 
            \(-2.3\)\ x[t]\  + \ 1.2\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)\(A\  = \ {{\(-1.2\), 1.5}, {\(-2.3\), 1.2}}; 
MatrixForm[A]\)

Check the eigenvalues of A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

The form is p  +  I q with 
        p  =  0 and q not 0. 
This means that the eigenvectors are pure whirlers (no suck and no propell). 
The same result; the trajectories oscillate around{0, 0} on ellipses. And the solution plots are sine waves.

See some trajectories followed by the corresponding individual solution plots:

ranger = 30; {xstarter, ystarter} = {
        Random[Real, {-(ranger/2), (ranger/2)}], 
        Random[Real, {-(ranger/2), (ranger/2)}]}; \(Clear[x, y, t]; 
Clear[x, y, t]; 
    
{x[t_], y[t_]} = 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]\)trajectoryplot = 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 
        DisplayFunction -> Identity]; starterpoint = {xstarter, ystarter}; starterplot = 
      Graphics[{CadmiumOrange, PointSize[0.06], Point[starterpoint]}]; Show[starterplot, trajectoryplot, 
      PlotRange -> {{-ranger, ranger}, {-ranger, ranger}}, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
      DisplayFunction -> $DisplayFunction, 
      PlotLabel -> 
        "Eigenvalues p + I q and p - I q \n  with p = 0 and q not 0"]; 
    \(xsolutionplot = 
      Plot[x[t], {t, 0, endtime}, 
        PlotStyle -> {{Magenta, Thickness[0.01]}}, 
        AspectRatio -> 1\/3, AxesLabel -> {"t", "x[t]"}, 
        PlotLabel -> "Corresponding x[t] solution plot"]; 

    ysolutionplot = 
      Plot[y[t], {t, 0, endtime}, PlotStyle -> {{Red, Thickness[0.01]}}, 
        AspectRatio -> 1\/3, AxesLabel -> {"t", "y[t]"}, 
        PlotLabel -> "Corresponding y[t] solution plot"]; \)

Elliptical trajectories and corresponding sine wave solutions everytime.

B.5.a.v) Two sucking swirlers:
            Eigenvalues  p  +  I q and p  -  I q with p  <  0 and q not 0 
            guarantee  {x[t], y[t]}  is sucked to {0, 0} no matter what the starting data on {x[0], y[0]} are.

If you find that the eigenvalues of A are of the form:
            p  +  I q and p  -  I q with p  <  0 and q not 0 
then you know that both eigenvectors are sucking swirlers and that all the trajectories will spiral toward {0, 0}, so that all solutions are sucked to 0 no matter what the starting data are.
How do the formulas back this up?

The formulas back this up. 
For instance if 
        eigenvalue[1] of A is -2.7  +  4.2 I 
and 
        eigenvalue[1] of A is -2.7  -  4.2 I, 
then every trajectory is given by the formula
       {x[t],  y[t]} =  C1 eigenvector[1] (E^((-2.7 +  4.2 I) t)) +  eigenvector[2] (E^((-2.7 - 4.2 I) t))

The exponents involving 
         -2.7  +  4.2 I and -2.7  -  4.2 I 
tell you that the trajectories are sucked to {0, 0} and are compelled to spiral as they are sucked.  To see why look at:

Clear[t];
ComplexExpand[(E^((-2.7 + 4.2 I) t))]

Clear[t];
ComplexExpand[(E^((-2.7 - 4.2 I) t))]

This tells you that the terms in the formula
         {x[t],  y[t]}   =   
        C1 eigenvector[1] (E^((-2.7 +  4.2 I) t))  +   
          eigenvector[2] (E^((-2.7 - 4.2 I) t))
are sucked to {0, 0} by the 
          (E^(-2.7 t)) 
factors and they are compelled to oscillate (spiral) along the way by the 
          Sin[4.2 t] and Cos[4.2 t] 
factors. 

The result: The trajectories spiral into {0, 0}. And the solution plots are damped sine waves.

See sucking swirlers in action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {\(-1.2\)\ x[t]\  + \ 1.5\ y[t], \ 
            \(-2.3\)\ x[t]\  + \ 0.9\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]
\)\(A\  = \ {{\(-1.2\), 1.5}, {\(-2.3\), 0.9}}; 
MatrixForm[A]\)

Check the eigenvalues of the coefficient matrix A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

The form is 
       p  +  I q with p  <  0 and q not 0. 
This means that the eigenvectors are sucking swirlers.  See some random trajectories followed by individual corrersponding solution plots:

\(ranger\  = \ 10; 
    
{xstarter, ystarter}\  = 
      \ {Random[Real, {\(-0.8\)\ ranger, 0.8\ ranger}], 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 
        Random[Real, {\(-0.8\)\ ranger, 0.8\ ranger}]}; 
endtime\  = \ 15; 

    
Clear[x, y, t]; 
    
{x[t_], y[t_]}\  = \ 
\ \ \ \ 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]

    \)\(trajectoryplot\  = \ 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
\ \ \ \ \ \ \ 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> Identity]; 

    \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 

    starterpoint\  = \ {xstarter, ystarter}; 
\ \ \ \ \ \ \ 
    starterplot\  = \ 
      Graphics[{Red, PointSize[0.06], 

          \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Point[starterpoint]}]; 
    

Show[starterplot, trajectoryplot, 
\ \ \ \ \ 
      PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
\ \ \ \ \ 
      DisplayFunction -> $DisplayFunction, 
\ \ \ \ \ 
      PlotLabel -> 
        "Eigenvalues p + I q and p - I q 
  with p < 0 and q not 0"]; 

    \ \ \ \ \ 

    xsolutionplot\  = \ 
      Plot[x[t], {t, 0, endtime}, PlotStyle -> {{Magenta, Thickness[0.01]}}, 
        
\ \ \ \ \ \ \ \ \ \ \ AspectRatio -> 1/3, 
        AxesLabel -> {"t", "x[t]"}, 
\ \ \ \ \ \ \ \ \ \ \ 
        PlotLabel -> "Corresponding x[t] solution plot"]; 


    ysolutionplot\  = \ 
      Plot[y[t], {t, 0, endtime}, PlotStyle -> {{Red, Thickness[0.01]}}, 

        \ \ \ \ \ AspectRatio -> 1/3, AxesLabel -> {"t", "y[t]"}, 

        \ \ \ \ \ \ \ \ PlotLabel -> "Corresponding y[t] solution plot"]; 
    
\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \)

Inward spiralling trajectories and corresponding damped sine wave solutions everytime. 
As you can see,  no matter what trajectory {x[t], y[t]} you ride, {x[t], y[t]} is eventually sucked to {0, 0}.

B.5.a.vi) Two propelling swirlers:
             Eigenvalues  p  +  I q and p  -  I q with p  >  0 and q not 0

If you find that the eigenvalues of A are 
         p  +  I q and p  -  I q with p  >  0 and q not 0
then you know that both eigenvectors are propelling swirlers and that all the trajectories will spiral away from {0, 0}.
How do the formulas back this up?

The formulas back this up. 
For instance if 
        eigenvalue[1] of A is 2.1  +  3.5 I 
and 
        eigenvalue[1] of A is 2.1  +  3.5 I, 
then every trajectory is given by the formula:
       {x[t],  y[t]}  =   C1 eigenvector[1](E^((2.1 +  3.5 I) t)) + eigenvector[2](E^((2.1 - 3.5 I) t))

The exponents involving 2.1  +  3.5 I and 2.1  -  3.5 I tell you that the trajectories are propelled away from {0, 0} and are forced to spiral.  To see why look at:

Clear[t]; ComplexExpand[(E^((2.1 + 3.5 I) t))]

Clear[t]; ComplexExpand[(E^((2.1 - 3.5 I) t))]

This tells you that the terms in the formula
        {x[t],  y[t]}   =    
        C1 eigenvector[1] (E^((2.1 +  3.5 I) t))  +  
          eigenvector[2] (E^((2.1 - 3.5 I) t))
are propelled away from {0, 0} by the 
         (E^(2.1 t)) 
factors and they are compelled to oscillate (spiral) by the 
         Sin[3.5 t] and Cos[3.5 t] 
factors. 

The result: The trajectories spiral away from {0, 0}. 

See propelling swirlers in action:

\(Clear[x, y, t]; 

    linearsystem\  = 
\ \ 
      \(({\(x'\)[t], \(y'\)[t]}\  == 
          \ {\(-0.9\)\ x[t]\  + \ 1.5\ y[t], \ 
            \(-2.3\)\ x[t]\  + \ 1.2\ y[t]})\); 

    ColumnForm[Thread[linearsystem]]\)\(A\  = \ {{\(-0.9\), 1.5}, {\(-2.3\), 1.2}}; 
MatrixForm[A]\)

Check the eigenvalues of A:

\(Clear[eigenvalue]; 
    
{eigenvalue[1], eigenvalue[2]} = Eigenvalues[A]\)

The form is 
         p  +  I q with p  >  0 and q  not 0. 
This means that the eigenvectors are propelling swirlers.  See some random trajectories followed by corresponding individual solution plots:

\(ranger\  = \ 200; 
    
{xstarter, ystarter}\  = 
      \ {Random[Real, {\(-ranger\)/8, ranger/8}], 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 
        Random[Real, {\(-ranger\)/8, ranger/8}]}; 
endtime\  = \ 12; 

    Clear[x, y, t]; 
    
{x[t_], y[t_]}\  = \ 
\ \ \ \ 
      Chop[ComplexExpand[Expand[MatrixExp[A\ t] . {xstarter, ystarter}]]]


    \)\(trajectoryplot\  = \ 
      ParametricPlot[{x[t], y[t]}, {t, 0, endtime}, 
\ \ \ \ \ \ \ 
        PlotStyle -> {{CadmiumOrange, Thickness[0.015]}}, 

        \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ DisplayFunction -> Identity]; 

    \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ 

    starterpoint\  = \ {xstarter, ystarter}; 
\ \ \ \ \ \ \ 
    starterplot\  = \ 
      Graphics[{Red, PointSize[0.06], 

          \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ Point[starterpoint]}]; 
    

\ \ \ \ \ 

    Show[starterplot, trajectoryplot, 
\ \ \ \ \ 
      PlotRange -> {{\(-ranger\), ranger}, {\(-ranger\), ranger}}, 
      Axes -> True, AxesLabel -> {"x", "y"}, 
\ \ \ \ \ 
      DisplayFunction -> $DisplayFunction, 
\ \ \ \ \ 
      PlotLabel -> 
        "Eigenvalues p + I q and p - I q 
  with p > 0 and q not 0"]; 

    \ \ \ \ \ 

    xsolutionplot\  = \ 
      Plot[x[t], {t, 0, endtime}, PlotStyle -> {{Magenta, Thickness[0.01]}}, 
        
\ \ \ \ \ \ \ \ \ \ \ AspectRatio -> 1/3, 
        AxesLabel -> {"t", "x[t]"}, 
\ \ \ \ \ \ \ \ \ \ \ 
        PlotLabel -> "Corresponding x[t] solution plot"]; 


    ysolutionplot\  = \ 
      Plot[y[t], {t, 0, endtime}, PlotStyle -> {{Red, Thickness[0.01]}}, 

        \ \ \ \ \ AspectRatio -> 1/3, AxesLabel -> {"t", "y[t]"}, 

        \ \ \ \ \ \ \ \ PlotLabel -> "Corresponding y[t] solution plot"]; 
    \)

Outward spiraling trajectories and corresponding increasingly excited sine wave solutions everytime.